@drip-apex/sdk 0.1.0 → 0.2.0

package/src/init-anti-flicker.test.ts

@@ -0,0 +1,1211 @@
+import { describe, expect, it, vi } from "vitest";
+import type { Assignment } from "./types";
+import {
+  RECENT_MONDAY_NOON, documentListeners, windowListeners, appendedAntiFlickerStyle, configPayloadHash, flushDynamicImports, installCookieJar, installMutationObserverStub, makeClassList, makeStorage, readCookieValue, readDecodedDripContext, registerInitTestLifecycle, verifiedHandoverResponse,
+} from "./init-test-helpers";
+
+describe("init anti flicker", () => {
+  registerInitTestLifecycle();
+
+
+  it("clears a superseded visual hydration gate for an empty-project config", async () => {
+    const cachedExperiments = [
+      {
+        id: "exp_cached_visual",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{ id: "var_cached_visual", weight: 1, mutations: [], js: "window.__cachedVisual=true;" }],
+      },
+    ];
+    localStorage.setItem("drip_cfg:shop_123:production", JSON.stringify({
+      fetchedAt: Date.now(),
+      hash: "cached-visual-config",
+      experiments: cachedExperiments,
+      runtime: { spa: { applyTiming: "after_hydration", hydrationTimeoutMs: 3_000 } },
+    }));
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => (
+      String(input).includes("/config")
+        ? new Response(JSON.stringify({ experiments: [] }), { status: 200 })
+        : new Response("ok", { status: 202 })
+    )) as any;
+    const { flush, getDiagnostics, init, track } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      lateConfigPolicy: "apply",
+      perfFlags: { perf_empty_project_v1: true },
+      profile: { platform: "shopify", version: 1 },
+      runtimeFeatures: { sdkVariant: "live" },
+      runtimeProfile: "empty_project",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    for (let attempt = 0; attempt < 20 && getDiagnostics().configSource !== "network"; attempt += 1) {
+      await Promise.resolve();
+    }
+    expect(getDiagnostics().configSource).toBe("network");
+
+    track("empty_project_ready");
+    await flush();
+
+    const eventsCall = vi.mocked(globalThis.fetch).mock.calls.find(
+      (call) => call[0] === "https://events.test/v1/events",
+    );
+    const events = JSON.parse(String(eventsCall?.[1]?.body)).events;
+    expect(events).toEqual(expect.arrayContaining([
+      expect.objectContaining({ type: "empty_project_ready" }),
+    ]));
+  });
+
+
+  it("keeps cached anti-flicker armed when refresh fails before hydration", async () => {
+    installMutationObserverStub();
+    const title = { textContent: "Original" };
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#product-title" ? [title] : []
+    ));
+    localStorage.setItem("drip_cfg:shop_123:production", JSON.stringify({
+      fetchedAt: Date.now(),
+      hash: "cached-hydration-config",
+      experiments: [{
+        id: "exp_cached_hydration",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{
+          id: "var_cached_hydration",
+          weight: 1,
+          mutations: [{ selector: "#product-title", action: "text", text: "Treatment" }],
+        }],
+      }],
+      runtime: { spa: { applyTiming: "after_hydration", hydrationTimeoutMs: 5_000 } },
+    }));
+    globalThis.fetch = vi.fn(async () => { throw new Error("refresh unavailable"); }) as any;
+    vi.spyOn(console, "error").mockImplementation(() => {});
+    const { hydrated, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "full",
+      antiFlickerTimeoutMs: 5_000,
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+    });
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(appendedAntiFlickerStyle()).toBeDefined();
+    expect(title.textContent).toBe("Original");
+
+    await vi.advanceTimersByTimeAsync(1_600);
+    expect(vi.mocked(globalThis.fetch).mock.calls.filter(
+      (call) => String(call[0]).includes("/config"),
+    )).toHaveLength(3);
+    expect(appendedAntiFlickerStyle()).toBeDefined();
+    expect(title.textContent).toBe("Original");
+
+    hydrated();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(title.textContent).toBe("Treatment");
+  });
+
+
+  it("reasserts SPA mutations immediately after reveal when hydration overwrites them", async () => {
+    const title = {
+      textContent: "Product detail loading",
+    };
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#product-title" ? [title] : []
+    ));
+
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_post_reveal_reassert",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "var_post_reveal_reassert",
+              weight: 1,
+              mutations: [{ selector: "#product-title", action: "text", text: "Apex post-reveal text" }],
+            },
+          ],
+        },
+      ],
+      pageTrigger: { defaultMode: "url_change" },
+      shopId: "shop_123",
+      spa: { activationMode: "manual", debounceMs: 500 },
+      trackingStart: "immediate",
+    });
+
+    expect(title.textContent).toBe("Apex post-reveal text");
+    title.textContent = "Hydrated product title";
+
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(title.textContent).toBe("Apex post-reveal text");
+  });
+
+
+  it("never early-reasserts a contaminated assignment after partial rollback", async () => {
+    const title = { textContent: "Control title" };
+    installMutationObserverStub();
+    let resolveEarlyAssignments: (() => Assignment[]) | null = null;
+    let reapplyEarlyAssignments: ((assignments: Assignment[]) => void) | null = null;
+    const earlyReassert = await import("./early-reassert");
+    vi.spyOn(earlyReassert, "installEarlyReassert").mockImplementation((input) => {
+      resolveEarlyAssignments = input.resolveAssignments;
+      reapplyEarlyAssignments = input.reapply;
+      return vi.fn();
+    });
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#product-title" ? [title] : []
+    ));
+    (globalThis as any).__dripPredecided = {
+      decision: [["exp_early_contaminated", "var_early_contaminated"]],
+      configRevision: 1557,
+      visitorId: "visitor_early_contaminated",
+      groups: {},
+    };
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      delivery: { revision: 1557 },
+      experiments: [{
+        id: "exp_early_contaminated",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{
+          id: "var_early_contaminated",
+          weight: 1,
+          mutations: [
+            { selector: "#product-title", action: "text", text: "Treatment title" },
+            { selector: "#missing-cta", action: "text", text: "Missing CTA" },
+          ],
+        }],
+      }],
+      shopId: "shop_123",
+      spa: { activationMode: "manual", applyTiming: "early_reassert" },
+      trackingStart: "immediate",
+      userId: "visitor_early_contaminated",
+    });
+
+    expect(title.textContent).toBe("Control title");
+    expect(resolveEarlyAssignments).not.toBeNull();
+    expect(resolveEarlyAssignments!()).toEqual([]);
+    title.textContent = "Hydrated control title";
+    reapplyEarlyAssignments!(resolveEarlyAssignments!());
+    expect(title.textContent).toBe("Hydrated control title");
+  });
+
+
+  it("keeps a contaminated commerce price plane at control and suppresses exposure", async () => {
+    const title = {
+      textContent: "Product detail loading",
+    };
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#product-title" ? [title] : []
+    ));
+
+    const commercePrice = await import("./commerce-price");
+    const applyCommercePrice = vi.spyOn(commercePrice, "applyCommercePrice");
+    const { flush, getCartAttributes, init, reInit, trackGoal } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      commerce: {
+        price: {
+          revision: 1,
+          checksum: "a".repeat(64),
+          experiments: [{
+            experiment_id: "exp_delivery_health",
+            currency: "EUR",
+            variants: {
+              var_delivery_health: [{
+                variant_gid: "gid://shopify/ProductVariant/1557",
+                fixedPricePerUnit: "9.99",
+              }],
+            },
+          }],
+        },
+      },
+      experiments: [
+        {
+          id: "exp_delivery_health",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "var_delivery_health",
+              weight: 1,
+              mutations: [
+                { selector: "#product-title", action: "text", text: "Apex delivery health" },
+                { selector: "#missing-cta", action: "text", text: "Missing CTA" },
+              ],
+            },
+          ],
+          goals: [{ id: "goal_contaminated", type: "custom", eventName: "contaminated" }],
+        },
+      ],
+      shopId: "shop_123",
+      spa: { activationMode: "manual" },
+      trackingStart: "immediate",
+    });
+
+    expect(title.textContent).toBe("Product detail loading");
+    expect(applyCommercePrice).toHaveBeenLastCalledWith(
+      expect.anything(),
+      [],
+      expect.any(Function),
+      expect.any(Function),
+      expect.any(Function),
+    );
+
+    await flush();
+
+    const events = (globalThis.fetch as any).mock.calls
+      .flatMap((call: [string, RequestInit]) => JSON.parse(String(call[1].body)).events);
+    const deliveryEvent = events.find((event: { type: string }) => event.type === "delivery_health");
+    const rollbackEvent = events.find((event: { type: string }) => event.type === "variant_contamination_rollback");
+
+    expect(deliveryEvent).toMatchObject({
+      experimentId: "exp_delivery_health",
+      variationId: "var_delivery_health",
+      data: {
+        expected_mutations: 2,
+        applied_mutations: 1,
+        selector_misses: 1,
+        apply_status: "partial",
+        activation_mode: "manual",
+      },
+    });
+    expect(rollbackEvent).toMatchObject({
+      experimentId: "exp_delivery_health",
+      variationId: "var_delivery_health",
+      data: { missed_selector_count: 1 },
+    });
+    expect(events.some((event: { type: string }) => event.type === "experiment_viewed")).toBe(false);
+
+    // Deferred post-reveal replay must not restore a transaction that rolled back.
+    title.textContent = "Hydrated product title";
+    await vi.advanceTimersByTimeAsync(500);
+    expect(title.textContent).toBe("Hydrated product title");
+
+    // A contaminated assignment is neither goal-attributable nor cart-stampable.
+    trackGoal("goal_contaminated");
+    expect(getCartAttributes()).toEqual(expect.arrayContaining([
+      { key: "apex_assignments", value: "[]" },
+    ]));
+    await flush();
+    const afterGoal = (globalThis.fetch as any).mock.calls
+      .flatMap((call: [string, RequestInit]) => JSON.parse(String(call[1].body)).events);
+    expect(afterGoal.some((event: { type: string }) => event.type === "goal")).toBe(false);
+
+    // SPA re-evaluation cannot recreate a pending tracker or emit health twice.
+    reInit();
+    await vi.advanceTimersByTimeAsync(1_000);
+    await flush();
+    const afterReevaluation = (globalThis.fetch as any).mock.calls
+      .flatMap((call: [string, RequestInit]) => JSON.parse(String(call[1].body)).events);
+    expect(afterReevaluation.filter((event: { type: string }) => event.type === "delivery_health")).toHaveLength(1);
+    expect(afterReevaluation.filter((event: { type: string }) => event.type === "variant_contamination_rollback")).toHaveLength(1);
+  });
+
+
+  it("suppresses exposure when a variant's only mutation misses", async () => {
+    (globalThis as any).document.querySelectorAll = vi.fn(() => []);
+    const onExperimentViewed = vi.fn();
+    const { flush, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_single_miss",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{
+          id: "var_single_miss",
+          weight: 1,
+          mutations: [{ selector: "#missing", action: "text", text: "Never applied" }],
+        }],
+      }],
+      onExperimentViewed,
+      shopId: "shop_123",
+      spa: { activationMode: "manual" },
+      trackingStart: "immediate",
+    });
+
+    await flush();
+    const events = (globalThis.fetch as any).mock.calls
+      .flatMap((call: [string, RequestInit]) => JSON.parse(String(call[1].body)).events);
+    expect(events.some((event: { type: string }) => event.type === "experiment_viewed")).toBe(false);
+    expect(events).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: "variant_contamination_rollback",
+        experimentId: "exp_single_miss",
+        variationId: "var_single_miss",
+        data: expect.objectContaining({ missed_selector_count: 1 }),
+      }),
+    ]));
+    expect(onExperimentViewed).not.toHaveBeenCalled();
+  });
+
+
+  it("reports delayed SPA selector matches as applied instead of expiring health as a miss", async () => {
+    let observerCallback: MutationCallback | null = null;
+    (globalThis as any).MutationObserver = class MutationObserver {
+      constructor(callback: MutationCallback) {
+        observerCallback = callback;
+      }
+      observe = vi.fn();
+      disconnect = vi.fn();
+    };
+    (globalThis as any).Node = {
+      ELEMENT_NODE: 1,
+      DOCUMENT_FRAGMENT_NODE: 11,
+    };
+    const routeNode = {
+      nodeType: 1,
+      textContent: "Route shell",
+      matches: vi.fn((selector: string) => selector === "[data-route='pdp']"),
+      querySelectorAll: vi.fn(() => []),
+    };
+    (globalThis as any).document.querySelectorAll = vi.fn(() => []);
+
+    const { flush, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_spa_delivery_health",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [
+            {
+              id: "var_spa_delivery_health",
+              weight: 1,
+              mutations: [
+                { selector: "[data-route='pdp']", action: "text", text: "Apex applied after SPA mount" },
+              ],
+            },
+          ],
+        },
+      ],
+      shopId: "shop_123",
+      spa: { activationMode: "observer" },
+      trackingStart: "immediate",
+    });
+
+    (observerCallback as MutationCallback | null)?.(
+      [{ type: "attributes", target: routeNode, addedNodes: [] } as unknown as MutationRecord],
+      {} as MutationObserver,
+    );
+    await Promise.resolve();
+    await flush();
+
+    let events = (globalThis.fetch as any).mock.calls
+      .flatMap((call: [string, RequestInit]) => JSON.parse(String(call[1].body)).events);
+    const deliveryEvent = events.find((event: { type: string }) => event.type === "delivery_health");
+
+    expect(routeNode.textContent).toBe("Apex applied after SPA mount");
+    expect(deliveryEvent).toMatchObject({
+      experimentId: "exp_spa_delivery_health",
+      variationId: "var_spa_delivery_health",
+      data: {
+        expected_mutations: 1,
+        applied_mutations: 1,
+        selector_misses: 0,
+        apply_status: "applied",
+        activation_mode: "observer",
+      },
+    });
+    expect(events).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: "experiment_viewed",
+        experimentId: "exp_spa_delivery_health",
+        variationId: "var_spa_delivery_health",
+      }),
+    ]));
+
+    vi.advanceTimersByTime(30_001);
+    await flush();
+    events = (globalThis.fetch as any).mock.calls
+      .flatMap((call: [string, RequestInit]) => JSON.parse(String(call[1].body)).events);
+    const healthEvents = events.filter((event: { type: string }) => event.type === "delivery_health");
+    expect(healthEvents).toHaveLength(1);
+  });
+
+
+  it("keeps pending mutation identity off revenue and analytics until clean resolution", async () => {
+    let observerCallback: MutationCallback | null = null;
+    (globalThis as any).MutationObserver = class MutationObserver {
+      constructor(callback: MutationCallback) {
+        observerCallback = callback;
+      }
+      observe = vi.fn();
+      disconnect = vi.fn();
+    };
+    (globalThis as any).Node = {
+      ELEMENT_NODE: 1,
+      DOCUMENT_FRAGMENT_NODE: 11,
+    };
+    const routeNode = {
+      nodeType: 1,
+      textContent: "Route shell",
+      matches: vi.fn((selector: string) => selector === "[data-route='pending']"),
+      querySelectorAll: vi.fn(() => []),
+    };
+    (globalThis as any).document.querySelectorAll = vi.fn(() => []);
+
+    const { flush, init, track, trackRevenue } = await import("./index");
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_pending_identity",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{
+          id: "var_pending_identity",
+          weight: 1,
+          mutations: [{
+            selector: "[data-route='pending']",
+            action: "text",
+            text: "Resolved treatment",
+          }],
+        }],
+      }],
+      shopId: "shop_123",
+      spa: { activationMode: "observer" },
+      trackingStart: "immediate",
+    });
+
+    track("analytics_probe", { phase: "pending" });
+    trackRevenue(55, { orderId: "pending-order" });
+    await flush();
+
+    let events = (globalThis.fetch as any).mock.calls
+      .flatMap((call: [string, RequestInit]) => JSON.parse(String(call[1].body)).events);
+    const pendingPageviews = events.filter((event: { type: string }) => event.type === "pageview");
+    expect(pendingPageviews).toHaveLength(1);
+    expect(pendingPageviews[0]).not.toHaveProperty("experimentId");
+    expect(pendingPageviews[0]).not.toHaveProperty("variationId");
+    expect(events.filter((event: { type: string }) => event.type === "experiment_pageview")).toEqual([]);
+    const pendingEvents = events.filter((event: { data?: { phase?: string; orderId?: string } }) =>
+      event.data?.phase === "pending" || event.data?.orderId === "pending-order"
+    );
+    expect(pendingEvents).toHaveLength(2);
+    for (const event of pendingEvents) {
+      expect(event).not.toHaveProperty("experimentId");
+      expect(event).not.toHaveProperty("variationId");
+    }
+
+    (observerCallback as MutationCallback | null)?.(
+      [{ type: "attributes", target: routeNode, addedNodes: [] } as unknown as MutationRecord],
+      {} as MutationObserver,
+    );
+    await Promise.resolve();
+    track("analytics_probe", { phase: "resolved" });
+    await flush();
+
+    events = (globalThis.fetch as any).mock.calls
+      .flatMap((call: [string, RequestInit]) => JSON.parse(String(call[1].body)).events);
+    expect(events).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: "analytics_probe",
+        experimentId: "exp_pending_identity",
+        variationId: "var_pending_identity",
+        data: expect.objectContaining({ phase: "resolved" }),
+      }),
+    ]));
+  });
+
+
+  it("keeps click goal listeners after dataLayer-triggered SPA reassignment", async () => {
+    const clickHandlers: Array<(event: { target: unknown }) => void> = [];
+    (globalThis as any).document.addEventListener = vi.fn((type: string, handler: (event: { target: unknown }) => void) => {
+      if (type === "click") clickHandlers.push(handler);
+    });
+
+    const { flush, getAssignments, init } = await import("./index");
+
+    (globalThis as any).window.dataLayer = [];
+    init({
+      antiFlickerMode: "off",
+      dataLayerTriggers: [
+        {
+          eventName: "virtPageView",
+          mappings: [{ from: "page_type", to: "page.type", valueType: "string" }],
+          trackPageview: false,
+        },
+      ],
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_pdp_click",
+          status: "running",
+          targeting: {
+            segmentRules: [
+              {
+                id: "segment_pdp",
+                rules: {
+                  version: 1,
+                  operator: "and",
+                  conditions: [{ signal: "page.type", operator: "equals", value: "pdp" }],
+                },
+              },
+            ],
+          },
+          goals: [
+            {
+              id: "goal_add_to_cart",
+              type: "click",
+              selector: "[data-action='add-cart']",
+              capture: [{ property: "liveRunId", source: "dataset", attribute: "data-live-run-id" }],
+            },
+          ],
+          trafficAllocation: 1,
+          variations: [{ id: "var_pdp", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(getAssignments()).toHaveLength(0);
+    (globalThis as any).window.dataLayer.push({ event: "virtPageView", page_type: "pdp" });
+    expect(getAssignments()).toHaveLength(1);
+
+    const matched = {
+      dataset: { liveRunId: "run-123" },
+      getAttribute: () => null,
+      textContent: "Add to cart",
+    };
+    const target = {
+      closest: (selector: string) => selector === "[data-action='add-cart']" ? matched : null,
+    };
+    for (const handler of clickHandlers) handler({ target });
+    await flush();
+
+    const calls = vi.mocked(globalThis.fetch).mock.calls;
+    const body = JSON.parse(String(calls.at(-1)?.[1]?.body ?? "{}"));
+    expect(body.events).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          type: "goal",
+          data: expect.objectContaining({
+            goalId: "goal_add_to_cart",
+            liveRunId: "run-123",
+          }),
+        }),
+      ]),
+    );
+  });
+
+
+  it("captures DOM and global runtime signals before assignment evaluation", async () => {
+    (globalThis as any).window.Shopify = {
+      analytics: undefined,
+      routes: { root: "/de" },
+    };
+    (globalThis as any).Shopify = (globalThis as any).window.Shopify;
+    (globalThis as any).document.querySelector = vi.fn((selector: string) => {
+      if (selector === "[data-product-type]") {
+        return {
+          getAttribute: (name: string) => (name === "data-product-type" ? "recovery" : null),
+          textContent: "Recovery",
+        };
+      }
+      return null;
+    });
+
+    const { getAssignments, getDiagnostics, getSignals, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_recovery",
+          status: "running",
+          targeting: {
+            segmentRules: [
+              {
+                id: "segment_recovery",
+                rules: {
+                  version: 1,
+                  operator: "and",
+                  conditions: [
+                    { signal: "product.type", operator: "equals", value: "recovery" },
+                    { signal: "shopify.root", operator: "equals", value: "/de" },
+                  ],
+                },
+              },
+            ],
+          },
+          trafficAllocation: 1,
+          variations: [{ id: "var_recovery", weight: 1, mutations: [] }],
+        },
+      ],
+      shopId: "shop_123",
+      signals: [
+        {
+          key: "product.type",
+          valueType: "string",
+          capture: { mode: "dom_selector", selector: "[data-product-type]", source: "attribute", attribute: "data-product-type" },
+        },
+        {
+          key: "shopify.root",
+          valueType: "string",
+          capture: { mode: "global", path: "Shopify.routes.root" },
+        },
+      ],
+      trackingStart: "immediate",
+    });
+
+    expect(getSignals()).toMatchObject({
+      "product.type": "recovery",
+      "shopify.root": "/de",
+    });
+    expect(getDiagnostics().signals.sources).toMatchObject({
+      "product.type": "dom_selector",
+      "shopify.root": "global",
+    });
+    expect(getAssignments()).toHaveLength(1);
+  });
+
+
+  it("keeps runtime signal captures out of persistent storage while consent is denied", async () => {
+    (globalThis as any).location.href = "https://plain.test/?utm_content=creator_a";
+    (globalThis as any).location.search = "?utm_content=creator_a";
+    (globalThis as any).Shopware = { State: { cart: { count: 2 } } };
+    (globalThis as any).window.dataLayer = [];
+    (globalThis as any).document.querySelector = vi.fn((selector: string) => {
+      if (selector === "[data-product-type]") {
+        return {
+          getAttribute: (name: string) => (name === "data-product-type" ? "recovery" : null),
+          textContent: "Recovery",
+        };
+      }
+      return null;
+    });
+
+    const { getAssignments, getDiagnostics, init, reInit } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      consentMode: { enabled: true },
+      dataLayerTriggers: [
+        {
+          eventName: "virtPageView",
+          mappings: [{ from: "page_type", to: "page.type", valueType: "string" }],
+          reEvaluate: true,
+        },
+      ],
+      endpoint: "https://events.test",
+      experiments: [
+        {
+          id: "exp_initial_runtime_signals",
+          status: "running",
+          targeting: {
+            segmentRules: [
+              {
+                id: "initial_runtime_signals",
+                rules: {
+                  version: 1,
+                  operator: "and",
+                  conditions: [
+                    { signal: "utm.content", operator: "equals", value: "creator_a" },
+                    { signal: "product.type", operator: "equals", value: "recovery" },
+                    { signal: "shopware.cart_count", operator: "equals", value: 2 },
+                  ],
+                },
+              },
+            ],
+          },
+          trafficAllocation: 1,
+          variations: [{ id: "var_initial_runtime_signals", weight: 1, mutations: [] }],
+        },
+        {
+          id: "exp_data_layer_runtime_signal",
+          status: "running",
+          targeting: {
+            segmentRules: [
+              {
+                id: "data_layer_runtime_signal",
+                rules: {
+                  version: 1,
+                  operator: "and",
+                  conditions: [{ signal: "page.type", operator: "equals", value: "pdp" }],
+                },
+              },
+            ],
+          },
+          trafficAllocation: 1,
+          variations: [{ id: "var_data_layer_runtime_signal", weight: 1, mutations: [] }],
+        },
+        {
+          id: "exp_manual_runtime_signal",
+          status: "running",
+          targeting: {
+            segmentRules: [
+              {
+                id: "manual_runtime_signal",
+                rules: {
+                  version: 1,
+                  operator: "and",
+                  conditions: [{ signal: "manual.signal", operator: "equals", value: "yes" }],
+                },
+              },
+            ],
+          },
+          trafficAllocation: 1,
+          variations: [{ id: "var_manual_runtime_signal", weight: 1, mutations: [] }],
+        },
+        {
+          id: "exp_queued_runtime_signal",
+          status: "running",
+          targeting: {
+            segmentRules: [
+              {
+                id: "queued_runtime_signal",
+                rules: {
+                  version: 1,
+                  operator: "and",
+                  conditions: [{ signal: "queued.signal", operator: "equals", value: "yes" }],
+                },
+              },
+            ],
+          },
+          trafficAllocation: 1,
+          variations: [{ id: "var_queued_runtime_signal", weight: 1, mutations: [] }],
+        },
+      ],
+      hasConsent: false,
+      shopId: "shop_123",
+      signals: [
+        {
+          key: "utm.content",
+          valueType: "string",
+          capture: { mode: "url_parameter", parameter: "utm_content" },
+        },
+        {
+          key: "product.type",
+          valueType: "string",
+          capture: { mode: "dom_selector", selector: "[data-product-type]", source: "attribute", attribute: "data-product-type" },
+        },
+        {
+          key: "shopware.cart_count",
+          valueType: "number",
+          capture: { mode: "global", path: "Shopware.State.cart.count" },
+        },
+      ],
+      trackingStart: "immediate",
+    });
+
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({ experimentId: "exp_initial_runtime_signals" }),
+    ]);
+    expect(getDiagnostics().signals.values).toMatchObject({
+      "utm.content": "creator_a",
+      "product.type": "recovery",
+      "shopware.cart_count": 2,
+    });
+    expect((globalThis as any).localStorage.getItem("drip_signals_v1")).toBeNull();
+    expect((globalThis as any).localStorage.getItem("drip_visitor_seen_v1")).toBeNull();
+
+    (globalThis as any).window.dataLayer.push({ event: "virtPageView", page_type: "pdp" });
+    (globalThis as any).drip.signal("manual.signal", "yes");
+    (globalThis as any).drip.push({ type: "signal", key: "queued.signal", value: "yes" });
+    reInit();
+
+    expect(getAssignments()).toEqual(expect.arrayContaining([
+      expect.objectContaining({ experimentId: "exp_data_layer_runtime_signal" }),
+      expect.objectContaining({ experimentId: "exp_manual_runtime_signal" }),
+      expect.objectContaining({ experimentId: "exp_queued_runtime_signal" }),
+    ]));
+    expect((globalThis as any).drip.getSignals()).toMatchObject({
+      "page.type": "pdp",
+      "manual.signal": "yes",
+      "queued.signal": "yes",
+    });
+    expect((globalThis as any).localStorage.getItem("drip_signals_v1")).toBeNull();
+    expect((globalThis as any).localStorage.getItem("drip_visitor_seen_v1")).toBeNull();
+  });
+
+
+  it("clears persisted signal storage when consent is revoked", async () => {
+    const { init, setConsent } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      consentMode: { enabled: true },
+      endpoint: "https://events.test",
+      experiments: [],
+      hasConsent: true,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    (globalThis as any).drip.signal("manual.signal", "yes");
+    expect((globalThis as any).localStorage.getItem("drip_signals_v1")).toContain("manual.signal");
+
+    setConsent(false);
+
+    expect((globalThis as any).localStorage.getItem("drip_signals_v1")).toBeNull();
+    expect((globalThis as any).localStorage.getItem("drip_visitor_seen_v1")).toBeNull();
+  });
+
+
+  it("uses full-page anti-flicker while fetching forced QA config without scoped selectors", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a?drip_qa=1&drip_force=exp_1:var_1",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "?drip_qa=1&drip_force=exp_1:var_1",
+    };
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes("/config")) {
+        return new Response(JSON.stringify({
+          experiments: [],
+          profile: { platform: "auto", version: 1 },
+        }), { status: 200 });
+      }
+      return new Response("ok", { status: 202 });
+    }) as any;
+
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "scoped",
+      antiFlickerTimeoutMs: 1200,
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+    });
+
+    expect(appendedAntiFlickerStyle()).toBeDefined();
+    expect(document.head.appendChild).toHaveBeenCalled();
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      "https://events.test/config?shopId=shop_123&drip_qa=1&drip_force=exp_1%3Avar_1",
+      expect.objectContaining({ signal: expect.any(Object) }),
+    );
+
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+    await Promise.resolve();
+  });
+
+
+  it.each([
+    ["QA", "?drip_qa=1&drip_force=exp_off_target_force:var_off_target_force"],
+    ["screenshot", "?drip_screenshot=1&drip_force=exp_off_target_force:var_off_target_force"],
+  ] as const)("keeps a %s-forced off-target network assignment attributable without rendering it", async (mode, search) => {
+    Object.assign((globalThis as any).location, {
+      href: `https://plain.test/thank-you${search}`,
+      pathname: "/thank-you",
+      search,
+    });
+    const headline = { textContent: "Order confirmed" };
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) =>
+      selector === "#forced-headline" ? [headline] : [],
+    );
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+      if (String(input).includes("/config")) {
+        return Response.json({
+          experiments: [{
+            id: "exp_off_target_force",
+            status: "running",
+            targeting: { url: [{ type: "simple", pattern: "/products/*" }] },
+            trafficAllocation: 1,
+            goalPageRules: [{
+              id: "page_thank_you",
+              includeRules: [{ type: "simple", pattern: "/thank-you", include: true }],
+            }],
+            variations: [{
+              id: "var_off_target_force",
+              weight: 1,
+              mutations: [{
+                selector: "#forced-headline",
+                action: "text",
+                text: "Treatment rendered",
+              }],
+            }],
+            goals: [{
+              id: "goal_off_target_force",
+              type: "click",
+              selector: "#complete-order",
+              pageId: "page_thank_you",
+            }],
+          }],
+        });
+      }
+      return new Response("ok", { status: 202 });
+    }) as any;
+    const { __test, flush, getAssignments, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_off_target_force",
+    });
+    await flushDynamicImports();
+
+    const assignments = getAssignments();
+    expect(assignments).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_off_target_force",
+        variationId: "var_off_target_force",
+        pageActive: false,
+      }),
+    ]);
+    expect(__test!.artifactRenderableAssignments(assignments)).toEqual([]);
+    expect(headline.textContent).toBe("Order confirmed");
+
+    const target = {
+      closest: vi.fn((selector: string) => selector === "#complete-order" ? target : null),
+    };
+    if (mode === "QA") expect(documentListeners.click ?? []).not.toHaveLength(0);
+    for (const handler of documentListeners.click ?? []) handler({ target });
+    await flush();
+
+    const events = vi.mocked(globalThis.fetch).mock.calls
+      .filter(([input]) => String(input) === "https://events.test/v1/events")
+      .flatMap(([, request]) => JSON.parse(String(request?.body)).events);
+    if (mode === "QA") {
+      expect(events).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+          type: "goal",
+          experimentId: "exp_off_target_force",
+          variationId: "var_off_target_force",
+          data: expect.objectContaining({ goalId: "goal_off_target_force" }),
+        }),
+      ]));
+    }
+  });
+
+
+  it("keeps an unforced off-target network experiment unassigned in QA", async () => {
+    Object.assign((globalThis as any).location, {
+      href: "https://plain.test/thank-you?drip_qa=1",
+      pathname: "/thank-you",
+      search: "?drip_qa=1",
+    });
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+      if (String(input).includes("/config")) {
+        return Response.json({
+          experiments: [{
+            id: "exp_unforced_off_target",
+            status: "running",
+            targeting: { url: [{ type: "simple", pattern: "/products/*" }] },
+            trafficAllocation: 1,
+            variations: [{ id: "var_unforced_off_target", weight: 1, mutations: [] }],
+          }],
+        });
+      }
+      return new Response("ok", { status: 202 });
+    }) as any;
+    const { getAssignments, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+      userId: "visitor_unforced_off_target",
+    });
+    await flushDynamicImports();
+
+    expect(getAssignments()).toEqual([]);
+  });
+
+
+  it("reports an unavailable forced experiment on a cold inline QA load", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a?drip_qa=1&drip_force=exp_missing:var_missing",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "?drip_qa=1&drip_force=exp_missing:var_missing",
+    };
+    const { __getQaAssistantRuntimeSnapshot, init } = await import("./index");
+
+    init({ experiments: [] });
+
+    expect(__getQaAssistantRuntimeSnapshot().forcedUnavailable).toEqual([
+      { experimentId: "exp_missing", reason: "not_in_config" },
+    ]);
+  });
+
+
+  it("copies server-classified QA warnings from a fetched config", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a?drip_qa=1&drip_force=exp_archived:var_archived",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "?drip_qa=1&drip_force=exp_archived:var_archived",
+    };
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+      if (String(input).includes("/config")) {
+        return Response.json({
+          experiments: [],
+          qa_warnings: [{
+            code: "forced_experiment_unavailable",
+            experiment_id: "exp_archived",
+            reason: "archived",
+          }],
+        });
+      }
+      return new Response("ok", { status: 202 });
+    }) as any;
+    const { __getQaAssistantRuntimeSnapshot, init } = await import("./index");
+
+    init({ antiFlickerMode: "off", endpoint: "https://events.test", shopId: "shop_123" });
+    await flushDynamicImports();
+
+    expect(__getQaAssistantRuntimeSnapshot().forcedUnavailable).toEqual([
+      { experimentId: "exp_archived", reason: "archived" },
+    ]);
+  });
+
+
+  it("delivers edge device-audience warnings from the real QA /config shape to the assistant state", async () => {
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a?drip_qa=1",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "?drip_qa=1",
+    };
+    localStorage.setItem("drip_cfg:shop_123:production", JSON.stringify({
+      fetchedAt: Date.now(),
+      hash: "non-qa-cached-config",
+      experiments: [],
+    }));
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+      if (String(input).includes("/config")) {
+        return Response.json({
+          experiments: [{
+            id: "exp_redirect",
+            type: "redirect",
+            targeting: { segmentRules: [] },
+            variations: [{ id: "control", weight: 1, mutations: [] }],
+          }],
+          geo: { country: "UNKNOWN" },
+          qa_warnings: [{
+            code: "edge_device_audience_unsupported",
+            experiment_id: "exp_redirect",
+            audience_name: "Mobile shoppers",
+          }],
+        });
+      }
+      return new Response("ok", { status: 202 });
+    }) as any;
+    const { __getQaAssistantRuntimeSnapshot, init } = await import("./index");
+
+    init({ antiFlickerMode: "off", endpoint: "https://events.test", shopId: "shop_123" });
+    await flushDynamicImports();
+
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      "https://events.test/config?shopId=shop_123&drip_qa=1",
+      expect.objectContaining({ signal: expect.any(Object) }),
+    );
+    expect(__getQaAssistantRuntimeSnapshot().edgeDeviceAudienceUnsupported).toEqual([
+      { experimentId: "exp_redirect", audienceName: "Mobile shoppers" },
+    ]);
+  });
+
+
+  it("preserves scoped anti-flicker when network config supplies non-commerce mutations", async () => {
+    installMutationObserverStub();
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+      if (String(input).includes("/config")) {
+        return Response.json({
+          experiments: [{
+            id: "exp_network",
+            status: "running",
+            trafficAllocation: 1,
+            variations: [{
+              id: "var_network",
+              weight: 1,
+              mutations: [{ selector: ".network-title", action: "text", text: "Fetched" }],
+            }],
+          }],
+        });
+      }
+      return new Response("ok", { status: 202 });
+    }) as any;
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "scoped",
+      endpoint: "https://events.test",
+      lateConfigPolicy: "apply",
+      shopId: "shop_123",
+    });
+    await flushDynamicImports();
+
+    expect(document.head.appendChild).toHaveBeenCalled();
+  });
+
+
+  it("includes URL block mutation selectors in scoped anti-flicker CSS", async () => {
+    installMutationObserverStub();
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => {
+      if (String(input).includes("/config")) {
+        return Response.json({
+          experiments: [{
+            id: "exp_network",
+            status: "running",
+            trafficAllocation: 1,
+            variations: [{
+              id: "var_network",
+              weight: 1,
+              mutations: [],
+              urlBlocks: [{
+                id: "product-a",
+                name: "Product A",
+                urlRules: [{ type: "simple", pattern: "/products/a" }],
+                mutations: [{
+                  selector: ".block-title",
+                  action: "text",
+                  text: "Fetched",
+                }],
+              }],
+            }],
+          }],
+        });
+      }
+      return new Response("ok", { status: 202 });
+    }) as any;
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "scoped",
+      endpoint: "https://events.test",
+      lateConfigPolicy: "apply",
+      shopId: "shop_123",
+    });
+    await flushDynamicImports();
+
+    expect(appendedAntiFlickerStyle()?.textContent).toContain(".block-title");
+  });
+});