@drip-apex/sdk 0.1.0 → 0.3.0

package/src/init-config-resolution.test.ts

@@ -0,0 +1,999 @@
+import { describe, expect, it, vi } from "vitest";
+import type { UrlRule } 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 config resolution", () => {
+  registerInitTestLifecycle();
+
+
+  it("discards a matching bootstrap predecision for a global-holdout visitor", async () => {
+    const { isHoldoutVisitor } = await import("./hash");
+    const visitorId = Array.from({ length: 2000 }, (_, index) => `predecision-holdout-${index}`)
+      .find((id) => isHoldoutVisitor({ holdout_v1_enabled: true, holdout_pct: 10 }, id))!;
+    (globalThis as any).__dripPredecided = {
+      decision: [["exp_holdout_predecision", "var_treatment"]], configRevision: 7, visitorId, groups: {},
+    };
+    const { init } = await import("./index");
+    const assignments = init({
+      antiFlickerMode: "off", userId: visitorId, delivery: { revision: 7 },
+      holdout_v1_enabled: true, holdout_pct: 10,
+      experiments: [{ id: "exp_holdout_predecision", name: "Holdout", status: "running", trafficAllocation: 1,
+        variations: [{ id: "var_treatment", weight: 1, mutations: [] }] }],
+    });
+    expect(assignments).toEqual([]);
+  });
+
+
+  it("keeps a predecided sticky winner after traffic allocation is reduced", async () => {
+    const visitorId = "predecision-sticky-visitor";
+    (globalThis as any).__dripPredecided = {
+      decision: [["exp_sticky_predecision", "var_sticky"]], configRevision: 8, visitorId, groups: {},
+    };
+    const { init } = await import("./index");
+    const assignments = init({
+      antiFlickerMode: "off", userId: visitorId, delivery: { revision: 8 },
+      experiments: [{ id: "exp_sticky_predecision", name: "Sticky", status: "running", trafficAllocation: 0,
+        variations: [{ id: "var_sticky", weight: 1, mutations: [] }] }],
+    });
+    expect(assignments).toEqual([expect.objectContaining({ experimentId: "exp_sticky_predecision", variationId: "var_sticky" })]);
+  });
+
+
+  it("applies the matching URL block on a predecided first visit", async () => {
+    const visitorId = "predecision-url-block-visitor";
+    const title = { textContent: "Original" };
+    installMutationObserverStub();
+    (globalThis as any).location = {
+      hash: "",
+      hostname: "plain.test",
+      href: "https://plain.test/products/a",
+      origin: "https://plain.test",
+      pathname: "/products/a",
+      search: "",
+    };
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#product-title" ? [title] : []
+    ));
+    (globalThis as any).__dripPredecided = {
+      decision: [["exp_url_block_predecision", "var_treatment"]],
+      configRevision: 1097,
+      visitorId,
+      groups: {},
+    };
+    const { init } = await import("./index");
+
+    const assignments = init({
+      antiFlickerMode: "off",
+      delivery: { revision: 1097 },
+      experiments: [{
+        id: "exp_url_block_predecision",
+        name: "URL block predecision",
+        status: "running",
+        trafficAllocation: 0,
+        variations: [{
+          id: "var_treatment",
+          weight: 1,
+          mutations: [{
+            selector: "#product-title",
+            action: "text",
+            text: "Flat fallback",
+          }],
+          urlBlocks: [{
+            id: "product-a",
+            name: "Product A",
+            urlRules: [{ type: "simple", pattern: "/products/a" }],
+            mutations: [{
+              selector: "#product-title",
+              action: "text",
+              text: "Block treatment",
+            }],
+          }],
+        }],
+      }],
+      userId: visitorId,
+    });
+
+    expect(assignments[0]).toMatchObject({
+      activeUrlBlockId: "product-a",
+      variationId: "var_treatment",
+    });
+    expect(title.textContent).toBe("Block treatment");
+  });
+
+
+  it.each([
+    [
+      "QA force link",
+      "?drip_qa=1&drip_experiment_id=exp_qa_predecision&drip_variation_id=var_qa_treatment",
+      "",
+    ],
+    [
+      "QA force cookie",
+      "",
+      "drip_qa_force=exp_qa_predecision%3Avar_qa_treatment",
+    ],
+  ])("defers a %s override of an early_reassert predecision until hydration", async (
+    _source,
+    search,
+    cookie,
+  ) => {
+    const visitorId = "qa-predecision-visitor";
+    const forcedTitle = { textContent: "Original forced title" };
+    const siblingTitle = { textContent: "Original sibling title" };
+    installMutationObserverStub();
+    const earlyReassert = await import("./early-reassert");
+    const installEarlyReassert = vi.spyOn(earlyReassert, "installEarlyReassert");
+    Object.assign((globalThis as any).location, {
+      href: `https://plain.test/${search}`,
+      search,
+    });
+    (globalThis as any).document.cookie = cookie;
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => {
+      if (selector === "#forced-title") return [forcedTitle];
+      if (selector === "#sibling-title") return [siblingTitle];
+      return [];
+    });
+    (globalThis as any).__dripPredecided = {
+      decision: [
+        ["exp_qa_predecision", "var_qa_control"],
+        ["exp_qa_sibling", "var_sibling_treatment"],
+      ],
+      configRevision: 1215,
+      visitorId,
+      groups: {},
+    };
+    const { getAssignments, hydrated, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      delivery: { revision: 1215 },
+      experiments: [
+        {
+          id: "exp_qa_predecision",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [
+            { id: "var_qa_control", isControl: true, weight: 1, mutations: [] },
+            {
+              id: "var_qa_treatment",
+              weight: 0,
+              mutations: [{ selector: "#forced-title", action: "text", text: "Forced treatment" }],
+            },
+          ],
+        },
+        {
+          id: "exp_qa_sibling",
+          status: "running",
+          trafficAllocation: 1,
+          variations: [
+            { id: "var_sibling_control", isControl: true, weight: 1, mutations: [] },
+            {
+              id: "var_sibling_treatment",
+              weight: 0,
+              mutations: [{ selector: "#sibling-title", action: "text", text: "Sibling predecision" }],
+            },
+          ],
+        },
+      ],
+      shopId: "shop_123",
+      spa: { applyTiming: "early_reassert", hydrationTimeoutMs: 3_000 },
+      trackingStart: "immediate",
+      userId: visitorId,
+    });
+
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_qa_predecision",
+        variationId: "var_qa_treatment",
+      }),
+      expect.objectContaining({
+        experimentId: "exp_qa_sibling",
+        variationId: "var_sibling_treatment",
+      }),
+    ]);
+    expect(forcedTitle.textContent).toBe("Original forced title");
+    expect(siblingTitle.textContent).toBe("Original sibling title");
+    expect(installEarlyReassert).not.toHaveBeenCalled();
+
+    hydrated();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(forcedTitle.textContent).toBe("Forced treatment");
+    expect(siblingTitle.textContent).toBe("Sibling predecision");
+    expect((globalThis as any).localStorage.getItem("drip_assignments_v1")).toBeNull();
+  });
+
+
+  it("writes only the functional QA force cookie when consent is denied", async () => {
+    Object.assign((globalThis as any).location, {
+      href: "https://plain.test/?drip_qa=1&drip_force=exp_consent_qa%3Avar_consent_qa",
+      search: "?drip_qa=1&drip_force=exp_consent_qa%3Avar_consent_qa",
+    });
+    const cookieWrites = installCookieJar();
+    const { getDiagnostics, init } = await import("./index");
+
+    const assignments = init({
+      antiFlickerMode: "off",
+      consentMode: { enabled: true },
+      experiments: [{
+        id: "exp_consent_qa",
+        status: "draft",
+        trafficAllocation: 1,
+        variations: [
+          { id: "var_control", isControl: true, weight: 1, mutations: [] },
+          { id: "var_consent_qa", weight: 0, mutations: [] },
+        ],
+      }],
+      hasConsent: false,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+
+    expect(getDiagnostics().qaMode).toBe(true);
+    expect(assignments).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_consent_qa",
+        variationId: "var_consent_qa",
+      }),
+    ]);
+    expect(cookieWrites).toContain(
+      "drip_qa_force=exp_consent_qa%3Avar_consent_qa;path=/;max-age=1800;samesite=lax",
+    );
+    expect((globalThis as any).localStorage.getItem("drip_uid")).toBeNull();
+    expect((globalThis as any).localStorage.getItem("drip_assignments_v1")).toBeNull();
+    expect(readCookieValue("drip_uid")).toBeNull();
+    expect(readCookieValue("drip_assignments_v1")).toBeNull();
+  });
+
+
+  it("restores and renews a cookie-only QA force when consent is denied", async () => {
+    const cookieWrites = installCookieJar(
+      "drip_qa_force=exp_cookie_qa%3Avar_cookie_qa",
+    );
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => (
+      String(input).includes("/config")
+        ? Response.json({
+            experiments: [{
+              id: "exp_cookie_qa",
+              status: "running",
+              trafficAllocation: 1,
+              variations: [
+                { id: "var_control", isControl: true, weight: 1, mutations: [] },
+                { id: "var_cookie_qa", weight: 0, mutations: [] },
+              ],
+            }],
+          })
+        : new Response("ok", { status: 202 })
+    )) as any;
+    const { getAssignments, getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      consentMode: { enabled: true },
+      endpoint: "https://events.test",
+      hasConsent: false,
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await vi.waitFor(() => expect(getDiagnostics().configSource).toBe("network"));
+
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      "https://events.test/config?shopId=shop_123&drip_qa=1&drip_force=exp_cookie_qa%3Avar_cookie_qa",
+      expect.objectContaining({ signal: expect.any(Object) }),
+    );
+    expect(getDiagnostics().qaMode).toBe(true);
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_cookie_qa",
+        variationId: "var_cookie_qa",
+      }),
+    ]);
+    expect(cookieWrites).toContain(
+      "drip_qa_force=exp_cookie_qa%3Avar_cookie_qa;path=/;max-age=1800;samesite=lax",
+    );
+    expect((globalThis as any).localStorage.getItem("drip_uid")).toBeNull();
+    expect((globalThis as any).localStorage.getItem("drip_assignments_v1")).toBeNull();
+  });
+
+
+  it("defers custom-JS early_reassert assignments until hydration", async () => {
+    const visitorId = "custom-js-predecision-visitor";
+    installMutationObserverStub();
+    const target = {
+      getAttribute: vi.fn(() => null),
+      removeAttribute: vi.fn(),
+      setAttribute: vi.fn(),
+    };
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#custom-js-target" ? [target] : []
+    ));
+    (globalThis as any).__dripPredecided = {
+      decision: [["exp_custom_js_predecision", "var_custom_js_treatment"]],
+      configRevision: 1217,
+      visitorId,
+      groups: {},
+    };
+    const { hydrated, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      delivery: { revision: 1217 },
+      experiments: [{
+        id: "exp_custom_js_predecision",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{
+          id: "var_custom_js_treatment",
+          weight: 1,
+          mutations: [{
+            selector: "#custom-js-target",
+            action: "attribute",
+            attribute: { name: "data-treatment", value: "active" },
+          }],
+          js: "document.title='x'",
+        }],
+      }],
+      shopId: "shop_123",
+      spa: { applyTiming: "early_reassert", hydrationTimeoutMs: 3_000 },
+      trackingStart: "immediate",
+      userId: visitorId,
+    });
+
+    expect(target.setAttribute).not.toHaveBeenCalled();
+    expect((globalThis as any).document.title).toBe("Plain probe");
+
+    hydrated();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(target.setAttribute).toHaveBeenCalledWith("data-treatment", "active");
+    expect((globalThis as any).document.title).toBe("x");
+  });
+
+
+  it("defers a cookie-forced network QA treatment until hydration under early_reassert", async () => {
+    const title = { textContent: "Original title" };
+    installMutationObserverStub();
+    Object.defineProperty((globalThis as any).document, "cookie", {
+      configurable: true,
+      get: () => "drip_qa_force=exp_qa_network%3Avar_qa_network_treatment",
+      set: vi.fn(),
+    });
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#qa-network-title" ? [title] : []
+    ));
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => (
+      String(input).includes("/config")
+        ? new Response(JSON.stringify({
+            experiments: [{
+              id: "exp_qa_network",
+              status: "running",
+              trafficAllocation: 1,
+              variations: [
+                { id: "var_qa_network_control", isControl: true, weight: 1, mutations: [] },
+                {
+                  id: "var_qa_network_treatment",
+                  weight: 0,
+                  mutations: [{ selector: "#qa-network-title", action: "text", text: "Forced treatment" }],
+                },
+              ],
+            }],
+            runtime: { spa: { applyTiming: "early_reassert", hydrationTimeoutMs: 3_000 } },
+          }), { status: 200 })
+        : new Response("ok", { status: 202 })
+    )) as any;
+    const { getAssignments, getDiagnostics, hydrated, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await vi.waitFor(() => expect(getDiagnostics().configSource).toBe("network"));
+
+    expect(getDiagnostics().qaMode).toBe(true);
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_qa_network",
+        variationId: "var_qa_network_treatment",
+      }),
+    ]);
+    expect(title.textContent).toBe("Original title");
+
+    hydrated();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(title.textContent).toBe("Forced treatment");
+  });
+
+
+  it("defers a screenshot-forced network treatment until hydration under early_reassert", async () => {
+    const title = { textContent: "Original title" };
+    installMutationObserverStub();
+    Object.assign((globalThis as any).location, {
+      href: "https://plain.test/?drip_screenshot=1&drip_force=exp_ss_network%3Avar_ss_network_treatment",
+      search: "?drip_screenshot=1&drip_force=exp_ss_network%3Avar_ss_network_treatment",
+    });
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#ss-network-title" ? [title] : []
+    ));
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => (
+      String(input).includes("/config")
+        ? new Response(JSON.stringify({
+            experiments: [{
+              id: "exp_ss_network",
+              status: "running",
+              trafficAllocation: 1,
+              variations: [
+                { id: "var_ss_network_control", isControl: true, weight: 1, mutations: [] },
+                {
+                  id: "var_ss_network_treatment",
+                  weight: 0,
+                  mutations: [{ selector: "#ss-network-title", action: "text", text: "Forced treatment" }],
+                },
+              ],
+            }],
+            runtime: { spa: { applyTiming: "early_reassert", hydrationTimeoutMs: 3_000 } },
+          }), { status: 200 })
+        : new Response("ok", { status: 202 })
+    )) as any;
+    const { getAssignments, getDiagnostics, hydrated, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await vi.waitFor(() => expect(getDiagnostics().configSource).toBe("network"));
+
+    expect(getDiagnostics().qaMode).toBe(false);
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_ss_network",
+        variationId: "var_ss_network_treatment",
+      }),
+    ]);
+    expect(title.textContent).toBe("Original title");
+
+    hydrated();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(title.textContent).toBe("Forced treatment");
+  });
+
+
+  it("keeps non-QA network early_reassert treatments immediate", async () => {
+    const title = { textContent: "Original title" };
+    installMutationObserverStub();
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#network-title" ? [title] : []
+    ));
+    globalThis.fetch = vi.fn(async (input: RequestInfo | URL) => (
+      String(input).includes("/config")
+        ? new Response(JSON.stringify({
+            experiments: [{
+              id: "exp_network",
+              status: "running",
+              trafficAllocation: 1,
+              variations: [{
+                id: "var_network_treatment",
+                weight: 1,
+                mutations: [{ selector: "#network-title", action: "text", text: "Treatment" }],
+              }],
+            }],
+            runtime: { spa: { applyTiming: "early_reassert", hydrationTimeoutMs: 3_000 } },
+          }), { status: 200 })
+        : new Response("ok", { status: 202 })
+    )) as any;
+    const { getDiagnostics, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      shopId: "shop_123",
+      trackingStart: "immediate",
+    });
+    await vi.waitFor(() => expect(getDiagnostics().configSource).toBe("network"));
+
+    expect(title.textContent).toBe("Treatment");
+  });
+
+
+  it("keeps an early_reassert predecision when drip_force=clear removes a stale QA force", async () => {
+    const visitorId = "qa-predecision-clear-visitor";
+    const title = { textContent: "Original title" };
+    installMutationObserverStub();
+    Object.assign((globalThis as any).location, {
+      href: "https://plain.test/?drip_force=clear",
+      search: "?drip_force=clear",
+    });
+    (globalThis as any).document.cookie = "drip_qa_force=exp_qa_clear%3Avar_qa_treatment";
+    (globalThis as any).document.querySelectorAll = vi.fn((selector: string) => (
+      selector === "#clear-title" ? [title] : []
+    ));
+    (globalThis as any).__dripPredecided = {
+      decision: [["exp_qa_clear", "var_qa_control"]],
+      configRevision: 1216,
+      visitorId,
+      groups: {},
+    };
+    const { getAssignments, init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      delivery: { revision: 1216 },
+      experiments: [{
+        id: "exp_qa_clear",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [
+          {
+            id: "var_qa_control",
+            isControl: true,
+            weight: 0,
+            mutations: [{ selector: "#clear-title", action: "text", text: "Predecided control" }],
+          },
+          {
+            id: "var_qa_treatment",
+            weight: 1,
+            mutations: [{ selector: "#clear-title", action: "text", text: "Stale forced treatment" }],
+          },
+        ],
+      }],
+      shopId: "shop_123",
+      spa: { applyTiming: "early_reassert", hydrationTimeoutMs: 3_000 },
+      trackingStart: "immediate",
+      userId: visitorId,
+    });
+
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({
+        experimentId: "exp_qa_clear",
+        variationId: "var_qa_control",
+      }),
+    ]);
+    expect(title.textContent).toBe("Predecided control");
+  });
+
+
+  it("persists a bootstrap provisional visitor identity when storage is allowed", async () => {
+    const visitorId = "predecision-persisted-visitor";
+    (globalThis as any).__dripPredecided = {
+      decision: [], configRevision: 9, visitorId, groups: {},
+    };
+    const { init } = await import("./index");
+    const { getUserId } = await import("./hash");
+
+    init({
+      antiFlickerMode: "off",
+      delivery: { revision: 9 },
+      experiments: [],
+    });
+
+    expect((globalThis as any).localStorage.getItem("drip_uid")).toBe(visitorId);
+    expect(getUserId()).toBe(visitorId);
+  });
+
+
+  it("does not persist a client-provided identity when a bootstrap identity is present", async () => {
+    (globalThis as any).__dripPredecided = {
+      decision: [], configRevision: 10, visitorId: "predecision-ignored-visitor", groups: {},
+    };
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      delivery: { revision: 10 },
+      experiments: [],
+      userId: "client-provided-visitor",
+    });
+
+    expect((globalThis as any).localStorage.getItem("drip_uid")).toBeNull();
+    expect(readCookieValue("drip_uid")).toBeNull();
+  });
+
+
+  it("does not persist a bootstrap provisional visitor identity when storage is blocked", async () => {
+    (globalThis as any).__dripPredecided = {
+      decision: [], configRevision: 11, visitorId: "predecision-ephemeral-visitor", groups: {},
+    };
+    const { init } = await import("./index");
+
+    init({
+      antiFlickerMode: "off",
+      consentMode: { enabled: true },
+      delivery: { revision: 11 },
+      experiments: [],
+      hasConsent: false,
+    });
+
+    expect((globalThis as any).localStorage.getItem("drip_uid")).toBeNull();
+    expect(readCookieValue("drip_uid")).toBeNull();
+  });
+
+
+  it("clears bootstrap predecision state when diagnostic evaluation throws", async () => {
+    const targeting = await import("./targeting");
+    const evaluateTargeting = vi.spyOn(targeting, "evaluateTargetingGatesDetailed")
+      .mockImplementationOnce(() => {
+        throw new Error("diagnostic evaluation failed");
+      });
+    const { evaluate, init } = await import("./index");
+    const visitorId = "predecision-throw-visitor";
+    const experiments = [{
+      id: "exp_predecision_throw",
+      name: "Throwing predecision",
+      status: "running" as const,
+      trafficAllocation: 0,
+      variations: [{ id: "var_predecision_throw", weight: 1, mutations: [] }],
+    }];
+    (globalThis as any).__dripPredecided = {
+      decision: [["exp_predecision_throw", "var_predecision_throw"]],
+      configRevision: 12,
+      visitorId,
+      groups: {},
+    };
+
+    expect(() => init({
+      antiFlickerMode: "off",
+      delivery: { revision: 12 },
+      experiments,
+    })).toThrow("diagnostic evaluation failed");
+    expect(evaluateTargeting).toHaveBeenCalled();
+
+    expect(evaluate(experiments, { userId: visitorId })).toEqual([]);
+  });
+
+
+  it("installs inline request geography before evaluating country targeting", async () => {
+    const { getSignals, init } = await import("./index");
+    const assignments = init({
+      antiFlickerMode: "off",
+      geo: { country: "DE" },
+      trackingStart: "immediate",
+      userId: "geo-inline-visitor",
+      experiments: [{
+        id: "exp_geo_inline",
+        name: "Germany",
+        status: "running",
+        trafficAllocation: 1,
+        targeting: {
+          segmentRules: [{
+            id: "seg_geo_inline",
+            include: true,
+            rules: {
+              version: 1,
+              operator: "and",
+              conditions: [{ signal: "geo.country", operator: "equals", value: "DE" }],
+            },
+          }],
+        },
+        variations: [{ id: "var_geo", weight: 1, mutations: [] }],
+      }],
+    });
+
+    expect(getSignals({ markVisitorSeen: false })["geo.country"]).toBe("DE");
+    expect(assignments).toEqual([expect.objectContaining({ experimentId: "exp_geo_inline" })]);
+  });
+
+
+  it("reuses targeting attributes within one evaluation pass and rebuilds them for re-init", async () => {
+    const targeting = await import("./targeting");
+    const buildTargetingAttributes = vi.spyOn(targeting, "buildTargetingAttributes");
+    const { init, reInit } = await import("./index");
+    const experiments = [{
+      id: "exp_targeting_pass",
+      status: "running" as const,
+      trafficAllocation: 1,
+      variations: [{ id: "var_targeting_pass", weight: 1, mutations: [] }],
+    }];
+
+    expect(init({
+      antiFlickerMode: "off",
+      experiments,
+      trackingStart: "immediate",
+      userId: "targeting-pass-visitor",
+    })).toHaveLength(1);
+    expect(buildTargetingAttributes).toHaveBeenCalledTimes(1);
+
+    expect(reInit()).toHaveLength(1);
+    expect(buildTargetingAttributes).toHaveBeenCalledTimes(2);
+  });
+
+
+  it("keeps the assignment-time DOM targeting snapshot through idle exposure and goal wiring", async () => {
+    let runIdle: (() => void) | undefined;
+    (globalThis as any).requestIdleCallback = vi.fn((callback: () => void) => {
+      runIdle = callback;
+      return 42;
+    });
+    (globalThis as any).cancelIdleCallback = vi.fn();
+    (globalThis as any).document.referrer = "https://www.google.com/search?q=apex";
+
+    const exposureSignals = await import("./exposure-signals");
+    const targeting = await import("./targeting");
+    const buildExposureSignalContext = vi.spyOn(exposureSignals, "buildExposureSignalContext");
+    const buildTargetingAttributes = vi.spyOn(targeting, "buildTargetingAttributes");
+    const evaluateTargeting = vi.spyOn(targeting, "evaluateTargetingGatesDetailed");
+    const { flush, init } = await import("./index");
+    const pageRule = {
+      id: "page_idle_assignment_snapshot",
+      includeRules: [{ type: "simple" as const, pattern: "/" }],
+      advancedCondition: {
+        code: 'return attributes["traffic.source"] === "search";',
+      },
+    };
+
+    expect(init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_idle_assignment_snapshot",
+        status: "running",
+        targeting: { pageRules: [pageRule] },
+        trafficAllocation: 1,
+        variations: [{ id: "var_idle_assignment_snapshot", weight: 1, mutations: [] }],
+        goals: [{
+          id: "goal_idle_assignment_snapshot",
+          type: "click",
+          selector: ".buy",
+          pageId: pageRule.id,
+        }],
+      }],
+      shopId: "shop_123",
+      trackingStart: "idle",
+      userId: "visitor_idle_assignment_snapshot",
+    })).toHaveLength(1);
+
+    const decisionAttributes = evaluateTargeting.mock.calls[0]?.[1].attributes;
+    expect(decisionAttributes).toMatchObject({
+      referrer: "www.google.com",
+      "traffic.source": "search",
+    });
+
+    (globalThis as any).document.referrer = "https://mutated.test/from-dom";
+    runIdle?.();
+
+    const exposureAttributes = buildExposureSignalContext.mock.calls[0]?.[0].attributes;
+    expect(buildTargetingAttributes).toHaveBeenCalledTimes(1);
+    expect(exposureAttributes).toBe(decisionAttributes);
+
+    const target = {
+      closest: vi.fn((selector: string) => selector === ".buy" ? target : null),
+      textContent: "Buy",
+    };
+    for (const handler of documentListeners.click ?? []) handler({ target });
+    await flush();
+
+    const events = vi.mocked(globalThis.fetch).mock.calls
+      .filter(([url]) => url === "https://events.test/v1/events")
+      .flatMap(([, request]) => JSON.parse(String(request?.body)).events);
+    expect(events).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: "experiment_viewed",
+        data: expect.objectContaining({ signals: expect.objectContaining({ traffic_source: "search" }) }),
+      }),
+      expect.objectContaining({
+        type: "goal",
+        data: expect.objectContaining({ goalId: "goal_idle_assignment_snapshot" }),
+      }),
+    ]));
+  });
+
+
+  it("rebuilds targeting attributes when navigation occurs before idle analytics starts", async () => {
+    let runIdle: (() => void) | undefined;
+    (globalThis as any).requestIdleCallback = vi.fn((callback: () => void) => {
+      runIdle = callback;
+      return 42;
+    });
+    (globalThis as any).cancelIdleCallback = vi.fn();
+    (globalThis as any).document.referrer = "https://www.google.com/search?q=apex";
+
+    const exposureSignals = await import("./exposure-signals");
+    const targeting = await import("./targeting");
+    const buildExposureSignalContext = vi.spyOn(exposureSignals, "buildExposureSignalContext");
+    const buildTargetingAttributes = vi.spyOn(targeting, "buildTargetingAttributes");
+    const evaluateTargeting = vi.spyOn(targeting, "evaluateTargetingGatesDetailed");
+    const { flush, init, reInit } = await import("./index");
+
+    expect(init({
+      antiFlickerMode: "off",
+      endpoint: "https://events.test",
+      experiments: [{
+        id: "exp_idle_navigation_fallback",
+        status: "running",
+        targeting: {
+          pageRules: [
+            {
+              id: "page_idle_assignment_url",
+              includeRules: [{ type: "simple", pattern: "/" }],
+              advancedCondition: {
+                code: 'return url.pathname === "/" && attributes["traffic.source"] === "search";',
+              },
+            },
+            {
+              id: "page_idle_navigation_url",
+              includeRules: [{ type: "simple", pattern: "/next" }],
+              advancedCondition: {
+                code: 'return attributes["traffic.source"] === "referral";',
+              },
+            },
+          ],
+        },
+        trafficAllocation: 1,
+        variations: [{ id: "var_idle_navigation_fallback", weight: 1, mutations: [] }],
+        goals: [{
+          id: "goal_idle_navigation_fallback",
+          type: "click",
+          selector: ".buy",
+          pageId: "page_idle_navigation_url",
+        }],
+      }],
+      shopId: "shop_123",
+      trackingStart: "idle",
+      userId: "visitor_idle_navigation_fallback",
+    })).toHaveLength(1);
+
+    const decisionAttributes = evaluateTargeting.mock.calls[0]?.[1].attributes;
+    expect(decisionAttributes).toMatchObject({
+      "traffic.source": "search",
+      "url.path": "/",
+    });
+
+    Object.assign((globalThis as any).location, {
+      href: "https://plain.test/next",
+      pathname: "/next",
+    });
+    (globalThis as any).document.referrer = "https://mutated.test/from-dom";
+    reInit();
+    runIdle?.();
+
+    const exposureAttributes = buildExposureSignalContext.mock.calls[0]?.[0].attributes;
+    expect(buildTargetingAttributes).toHaveBeenCalledTimes(3);
+    expect(exposureAttributes).not.toBe(decisionAttributes);
+    expect(exposureAttributes).toMatchObject({
+      "traffic.source": "referral",
+      "url.path": "/next",
+    });
+
+    const target = {
+      closest: vi.fn((selector: string) => selector === ".buy" ? target : null),
+      textContent: "Buy",
+    };
+    for (const handler of documentListeners.click ?? []) handler({ target });
+    await flush();
+
+    const events = vi.mocked(globalThis.fetch).mock.calls
+      .filter(([url]) => url === "https://events.test/v1/events")
+      .flatMap(([, request]) => JSON.parse(String(request?.body)).events);
+    expect(events).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        type: "experiment_viewed",
+        data: expect.objectContaining({ signals: expect.objectContaining({ traffic_source: "referral" }) }),
+      }),
+      expect.objectContaining({
+        type: "goal",
+        data: expect.objectContaining({ goalId: "goal_idle_navigation_fallback" }),
+      }),
+    ]));
+  });
+
+
+  it("does not run the audience-only page recheck without a persisted assignment", async () => {
+    const targeting = await import("./targeting");
+    const evaluateTargeting = vi.spyOn(targeting, "evaluateTargetingGatesDetailed");
+    const { evaluate } = await import("./index");
+
+    expect(evaluate([{
+      id: "exp_unpersisted_page_mismatch",
+      status: "running",
+      trafficAllocation: 1,
+      // Legacy bare-string URL rules stay accepted at runtime
+      // (normalizeRuntimeUrlRule); only the object form is in the declared type.
+      targeting: { url: ["https://plain.test/products/target"] as unknown as UrlRule[] },
+      variations: [{ id: "var_unpersisted_page_mismatch", weight: 1, mutations: [] }],
+    }], {
+      persistSignals: false,
+      url: "https://plain.test/products/other",
+      userId: "unpersisted-page-mismatch-visitor",
+    })).toEqual([]);
+    expect(evaluateTargeting).toHaveBeenCalledTimes(1);
+  });
+
+
+  it("merges hydration apply timing from runtime settings", async () => {
+    const { __test } = await import("./index");
+    const config = __test!.withRuntimeSettings(
+      { spa: { routerMode: "history", applyTiming: "immediate" } },
+      { spa: { applyTiming: "after_hydration", hydrationTimeoutMs: 4_500 } },
+    );
+
+    expect(config.spa).toMatchObject({
+      routerMode: "history",
+      applyTiming: "after_hydration",
+      hydrationTimeoutMs: 4_500,
+    });
+  });
+
+
+  it("restores live assignments after the debug script fails", async () => {
+    (globalThis as any).location.search = "?drip_debug=1";
+    (globalThis as any).location.href = "https://plain.test/?drip_debug=1";
+    vi.mocked((globalThis as any).document.head.appendChild).mockImplementation((element: any) => element);
+    const { getAssignments, init } = await import("./index");
+
+    const result = init({
+      antiFlickerMode: "off",
+      debug: { enabled: true, restrictMode: "query_param" },
+      experiments: [{
+        id: "exp_debug_fallback",
+        name: "Debug fallback",
+        status: "running",
+        trafficAllocation: 1,
+        variations: [{ id: "var_live", weight: 1, mutations: [] }],
+      }],
+      runtimeFeatures: { sdkVariant: "live" },
+      snippetUrl: "https://events.example.test/s/shop.js",
+      userId: "debug-fallback-visitor",
+    });
+
+    expect(result).toEqual([]);
+    expect(getAssignments()).toEqual([]);
+    const debugScript = vi.mocked((globalThis as any).document.head.appendChild).mock.calls[0]?.[0] as {
+      onerror?: () => void;
+    };
+
+    debugScript.onerror?.();
+
+    expect(getAssignments()).toEqual([
+      expect.objectContaining({ experimentId: "exp_debug_fallback", variationId: "var_live" }),
+    ]);
+  });
+
+
+  it("reads only the logged-in segment construction from aggregate mode", async () => {
+    const { __test } = await import("./index");
+    const enabled = __test!.withRuntimeSettings(
+      {},
+      { aggregateMode: { enabled: true, constructions: { loggedInSegment: true } } },
+    );
+    const omitted = __test!.withRuntimeSettings({}, { aggregateMode: { enabled: true } });
+
+    expect(enabled.aggregateMode?.constructions?.loggedInSegment).toBe(true);
+    expect(omitted.aggregateMode?.constructions?.loggedInSegment).toBeUndefined();
+  });
+
+
+  it("reads the cart attribute write owner and scope from fetched runtime settings", async () => {
+    const { __test } = await import("./index");
+    const external = __test!.withRuntimeSettings(
+      {},
+      { commerce: { cartAttributeWrite: "external", cartAttributeScope: "all" } },
+    );
+    const malformed = __test!.withRuntimeSettings(
+      {},
+      { commerce: { cartAttributeWrite: "unexpected", cartAttributeScope: "unexpected" } },
+    );
+    const legacyCached = __test!.withRuntimeSettings(
+      { cartAttributeWrite: "external", cartAttributeScope: "all" },
+      { commerce: {} },
+    );
+    const freshSdk = __test!.withRuntimeSettings(
+      { cartAttributeWrite: "external", cartAttributeScope: "all" },
+      { commerce: { cartAttributeWrite: "sdk", cartAttributeScope: "consented" } },
+    );
+
+    expect(external.cartAttributeWrite).toBe("external");
+    expect(external.cartAttributeScope).toBe("all");
+    expect(malformed.cartAttributeWrite).toBe("sdk");
+    expect(malformed.cartAttributeScope).toBe("consented");
+    expect(legacyCached.cartAttributeWrite).toBe("external");
+    expect(legacyCached.cartAttributeScope).toBe("all");
+    expect(freshSdk.cartAttributeWrite).toBe("sdk");
+    expect(freshSdk.cartAttributeScope).toBe("consented");
+  });
+});