@drip-apex/sdk 0.1.0

package/src/commerce-gift.test.ts

@@ -0,0 +1,1293 @@
+// @vitest-environment jsdom
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { __giftManagerInternals, getPendingGiftChoices, noteCartSnapshotForGifts, selectGiftOption, syncGiftWithPurchase } from "./commerce-gift";
+import { onShopifyCartMutation } from "./shopify-cart-events";
+
+const experimentId = "exp-gwp";
+const settings = (variant: Record<string, unknown> = {
+  offer_type: "gwp_threshold",
+  threshold: "5000",
+  gift_variant_gid: "gid://shopify/ProductVariant/9",
+}) => ({
+  authorization: {
+    version: 1 as const,
+    revision: 1,
+    checksum: "a".repeat(64),
+    experimentIds: [experimentId, "exp-gwp-2"],
+  },
+  experiments: [{ experiment_id: experimentId, currency: "USD", variants: { treatment: variant } }],
+});
+const assignments = [{ experimentId, variationId: "treatment" }];
+const cart = (items: unknown[], currency = "USD", token?: string) => ({
+  currency,
+  items,
+  ...(token ? { token } : {}),
+});
+const merchandise = { key: "merch", variant_id: 1, line_price: 5000, properties: {} };
+const apexGift = { key: "gift-key", variant_id: 9, line_price: 0, properties: { _apex_gwp: experimentId } };
+
+function response(body: unknown, ok = true): Response {
+  return { ok, json: async () => body } as Response;
+}
+
+beforeEach(() => {
+  vi.restoreAllMocks();
+  __giftManagerInternals.reset();
+  sessionStorage.clear();
+  localStorage.clear();
+  (window as Window & { Shopify?: unknown }).Shopify = { routes: { root: "/" } };
+});
+
+describe("gift-with-purchase manager", () => {
+  it("adds one marked gift when treatment merchandise reaches the threshold", async () => {
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/add.js", expect.objectContaining({
+      method: "POST",
+      body: JSON.stringify({ items: [{ id: 9, quantity: 1, properties: { _apex_gwp: experimentId } }] }),
+    }));
+  });
+
+  it("removes only the Apex-managed gift below threshold", async () => {
+    const shopperGift = { key: "shopper-gift", variant_id: 9, line_price: 0, properties: {} };
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([{ ...merchandise, line_price: 4999 }, apexGift, shopperGift]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    expect(fetch).not.toHaveBeenCalledWith("/cart/change.js", expect.objectContaining({ body: expect.stringContaining("shopper-gift") }));
+  });
+
+  it("does not remove or double-add a shopper-owned gift", async () => {
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise, { variant_id: 9, line_price: 0, properties: {} }])));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("treats disappearance after insertion as a session decline", async () => {
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise])))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValueOnce(response(cart([merchandise])))
+      .mockResolvedValueOnce(response(cart([merchandise])));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    await syncGiftWithPurchase(settings(), assignments);
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(1);
+    expect(sessionStorage.getItem(`drip_gwp_declined:${experimentId}`)).toBe("1");
+  });
+
+  it("never inserts in control and removes a stale managed gift", async () => {
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise, apexGift]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings({ offer_type: "gwp_threshold", control: true }), assignments);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({ body: JSON.stringify({ id: "gift-key", quantity: 0 }) }));
+  });
+
+  it("fails closed when cart and offer currencies differ", async () => {
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise], "EUR")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("removes a managed gift when the cart currency changes", async () => {
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise, apexGift], "EUR"))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    // A currency switch is not a shopper decline.
+    expect(sessionStorage.getItem(`drip_gwp_declined:${experimentId}`)).toBeNull();
+  });
+
+  it("seeds insertion records from a cart snapshot and enables teardown", async () => {
+    const { noteCartSnapshotForGifts } = await import("./commerce-gift");
+    // Fresh device: no local records, but the stamp-write response shows a
+    // marked line riding on the synced cart.
+    expect(noteCartSnapshotForGifts(cart([merchandise, apexGift]))).toBe(true);
+    expect(localStorage.getItem(`drip_gwp_inserted:${experimentId}`)).toBeTruthy();
+    // Teardown (no offers settings) can now reconcile.
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise, apexGift]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(undefined, []);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    expect(noteCartSnapshotForGifts(cart([merchandise]))).toBe(false);
+  });
+
+  it("removes a managed gift after its offer leaves the projection", async () => {
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise, apexGift]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, "1");
+    await syncGiftWithPurchase(undefined, []);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    expect(localStorage.getItem(`drip_gwp_inserted:${experimentId}`)).toBeNull();
+  });
+
+  it("removes a managed gift whose assignment is gone", async () => {
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise, apexGift]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), []);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+  });
+
+  it("respects manual removal after a fresh page load", async () => {
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise])))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValueOnce(response(cart([merchandise])));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    // Simulate a navigation: in-memory state is gone, sessionStorage survives.
+    __giftManagerInternals.reset();
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(1);
+    expect(sessionStorage.getItem(`drip_gwp_declined:${experimentId}`)).toBe("1");
+  });
+
+  it("normalizes an incremented managed gift line back to one unit", async () => {
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise, { ...apexGift, quantity: 2 }]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 1 }),
+    }));
+  });
+
+  it("queues one trailing reconciliation while a run is in flight", async () => {
+    let release!: (value: Response) => void;
+    const firstRead = new Promise<Response>((resolve) => { release = resolve; });
+    const shopperGift = { variant_id: 9, line_price: 0, properties: {} };
+    const fetch = vi.fn()
+      .mockReturnValueOnce(firstRead)
+      .mockResolvedValue(response(cart([merchandise, shopperGift])));
+    window.fetch = fetch;
+    const active = syncGiftWithPurchase(settings(), assignments);
+    const coalesced = syncGiftWithPurchase(settings(), assignments);
+    release(response(cart([merchandise, shopperGift])));
+    await active;
+    await coalesced;
+    // Two cart reads: the in-flight run plus the queued trailing run that
+    // re-observes the cart mutated underneath the first one.
+    expect(fetch).toHaveBeenCalledTimes(2);
+  });
+
+  it("uses locale-prefixed cart routes for reads and mutations", async () => {
+    (window as Window & { Shopify?: unknown }).Shopify = { routes: { root: "/fr/" } };
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch).toHaveBeenNthCalledWith(1, "/fr/cart.js", expect.anything());
+    expect(fetch).toHaveBeenNthCalledWith(2, "/fr/cart/add.js", expect.anything());
+  });
+
+  it("uses the pre-discount line_price basis the offer Function compares", async () => {
+    // Line-level discount: final is below threshold, pre-discount is not.
+    const discounted = { key: "merch", variant_id: 1, line_price: 5000, final_line_price: 4000, properties: {} };
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([discounted]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/add.js", expect.anything());
+  });
+
+  it("replaces a marked line whose gift variant changed on relaunch", async () => {
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise, apexGift]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, "1");
+    await syncGiftWithPurchase(settings({
+      offer_type: "gwp_threshold",
+      threshold: "5000",
+      gift_variant_gid: "gid://shopify/ProductVariant/10",
+    }), assignments);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    expect(fetch).toHaveBeenNthCalledWith(3, "/cart/add.js", expect.objectContaining({
+      body: JSON.stringify({ items: [{ id: 10, quantity: 1, properties: { _apex_gwp: experimentId } }] }),
+    }));
+    // The old line's removal is not a shopper decline of the new gift.
+    expect(sessionStorage.getItem(`drip_gwp_declined:${experimentId}`)).toBeNull();
+  });
+
+  it("removes a marked line whose experiment relaunched as a non-GWP offer", async () => {
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise, apexGift]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings({ offer_type: "discount_depth", percent_off: 10 }), assignments);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+  });
+
+  it("retains the insertion record when orphan removal fails, then retries", async () => {
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise, apexGift])))
+      .mockResolvedValueOnce(response({}, false))
+      .mockResolvedValueOnce(response(cart([merchandise, apexGift])))
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, "1");
+    await syncGiftWithPurchase(undefined, []);
+    // Removal failed — the record must survive so teardown cleanup retries.
+    expect(localStorage.getItem(`drip_gwp_inserted:${experimentId}`)).toBeTruthy();
+    await syncGiftWithPurchase(undefined, []);
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/change.js")).toHaveLength(2);
+    expect(localStorage.getItem(`drip_gwp_inserted:${experimentId}`)).toBeNull();
+  });
+
+  it("cleans up a marked line in a new browser session after teardown", async () => {
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise, apexGift]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    // New session: sessionStorage is empty, but the durable insertion record
+    // survives alongside the persistent Shopify cart.
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, "1");
+    sessionStorage.clear();
+    await syncGiftWithPurchase(undefined, []);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    expect(localStorage.getItem(`drip_gwp_inserted:${experimentId}`)).toBeNull();
+  });
+
+  it("treats a managed line discovered in a fresh session as inserted", async () => {
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise, apexGift])))
+      .mockResolvedValueOnce(response(cart([merchandise])));
+    window.fetch = fetch;
+    // No insertion records at all — the marked line itself is the evidence.
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(localStorage.getItem(`drip_gwp_inserted:${experimentId}`)).toBeTruthy();
+    // The shopper then removes it: that is a decline, not a re-add trigger.
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+    expect(sessionStorage.getItem(`drip_gwp_declined:${experimentId}`)).toBe("1");
+  });
+
+  it("does not treat a new cart as a manual decline of the previous cart's gift", async () => {
+    // Insertion evidence from the checked-out cart; the shopper starts fresh.
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, "cart-old");
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise], "USD", "cart-new")))
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(sessionStorage.getItem(`drip_gwp_declined:${experimentId}`)).toBeNull();
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/add.js", expect.anything());
+    expect(localStorage.getItem(`drip_gwp_inserted:${experimentId}`)).toBe("cart-new");
+  });
+
+  it("still records a decline when the line vanished from the same cart", async () => {
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, "cart-same");
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise], "USD", "cart-same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(sessionStorage.getItem(`drip_gwp_declined:${experimentId}`)).toBe("1");
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("shares one gift line across parallel GWP tests with the same variant", async () => {
+    const twoExperiments = {
+      authorization: settings().authorization,
+      experiments: [
+        settings().experiments[0],
+        { ...settings().experiments[0], experiment_id: "exp-gwp-2" },
+      ],
+    };
+    const bothAssignments = [
+      ...assignments,
+      { experimentId: "exp-gwp-2", variationId: "treatment" },
+    ];
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(twoExperiments, bothAssignments);
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(1);
+  });
+
+  it("never inserts for an off-target charge-only pinned assignment", async () => {
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise])));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), [
+      { experimentId, variationId: "treatment", commercePriceOnly: true },
+    ]);
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("clears an orphaned record whose line and experiment are both gone", async () => {
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, "cart-old");
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise])));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(undefined, []);
+    expect(localStorage.getItem(`drip_gwp_inserted:${experimentId}`)).toBeNull();
+    expect(fetch).toHaveBeenCalledTimes(1);
+    // With the record gone, teardown syncs stop reading the cart entirely.
+    await syncGiftWithPurchase(undefined, []);
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("discovers an orphaned gift via the tombstoned plane without any local records", async () => {
+    // Offer stopped; storage is empty (new device); the projection tombstone
+    // keeps an empty offers plane alive for exactly this discovery read.
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise, apexGift]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase({ experiments: [] }, []);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    // Once per session: the second sync performs no additional cart read.
+    const calls = fetch.mock.calls.length;
+    await syncGiftWithPurchase({ experiments: [] }, []);
+    expect(fetch.mock.calls.length).toBe(calls);
+  });
+
+  it("inserts for a still-qualifying experiment after removing a shared gift line", async () => {
+    const twoExperiments = {
+      authorization: settings().authorization,
+      experiments: [
+        {
+          experiment_id: experimentId,
+          currency: "USD",
+          variants: { treatment: { offer_type: "gwp_threshold", control: true } },
+        },
+        {
+          ...settings().experiments[0],
+          experiment_id: "exp-gwp-2",
+        },
+      ],
+    };
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise, apexGift]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(twoExperiments, [
+      ...assignments,
+      { experimentId: "exp-gwp-2", variationId: "treatment" },
+    ]);
+    // Control removes its marked line; the qualifying sibling must not treat
+    // the just-removed variant as still present and must insert its own gift.
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    expect(fetch).toHaveBeenNthCalledWith(3, "/cart/add.js", expect.objectContaining({
+      body: JSON.stringify({ items: [{ id: 9, quantity: 1, properties: { _apex_gwp: "exp-gwp-2" } }] }),
+    }));
+  });
+
+  it("normalizes a concurrently consolidated gift line from the add response", async () => {
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise])))
+      // Another tab added first; Shopify consolidated to quantity 2.
+      .mockResolvedValueOnce(response({
+        items: [{ key: "gift-key", quantity: 2, variant_id: 9, properties: { _apex_gwp: experimentId } }],
+      }))
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch).toHaveBeenNthCalledWith(3, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 1 }),
+    }));
+  });
+
+  it("revalidates after inserting and removes a gift the cart no longer earns", async () => {
+    const fetch = vi.fn()
+      // Eligible at read time…
+      .mockResolvedValueOnce(response(cart([merchandise])))
+      // …gift added…
+      .mockResolvedValueOnce(response({}))
+      // …but the subtotal dropped concurrently before the add landed: the
+      // fixpoint re-read sees the below-threshold cart with the managed line.
+      .mockResolvedValueOnce(response(cart([{ ...merchandise, line_price: 100 }, apexGift])))
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch).toHaveBeenNthCalledWith(4, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+  });
+
+  it("never inserts without a signed offers authorization covering the experiment", async () => {
+    const unauthorized = { experiments: settings().experiments };
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise])));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(unauthorized, assignments);
+    // The Function could not discount the line, so no insertion happens.
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+  });
+
+  it("removes and never inserts a gift whose arm is absent from the stamped proof", async () => {
+    // Shared price+offers experiment: price proof valid, offers proof refused.
+    // Config membership alone must not insert or retain the gift.
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise, apexGift]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments, { isArmProven: () => false });
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+  });
+
+  it("inserts normally when the stamped proof covers the arm", async () => {
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments, {
+      isArmProven: (assignment) => assignment.experimentId === experimentId,
+    });
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/add.js", expect.anything());
+  });
+
+  it("fail-closed cleanup still removes a below-threshold gift but never inserts", async () => {
+    // Below threshold with a managed line: removal must run.
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([{ ...merchandise, line_price: 100 }, apexGift]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments, { suppressInsertion: true });
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    __giftManagerInternals.reset();
+    sessionStorage.clear();
+    localStorage.clear();
+    // Eligible cart without the line: insertion is still suppressed.
+    const fetch2 = vi.fn().mockResolvedValue(response(cart([merchandise])));
+    window.fetch = fetch2;
+    await syncGiftWithPurchase(settings(), assignments, {
+      suppressInsertion: true,
+      isArmProven: () => true,
+    });
+    expect(fetch2.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+  });
+
+  it("keeps one current-variant line and removes duplicates and stale variants", async () => {
+    const staleGift = { key: "stale-key", variant_id: 7, line_price: 0, properties: { _apex_gwp: experimentId } };
+    const duplicateGift = { key: "dup-key", variant_id: 9, line_price: 0, properties: { _apex_gwp: experimentId } };
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise, apexGift, staleGift, duplicateGift])))
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    const removals = fetch.mock.calls
+      .filter(([url]) => url === "/cart/change.js")
+      .map(([, init]) => JSON.parse(String((init as RequestInit).body)));
+    expect(removals).toEqual(expect.arrayContaining([
+      { id: "stale-key", quantity: 0 },
+      { id: "dup-key", quantity: 0 },
+    ]));
+    expect(removals.some((body) => body.id === "gift-key")).toBe(false);
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+    // Our stale removals never record a shopper decline.
+    expect(sessionStorage.getItem(`drip_gwp_declined:${experimentId}`)).toBeNull();
+  });
+
+  it("fail-closed pass removes a managed line lacking current-cart evidence", async () => {
+    // Cart identity changed (merge) and the stamp refresh failed: the record
+    // belongs to the old cart, so the line has no proof on this one.
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, "cart-old");
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise, apexGift], "USD", "cart-new")))
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments, { suppressInsertion: true });
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+  });
+
+  it("fail-closed pass keeps a managed line proven on the current cart", async () => {
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, "cart-same");
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise, apexGift], "USD", "cart-same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments, { suppressInsertion: true });
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("dispatches apex:cart:changed after a mutating reconciliation", async () => {
+    const events: Event[] = [];
+    const listener = (event: Event) => events.push(event);
+    window.addEventListener("apex:cart:changed", listener);
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    window.removeEventListener("apex:cart:changed", listener);
+    expect(events).toHaveLength(1);
+  });
+
+  it("retries within the run when a duplicate-line removal fails beside the keeper", async () => {
+    const duplicateGift = { key: "dup-key", variant_id: 9, line_price: 0, properties: { _apex_gwp: experimentId } };
+    const fetch = vi.fn()
+      // Pass 1: read, then the duplicate removal fails.
+      .mockResolvedValueOnce(response(cart([merchandise, apexGift, duplicateGift])))
+      .mockResolvedValueOnce(response({}, false))
+      // Pass 2 (forced by the failed removal): read again, removal succeeds.
+      .mockResolvedValueOnce(response(cart([merchandise, apexGift, duplicateGift])))
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/change.js")).toHaveLength(2);
+  });
+
+  it("keeps accumulated mutation state when a later mutation rejects", async () => {
+    const events: Event[] = [];
+    const listener = (event: Event) => events.push(event);
+    window.addEventListener("apex:cart:changed", listener);
+    const staleA = { key: "stale-a", variant_id: 7, line_price: 0, properties: { _apex_gwp: experimentId } };
+    const staleB = { key: "stale-b", variant_id: 8, line_price: 0, properties: { _apex_gwp: experimentId } };
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise, apexGift, staleA, staleB])))
+      .mockResolvedValueOnce(response({}))
+      // Network-level rejection mid-pass must not void the first removal.
+      .mockRejectedValueOnce(new TypeError("network down"))
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    window.removeEventListener("apex:cart:changed", listener);
+    // The successful removal still counts: the run signals the storefront
+    // and retries (fixpoint) rather than aborting the pass.
+    expect(events).toHaveLength(1);
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/change.js").length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("a shared gift removal declines every experiment the line represented", async () => {
+    const twoExperiments = {
+      authorization: settings().authorization,
+      experiments: [
+        settings().experiments[0],
+        { ...settings().experiments[0], experiment_id: "exp-gwp-2" },
+      ],
+    };
+    const bothAssignments = [
+      ...assignments,
+      { experimentId: "exp-gwp-2", variationId: "treatment" },
+    ];
+    const fetch = vi.fn()
+      // Run 1: insert one shared line (marked for the first experiment).
+      .mockResolvedValueOnce(response(cart([merchandise])))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValueOnce(response(cart([merchandise, apexGift])))
+      // Run 2: the shopper removed the shared line.
+      .mockResolvedValue(response(cart([merchandise])));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(twoExperiments, bothAssignments);
+    // The fixpoint re-read with the shared line still present is NOT a
+    // decline for the co-owner.
+    expect(sessionStorage.getItem(`drip_gwp_declined:${experimentId}`)).toBeNull();
+    expect(sessionStorage.getItem("drip_gwp_declined:exp-gwp-2")).toBeNull();
+    await syncGiftWithPurchase(twoExperiments, bothAssignments);
+    expect(sessionStorage.getItem(`drip_gwp_declined:${experimentId}`)).toBe("1");
+    expect(sessionStorage.getItem("drip_gwp_declined:exp-gwp-2")).toBe("1");
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(1);
+  });
+
+  it("counts another experiment's gift toward the threshold (Function parity)", async () => {
+    const twoExperiments = {
+      authorization: {
+        version: 1 as const,
+        revision: 1,
+        checksum: "a".repeat(64),
+        experimentIds: [experimentId, "exp-gwp-2"],
+      },
+      experiments: [
+        settings().experiments[0],
+        {
+          experiment_id: "exp-gwp-2",
+          currency: "USD",
+          variants: {
+            treatment: {
+              offer_type: "gwp_threshold",
+              threshold: "100",
+              gift_variant_gid: "gid://shopify/ProductVariant/7",
+            },
+          },
+        },
+      ],
+    };
+    const otherGift = { key: "other-gift", variant_id: 7, line_price: 2000, properties: { _apex_gwp: "exp-gwp-2" } };
+    const fetch = vi.fn()
+      // $40 merchandise + the sibling's $20 gift = $60 >= $50 threshold —
+      // the Function counts the sibling's gift line, so the SDK must too.
+      .mockResolvedValueOnce(response(cart([{ ...merchandise, line_price: 4000 }, otherGift])))
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(twoExperiments, [
+      ...assignments,
+      { experimentId: "exp-gwp-2", variationId: "treatment" },
+    ]);
+    expect(fetch.mock.calls.some(([url, init]) =>
+      url === "/cart/add.js" && String((init as RequestInit).body).includes('"id":9'))).toBe(true);
+  });
+
+  it("clears a charge-only co-owner's record when the SDK removed the shared line", async () => {
+    const twoExperiments = {
+      authorization: settings().authorization,
+      experiments: [
+        {
+          experiment_id: experimentId,
+          currency: "USD",
+          variants: { control: { offer_type: "gwp_threshold", control: true } },
+        },
+        { ...settings().experiments[0], experiment_id: "exp-gwp-2" },
+      ],
+    };
+    // The co-owner rode the shared line earlier and holds a record.
+    localStorage.setItem("drip_gwp_inserted:exp-gwp-2", "*");
+    const fetch = vi.fn()
+      // Run 1: the owner entered control; its line is removed while the
+      // co-owner is an off-target charge-only pin.
+      .mockResolvedValueOnce(response(cart([merchandise, apexGift])))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValueOnce(response(cart([merchandise])))
+      // Run 2: the co-owner is targeted again — it must insert, not decline.
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(twoExperiments, [
+      { experimentId, variationId: "control" },
+      { experimentId: "exp-gwp-2", variationId: "treatment", commercePriceOnly: true },
+    ]);
+    expect(localStorage.getItem("drip_gwp_inserted:exp-gwp-2")).toBeNull();
+    const fetch2 = vi.fn().mockResolvedValueOnce(response(cart([merchandise]))).mockResolvedValue(response({}));
+    window.fetch = fetch2;
+    await syncGiftWithPurchase(twoExperiments, [
+      { experimentId, variationId: "control" },
+      { experimentId: "exp-gwp-2", variationId: "treatment" },
+    ]);
+    expect(sessionStorage.getItem("drip_gwp_declined:exp-gwp-2")).toBeNull();
+    expect(fetch2.mock.calls.some(([url, init]) =>
+      url === "/cart/add.js" && String((init as RequestInit).body).includes("exp-gwp-2"))).toBe(true);
+  });
+
+  it("retries a failed below-threshold removal within the run", async () => {
+    const fetch = vi.fn()
+      // Pass 1: read below-threshold cart; removal fails transiently.
+      .mockResolvedValueOnce(response(cart([{ ...merchandise, line_price: 100 }, apexGift])))
+      .mockResolvedValueOnce(response({}, false))
+      // Pass 2 (forced): read again; removal succeeds.
+      .mockResolvedValueOnce(response(cart([{ ...merchandise, line_price: 100 }, apexGift])))
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(settings(), assignments);
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/change.js")).toHaveLength(2);
+  });
+
+  it("suppresses its add notification so the cart observer cannot recurse", async () => {
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    const observed = vi.fn(() => { void syncGiftWithPurchase(settings(), assignments); });
+    const stop = onShopifyCartMutation(observed);
+    await syncGiftWithPurchase(settings(), assignments);
+    await Promise.resolve();
+    stop();
+    expect(observed).not.toHaveBeenCalled();
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(1);
+  });
+
+  it("moves up and down tiers at exact boundaries without keeping two gifts", async () => {
+    const tiered = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [
+        { threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9" },
+        { threshold: "10000", gift_variant_gid: "gid://shopify/ProductVariant/10" },
+      ],
+    });
+    const lower = { ...apexGift, variant_id: 9 };
+    const upper = { ...apexGift, key: "upper-key", variant_id: 10 };
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([{ ...merchandise, line_price: 10000 }, lower])))
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(tiered, assignments);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({ body: JSON.stringify({ id: "gift-key", quantity: 0 }) }));
+    expect(fetch).toHaveBeenNthCalledWith(3, "/cart/add.js", expect.objectContaining({ body: expect.stringContaining('"id":10') }));
+
+    __giftManagerInternals.reset();
+    const fetchDown = vi.fn()
+      .mockResolvedValueOnce(response(cart([{ ...merchandise, line_price: 5000 }, upper])))
+      .mockResolvedValue(response({}));
+    window.fetch = fetchDown;
+    await syncGiftWithPurchase(tiered, assignments);
+    expect(fetchDown).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({ body: JSON.stringify({ id: "upper-key", quantity: 0 }) }));
+    expect(fetchDown).toHaveBeenNthCalledWith(3, "/cart/add.js", expect.objectContaining({ body: expect.stringContaining('"id":9') }));
+  });
+
+  it("emits a proven choice and inserts the selected option through reconciliation", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const events: CustomEvent[] = [];
+    window.addEventListener("apex:gwp:choice", ((event: CustomEvent) => events.push(event)) as EventListener);
+    const fetch = vi.fn().mockResolvedValueOnce(response(cart([merchandise]))).mockResolvedValueOnce(response(cart([merchandise]))).mockResolvedValue(response({}));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    expect(events[0]?.detail).toEqual({ experimentId, threshold: "5000", options: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] });
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+    await selectGiftOption(experimentId, "gid://shopify/ProductVariant/10");
+    expect(fetch.mock.calls.some(([url, init]) => url === "/cart/add.js" && String((init as RequestInit).body).includes('"id":10'))).toBe(true);
+  });
+
+  it("lets a late-mounted chooser query and select the live pending choice", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise])))
+      .mockResolvedValueOnce(response(cart([merchandise])))
+      .mockResolvedValue(response({}));
+    window.fetch = fetch;
+
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    const [prompt] = getPendingGiftChoices(experimentId);
+    expect(prompt).toEqual({
+      experimentId,
+      threshold: "5000",
+      options: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"],
+    });
+    await selectGiftOption(prompt!.experimentId, prompt!.options[1]!);
+    expect(getPendingGiftChoices(experimentId)).toEqual([]);
+    expect(fetch.mock.calls.some(([url, init]) =>
+      url === "/cart/add.js" && String((init as RequestInit).body).includes('"id":10'))).toBe(true);
+  });
+
+  it("re-arms the chooser when the selected option's add fails", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const fetch = vi.fn(async (url: string) =>
+      url === "/cart/add.js" ? response({}, false) : response(cart([merchandise])));
+    window.fetch = fetch as unknown as typeof window.fetch;
+    const events: CustomEvent[] = [];
+    window.addEventListener("apex:gwp:choice", ((event: CustomEvent) => events.push(event)) as EventListener);
+
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    expect(events).toHaveLength(1);
+    await selectGiftOption(experimentId, "gid://shopify/ProductVariant/10");
+    expect(fetch.mock.calls.some(([url]) => url === "/cart/add.js")).toBe(true);
+
+    // The failed add must not dead-end the shopper: the prompt is live again,
+    // re-dispatched, and an alternative selection still reaches cart/add.
+    expect(events).toHaveLength(2);
+    expect(getPendingGiftChoices(experimentId)).toHaveLength(1);
+    const addCallsBefore = fetch.mock.calls.filter(([url]) => url === "/cart/add.js").length;
+    await selectGiftOption(experimentId, "gid://shopify/ProductVariant/9");
+    expect(
+      fetch.mock.calls.filter(([url]) => url === "/cart/add.js").length,
+    ).toBeGreaterThan(addCallsBefore);
+  });
+
+  it("treats any unmarked current-tier option as satisfying a selected choice", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const shopperOption = { key: "shopper-option", variant_id: 9, line_price: 0, properties: {} };
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise, shopperOption])));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    await selectGiftOption(experimentId, "gid://shopify/ProductVariant/10");
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/change.js")).toHaveLength(0);
+  });
+
+  it("removes the marked line when the shopper owns another current-tier option", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const chosenGift = { ...apexGift, variant_id: 10 };
+    const shopperOption = { key: "shopper-option", variant_id: 9, line_price: 900, properties: {} };
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, JSON.stringify({
+      cart: "same", variantGid: "gid://shopify/ProductVariant/10", tierThreshold: "5000",
+    }));
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise, shopperOption, chosenGift], "USD", "same")))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValue(response(cart([merchandise, shopperOption], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+  });
+
+  it("relinquishes its marked line when another experiment marks an allowed option", async () => {
+    const otherExperimentId = "exp-gwp-2";
+    const overlapping = {
+      authorization: settings().authorization,
+      experiments: [
+        settings({
+          offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+            gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+        }).experiments[0],
+        {
+          experiment_id: otherExperimentId,
+          currency: "USD",
+          variants: { treatment: {
+            offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/10",
+          } },
+        },
+      ],
+    };
+    const otherGift = { key: "other-gift", variant_id: 10, line_price: 0, properties: { _apex_gwp: otherExperimentId } };
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, JSON.stringify({
+      cart: "same", variantGid: "gid://shopify/ProductVariant/9", tierThreshold: "5000",
+    }));
+    localStorage.setItem(`drip_gwp_inserted:${otherExperimentId}`, "same");
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise, apexGift, otherGift], "USD", "same")))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValue(response(cart([merchandise, otherGift], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(overlapping, [
+      ...assignments,
+      { experimentId: otherExperimentId, variationId: "treatment" },
+    ], { isArmProven: () => true });
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+  });
+
+  it("removes a fixed-tier gift and prompts when entering an overlapping choice tier", async () => {
+    const tieredChoice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [
+        { threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9" },
+        { threshold: "10000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] },
+      ],
+    });
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, JSON.stringify({
+      cart: "same", variantGid: "gid://shopify/ProductVariant/9", tierThreshold: "5000",
+    }));
+    const events: CustomEvent[] = [];
+    const listener = ((event: CustomEvent) => events.push(event)) as EventListener;
+    window.addEventListener("apex:gwp:choice", listener);
+    const qualifyingMerchandise = { ...merchandise, line_price: 10000 };
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([qualifyingMerchandise, apexGift], "USD", "same")))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValue(response(cart([qualifyingMerchandise], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(tieredChoice, assignments, { isArmProven: () => true });
+    window.removeEventListener("apex:gwp:choice", listener);
+    expect(fetch).toHaveBeenNthCalledWith(2, "/cart/change.js", expect.objectContaining({
+      body: JSON.stringify({ id: "gift-key", quantity: 0 }),
+    }));
+    expect(events[0]?.detail).toEqual({
+      experimentId,
+      threshold: "10000",
+      options: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"],
+    });
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+  });
+
+  it("recovers a choice from a marked line when local storage has no prior record", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const chosenGift = { ...apexGift, variant_id: 10 };
+    expect(noteCartSnapshotForGifts(cart([merchandise, chosenGift], "USD", "same"))).toBe(true);
+    __giftManagerInternals.reset();
+    const events: CustomEvent[] = [];
+    const listener = ((event: CustomEvent) => events.push(event)) as EventListener;
+    window.addEventListener("apex:gwp:choice", listener);
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise, chosenGift], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    window.removeEventListener("apex:gwp:choice", listener);
+    expect(events).toHaveLength(0);
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(localStorage.getItem(`drip_gwp_inserted:${experimentId}`)).toContain("ProductVariant/10");
+  });
+
+  it("restores a persisted choice after navigation without removing or re-prompting", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const chosenGift = { ...apexGift, variant_id: 10 };
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, JSON.stringify({
+      cart: "same", variantGid: "gid://shopify/ProductVariant/10", tierThreshold: "5000",
+    }));
+    __giftManagerInternals.reset();
+    const events: CustomEvent[] = [];
+    const listener = ((event: CustomEvent) => events.push(event)) as EventListener;
+    window.addEventListener("apex:gwp:choice", listener);
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise, chosenGift], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    window.removeEventListener("apex:gwp:choice", listener);
+    expect(events).toHaveLength(0);
+    expect(fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("binds a shared-GID selection to the prompted tier and inserts the gift", async () => {
+    const twoChoiceTiers = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [
+        { threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] },
+        { threshold: "10000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] },
+      ],
+    });
+    const highMerchandise = { ...merchandise, line_price: 10000 };
+    const fetch = vi.fn()
+      // Prompt fires for the higher tier.
+      .mockResolvedValueOnce(response(cart([highMerchandise], "USD", "same")))
+      // Selection sync: read, insert, fixpoint.
+      .mockResolvedValueOnce(response(cart([highMerchandise], "USD", "same")))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValue(response(cart([highMerchandise, { ...apexGift, variant_id: 10 }], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(twoChoiceTiers, assignments, { isArmProven: () => true });
+    await selectGiftOption(experimentId, "gid://shopify/ProductVariant/10");
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(1);
+    expect(localStorage.getItem(`drip_gwp_inserted:${experimentId}`)).toContain('"tierThreshold":"10000"');
+  });
+
+  it("binds a selection to the applicable tier after crossing up and back down", async () => {
+    const twoChoiceTiers = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [
+        { threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] },
+        { threshold: "10000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] },
+      ],
+    });
+    const highMerchandise = { ...merchandise, line_price: 10000 };
+    const fetch = vi.fn()
+      // High tier prompts, then the cart drops back to the low tier.
+      .mockResolvedValueOnce(response(cart([highMerchandise], "USD", "same")))
+      .mockResolvedValueOnce(response(cart([merchandise], "USD", "same")))
+      // Selection sync at the LOW tier: read, insert, fixpoint.
+      .mockResolvedValueOnce(response(cart([merchandise], "USD", "same")))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValue(response(cart([merchandise, { ...apexGift, variant_id: 10 }], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(twoChoiceTiers, assignments, { isArmProven: () => true });
+    await syncGiftWithPurchase(twoChoiceTiers, assignments, { isArmProven: () => true });
+    await selectGiftOption(experimentId, "gid://shopify/ProductVariant/10");
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(1);
+    expect(localStorage.getItem(`drip_gwp_inserted:${experimentId}`)).toContain('"tierThreshold":"5000"');
+  });
+
+  it("ignores a delayed selection after the choice tier stopped applying", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const fetch = vi.fn()
+      // Prompt fires, then the cart drops below the threshold.
+      .mockResolvedValueOnce(response(cart([merchandise], "USD", "same")))
+      .mockResolvedValue(response(cart([{ ...merchandise, line_price: 4999 }], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    await selectGiftOption(experimentId, "gid://shopify/ProductVariant/10");
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+  });
+
+  it("ignores a delayed selection when the arm is no longer proven", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => false });
+    await selectGiftOption(experimentId, "gid://shopify/ProductVariant/10");
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+  });
+
+  it("re-prompts when a tierless record meets a higher choice tier sharing the GID", async () => {
+    const twoChoiceTiers = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [
+        { threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] },
+        { threshold: "10000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] },
+      ],
+    });
+    // Snapshot-seeded record: variant known, tier provenance absent.
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, JSON.stringify({
+      cart: "same", variantGid: "gid://shopify/ProductVariant/10",
+    }));
+    const chosenGift = { ...apexGift, variant_id: 10 };
+    const events: CustomEvent[] = [];
+    const listener = ((event: CustomEvent) => events.push(event)) as EventListener;
+    window.addEventListener("apex:gwp:choice", listener);
+    const highMerchandise = { ...merchandise, line_price: 10000 };
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([highMerchandise, chosenGift], "USD", "same")))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValue(response(cart([highMerchandise], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(twoChoiceTiers, assignments, { isArmProven: () => true });
+    window.removeEventListener("apex:gwp:choice", listener);
+    expect(events.some((event) => (event.detail as { threshold?: string }).threshold === "10000")).toBe(true);
+  });
+
+  it("re-prompts tier A after visiting tier B and returning without answering", async () => {
+    const twoChoiceTiers = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [
+        { threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] },
+        { threshold: "10000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] },
+      ],
+    });
+    // Also covered below: traversal through a FIXED tier re-arms the chooser.
+    const events: CustomEvent[] = [];
+    const listener = ((event: CustomEvent) => events.push(event)) as EventListener;
+    window.addEventListener("apex:gwp:choice", listener);
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise], "USD", "same")))
+      .mockResolvedValueOnce(response(cart([{ ...merchandise, line_price: 10000 }], "USD", "same")))
+      .mockResolvedValue(response(cart([merchandise], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(twoChoiceTiers, assignments, { isArmProven: () => true });
+    await syncGiftWithPurchase(twoChoiceTiers, assignments, { isArmProven: () => true });
+    await syncGiftWithPurchase(twoChoiceTiers, assignments, { isArmProven: () => true });
+    window.removeEventListener("apex:gwp:choice", listener);
+    const thresholds = events.map((event) => (event.detail as { threshold?: string }).threshold);
+    expect(thresholds).toEqual(["5000", "10000", "5000"]);
+  });
+
+  it("re-prompts a choice tier after traversing a fixed tier without answering", async () => {
+    const mixedTiers = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [
+        { threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] },
+        { threshold: "10000", gift_variant_gid: "gid://shopify/ProductVariant/11" },
+      ],
+    });
+    const events: CustomEvent[] = [];
+    const listener = ((event: CustomEvent) => events.push(event)) as EventListener;
+    window.addEventListener("apex:gwp:choice", listener);
+    const fixedGift = { key: "fixed-key", variant_id: 11, line_price: 0, properties: { _apex_gwp: experimentId } };
+    const fetch = vi.fn()
+      // Choice tier prompts; fixed tier inserts its gift; back to the choice tier.
+      .mockResolvedValueOnce(response(cart([merchandise], "USD", "same")))
+      .mockResolvedValueOnce(response(cart([{ ...merchandise, line_price: 10000 }], "USD", "same")))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValueOnce(response(cart([{ ...merchandise, line_price: 10000 }, fixedGift], "USD", "same")))
+      .mockResolvedValueOnce(response(cart([merchandise, fixedGift], "USD", "same")))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValue(response(cart([merchandise], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(mixedTiers, assignments, { isArmProven: () => true });
+    await syncGiftWithPurchase(mixedTiers, assignments, { isArmProven: () => true });
+    await syncGiftWithPurchase(mixedTiers, assignments, { isArmProven: () => true });
+    window.removeEventListener("apex:gwp:choice", listener);
+    const thresholds = events.map((event) => (event.detail as { threshold?: string }).threshold);
+    expect(thresholds).toEqual(["5000", "5000"]);
+  });
+
+  it("adopts another tab's durable choice instead of reverting it", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const nineGift = { key: "nine-key", variant_id: 9, line_price: 0, properties: { _apex_gwp: experimentId } };
+    // This tab selected 9 and its record landed (pending settled)…
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, JSON.stringify({
+      cart: "same", variantGid: "gid://shopify/ProductVariant/9", tierThreshold: "5000",
+    }));
+    let fetch = vi.fn().mockResolvedValue(response(cart([merchandise, nineGift], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    // …then ANOTHER tab chose 10: durable record + cart line now say 10.
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, JSON.stringify({
+      cart: "same", variantGid: "gid://shopify/ProductVariant/10", tierThreshold: "5000",
+    }));
+    const tenGift = { key: "ten-key", variant_id: 10, line_price: 0, properties: { _apex_gwp: experimentId } };
+    fetch = vi.fn().mockResolvedValue(response(cart([merchandise, tenGift], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    // The stale local selection must not remove the other tab's gift.
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/change.js")).toHaveLength(0);
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+  });
+
+  it("re-arms the chooser when the selected gift fails to add", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const events: CustomEvent[] = [];
+    const listener = ((event: CustomEvent) => events.push(event)) as EventListener;
+    window.addEventListener("apex:gwp:choice", listener);
+    const fetch = vi.fn()
+      // Prompt fires; selection sync reads, then the add FAILS.
+      .mockResolvedValueOnce(response(cart([merchandise], "USD", "same")))
+      .mockResolvedValueOnce(response(cart([merchandise], "USD", "same")))
+      .mockResolvedValueOnce(new Response("unavailable", { status: 422 }))
+      .mockResolvedValue(response(cart([merchandise], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    await selectGiftOption(experimentId, "gid://shopify/ProductVariant/10");
+    // The failed selection is dropped and the prompt re-fires on the next sync.
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    window.removeEventListener("apex:gwp:choice", listener);
+    expect(events.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("rejects a fixed tier whose gift GID is not a numeric variant GID", async () => {
+    const malformed = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "not-a-gid",
+      tiers: [{ threshold: "5000", gift_variant_gid: "not-a-gid" }],
+    });
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise])));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(malformed, assignments, { isArmProven: () => true });
+    // Parse-time rejection: no add attempt, no crash-aborted reconciliation.
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+  });
+
+  it("re-dispatches live prompts on apex:gwp:choice:request", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const fetch = vi.fn().mockResolvedValue(response(cart([merchandise], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    // A chooser mounted late asks for a replay.
+    const events: CustomEvent[] = [];
+    const listener = ((event: CustomEvent) => events.push(event)) as EventListener;
+    window.addEventListener("apex:gwp:choice", listener);
+    window.dispatchEvent(new CustomEvent("apex:gwp:choice:request"));
+    window.removeEventListener("apex:gwp:choice", listener);
+    expect(events).toHaveLength(1);
+    expect((events[0].detail as { threshold?: string }).threshold).toBe("5000");
+  });
+
+  it("queues a replay request made while reconciliation is still proving the tier", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    let resolveCart!: (value: Response) => void;
+    window.fetch = vi.fn().mockImplementation(() => new Promise<Response>((resolve) => {
+      resolveCart = resolve;
+    }));
+    const sync = syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    const events: CustomEvent[] = [];
+    const listener = ((event: CustomEvent) => events.push(event)) as EventListener;
+    window.addEventListener("apex:gwp:choice", listener);
+    window.dispatchEvent(new CustomEvent("apex:gwp:choice:request"));
+    resolveCart(response(cart([merchandise], "USD", "same")));
+    await sync;
+    window.removeEventListener("apex:gwp:choice", listener);
+    expect(events).toHaveLength(2);
+    expect(events.map((event) => event.detail.threshold)).toEqual(["5000", "5000"]);
+  });
+
+  it("keeps tier ownership when a cart snapshot re-seeds an existing record", () => {
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, JSON.stringify({
+      cart: "same", variantGid: "gid://shopify/ProductVariant/10", tierThreshold: "5000",
+    }));
+    noteCartSnapshotForGifts({
+      token: "same",
+      items: [{ variant_id: 10, properties: { _apex_gwp: experimentId } }],
+    });
+    expect(localStorage.getItem(`drip_gwp_inserted:${experimentId}`)).toContain('"tierThreshold":"5000"');
+  });
+
+  it("re-prompts when an in-memory choice from a lower tier crosses into a higher choice tier", async () => {
+    const twoChoiceTiers = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [
+        { threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] },
+        { threshold: "10000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+          gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] },
+      ],
+    });
+    const chosenGift = { ...apexGift, variant_id: 10 };
+    const events: CustomEvent[] = [];
+    const listener = ((event: CustomEvent) => events.push(event)) as EventListener;
+    window.addEventListener("apex:gwp:choice", listener);
+    const fetch = vi.fn()
+      // Lower tier prompts, shopper selects option 10 (read, add, fixpoint).
+      .mockResolvedValueOnce(response(cart([merchandise], "USD", "same")))
+      .mockResolvedValueOnce(response(cart([merchandise], "USD", "same")))
+      .mockResolvedValueOnce(response({}))
+      .mockResolvedValueOnce(response(cart([merchandise, chosenGift], "USD", "same")))
+      // Higher tier now applies: the lower-tier selection must not carry over.
+      .mockResolvedValue(response(cart([{ ...merchandise, line_price: 10000 }, chosenGift], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(twoChoiceTiers, assignments, { isArmProven: () => true });
+    await selectGiftOption(experimentId, "gid://shopify/ProductVariant/10");
+    const promptsBeforeCrossing = events.filter(
+      (event) => (event.detail as { threshold?: string }).threshold === "10000",
+    ).length;
+    expect(promptsBeforeCrossing).toBe(0);
+    await syncGiftWithPurchase(twoChoiceTiers, assignments, { isArmProven: () => true });
+    window.removeEventListener("apex:gwp:choice", listener);
+    const higherTierPrompts = events.filter(
+      (event) => (event.detail as { threshold?: string }).threshold === "10000",
+    );
+    expect(higherTierPrompts.length).toBeGreaterThan(0);
+  });
+
+  it("re-arms the choice event after dropping below threshold and requalifying", async () => {
+    const choice = settings({
+      offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+        gift_choice_variant_gids: ["gid://shopify/ProductVariant/9", "gid://shopify/ProductVariant/10"] }],
+    });
+    const events: CustomEvent[] = [];
+    const listener = ((event: CustomEvent) => events.push(event)) as EventListener;
+    window.addEventListener("apex:gwp:choice", listener);
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(response(cart([merchandise])))
+      .mockResolvedValueOnce(response(cart([{ ...merchandise, line_price: 4999 }])))
+      .mockResolvedValueOnce(response(cart([merchandise])));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    await syncGiftWithPurchase(choice, assignments, { isArmProven: () => true });
+    window.removeEventListener("apex:gwp:choice", listener);
+    expect(events).toHaveLength(2);
+  });
+
+  it("keeps a shopper decline across tier changes", async () => {
+    const tiered = settings({ offer_type: "gwp_threshold", threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9",
+      tiers: [{ threshold: "5000", gift_variant_gid: "gid://shopify/ProductVariant/9" }, { threshold: "10000", gift_variant_gid: "gid://shopify/ProductVariant/10" }] });
+    localStorage.setItem(`drip_gwp_inserted:${experimentId}`, JSON.stringify({ cart: "same", variantGid: "gid://shopify/ProductVariant/9", tierThreshold: "5000" }));
+    const fetch = vi.fn().mockResolvedValue(response(cart([{ ...merchandise, line_price: 10000 }], "USD", "same")));
+    window.fetch = fetch;
+    await syncGiftWithPurchase(tiered, assignments);
+    expect(sessionStorage.getItem(`drip_gwp_declined:${experimentId}`)).toBe("1");
+    expect(fetch.mock.calls.filter(([url]) => url === "/cart/add.js")).toHaveLength(0);
+  });
+});