@drip-apex/sdk 0.1.0

package/src/targeting.test.ts

@@ -0,0 +1,1054 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { buildTargetingAttributes, evaluateTargetingGates, matchesTargeting, targetingHasJsTriggers } from "./targeting";
+import { clearRuntimeSignal, setRuntimeSignal } from "./signals";
+import type { Experiment, Targeting } from "./types";
+
+const originalGlobals = {
+  document: globalThis.document,
+  location: globalThis.location,
+  navigator: globalThis.navigator,
+  window: globalThis.window,
+};
+
+function setGlobalValue(key: "document" | "location" | "navigator" | "window", value: unknown) {
+  Object.defineProperty(globalThis, key, {
+    configurable: true,
+    value,
+  });
+}
+
+function setRuntimeEnv(args: {
+  cookie?: string;
+  docLang?: string;
+  href?: string;
+  language?: string;
+  maxTouchPoints?: number;
+  platform?: string;
+  referrer?: string;
+  userAgent?: string;
+  userAgentData?: Record<string, unknown>;
+  width?: number;
+}) {
+  const href = args.href ?? "https://shop.test/products/shirt";
+  const url = new URL(href);
+  setGlobalValue("navigator", {
+    language: args.language ?? "",
+    maxTouchPoints: args.maxTouchPoints ?? 0,
+    platform: args.platform ?? "",
+    userAgent: args.userAgent ?? "",
+    userAgentData: args.userAgentData,
+  });
+  setGlobalValue("window", {
+    innerWidth: args.width ?? 1280,
+  });
+  setGlobalValue("document", {
+    cookie: args.cookie ?? "",
+    documentElement: { lang: args.docLang ?? "" },
+    referrer: args.referrer ?? "",
+  });
+  setGlobalValue("location", {
+    hash: url.hash,
+    hostname: url.hostname,
+    href: url.href,
+    origin: url.origin,
+    pathname: url.pathname,
+    search: url.search,
+  });
+}
+
+afterEach(() => {
+  setGlobalValue("document", originalGlobals.document);
+  setGlobalValue("location", originalGlobals.location);
+  setGlobalValue("navigator", originalGlobals.navigator);
+  setGlobalValue("window", originalGlobals.window);
+});
+
+describe("targeting", () => {
+  it("matches geo.country from the edge runtime signal and rejects another country", () => {
+    const targeting: Targeting = {
+      segmentRules: [{
+        include: true,
+        rules: { operator: "and", conditions: [{ signal: "geo.country", operator: "equals", value: "DE" }] },
+      }],
+    };
+
+    setRuntimeSignal("geo.country", "DE", "edge");
+    expect(matchesTargeting(targeting, { url: "https://shop.test/", attributes: buildTargetingAttributes({}, undefined, { persistSignals: false }) })).toBe(true);
+    setRuntimeSignal("geo.country", "US", "edge");
+    expect(matchesTargeting(targeting, { url: "https://shop.test/", attributes: buildTargetingAttributes({}, undefined, { persistSignals: false }) })).toBe(false);
+    clearRuntimeSignal("geo.country");
+  });
+  it("matches when no targeting is configured", () => {
+    expect(matchesTargeting(undefined, { url: "https://shop.test/p", attributes: {} })).toBe(true);
+  });
+
+  it("evaluates Page rules before Audience rules and skips Audience on page mismatch", () => {
+    const targeting: Targeting = {
+      pageRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          name: "PDPs",
+          includeRules: [{ type: "simple", pattern: "/products/*", include: true }],
+          trigger: { mode: "immediate" },
+        },
+      ],
+      segmentRules: [
+        {
+          id: "22222222-2222-4222-8222-222222222222",
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [{ signal: "cart.item_count", operator: "greater_than", value: 0 }],
+          },
+        },
+      ],
+    };
+
+    const result = evaluateTargetingGates(targeting, {
+      url: "https://shop.test/pages/about",
+      attributes: {
+        "cart.item_count": 3,
+      },
+    });
+
+    expect(result.matched).toBe(false);
+    expect(result.gates).toEqual([
+      expect.objectContaining({ id: "page", status: "failed" }),
+      expect.objectContaining({ id: "audience", status: "skipped", reason: "page_mismatch" }),
+    ]);
+  });
+
+  it("fails closed when a Page is disabled or its advanced condition throws", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const disabledTargeting: Targeting = {
+      pageRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          disabled: true,
+          includeRules: [{ type: "simple", pattern: "/products/*", include: true }],
+        },
+      ],
+    };
+    expect(
+      matchesTargeting(disabledTargeting, {
+        url: "https://shop.test/products/shirt",
+        attributes: {},
+      }),
+    ).toBe(false);
+
+    const throwingTargeting: Targeting = {
+      pageRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          includeRules: [{ type: "simple", pattern: "/products/*", include: true }],
+          advancedCondition: { code: "throw new Error('bad trigger')" },
+        },
+      ],
+    };
+    expect(
+      matchesTargeting(throwingTargeting, {
+        url: "https://shop.test/products/shirt",
+        attributes: {},
+      }),
+    ).toBe(false);
+    expect(warn).toHaveBeenCalledWith(
+      "[drip] Page trigger failed closed",
+      expect.objectContaining({ pageId: "11111111-1111-4111-8111-111111111111" }),
+    );
+    warn.mockRestore();
+  });
+
+  it("requires manual Page trigger signals for Callback and API modes", () => {
+    for (const mode of ["manual-callback", "manual-api"] as const) {
+      const targeting: Targeting = {
+        pageRules: [
+          {
+            id: "11111111-1111-4111-8111-111111111111",
+            includeRules: [{ type: "simple", pattern: "/products/*", include: true }],
+            trigger: {
+              mode,
+              apiName: "pdp_overlay",
+              signal: "page.trigger.pdp_overlay",
+              triggerJs: "activate();",
+            },
+          },
+        ],
+      };
+
+      expect(
+        matchesTargeting(targeting, {
+          url: "https://shop.test/products/shirt",
+          attributes: {},
+        }),
+      ).toBe(false);
+      expect(
+        matchesTargeting(targeting, {
+          url: "https://shop.test/products/shirt",
+          attributes: { "page.trigger.pdp_overlay": true },
+        }),
+      ).toBe(true);
+      expect(
+        matchesTargeting(targeting, {
+          url: "https://shop.test/products/shirt",
+          attributes: { "page.trigger.pdp_overlay": false },
+        }),
+      ).toBe(false);
+    }
+  });
+
+  it("supports simple wildcard URL targeting", () => {
+    const targeting: Targeting = {
+      url: [{ type: "simple", pattern: "*.shop.test/products/*" }],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://eu.shop.test/products/123",
+        attributes: {},
+      }),
+    ).toBe(true);
+  });
+
+  it("normalizes legacy url_contains rules at runtime", () => {
+    const targeting = {
+      url: "https://www.abtestinglibrary.com/products/book",
+      rules: [{ type: "url_contains", value: "/products/book" }],
+    } as unknown as Targeting;
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://www.abtestinglibrary.com/products/book?drip_qa=1&drip_force=exp:var",
+        attributes: {},
+      }),
+    ).toBe(true);
+  });
+
+  it("matches explicit contains rules against the full URL", () => {
+    const targeting: Targeting = {
+      pageRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          includeRules: [
+            {
+              type: "simple",
+              pattern: "utm_campaign=spring",
+              include: true,
+              matchType: "contains",
+            },
+          ],
+        },
+      ],
+    };
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/products/shirt?utm_campaign=spring",
+        attributes: {},
+      }),
+    ).toBe(true);
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/products/utm_campaign=spring",
+        attributes: {},
+      }),
+    ).toBe(true);
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/products/shirt?utm_campaign=winter",
+        attributes: {},
+      }),
+    ).toBe(false);
+  });
+
+  it("matches legacy escaped contains patterns against the full URL", () => {
+    const targeting: Targeting = {
+      pageRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          includeRules: [
+            {
+              type: "regex",
+              pattern: "\\?utm_campaign=spring",
+              include: true,
+              matchType: "contains",
+            },
+          ],
+        },
+      ],
+    };
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/products/shirt?utm_campaign=spring",
+        attributes: {},
+      }),
+    ).toBe(true);
+  });
+
+  it("supports exclude URL rules", () => {
+    const targeting: Targeting = {
+      url: [
+        { type: "simple", pattern: "*.shop.test/*" },
+        { type: "simple", pattern: "*.shop.test/admin/*", include: false },
+      ],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://eu.shop.test/admin/settings",
+        attributes: {},
+      }),
+    ).toBe(false);
+  });
+
+  it("supports attribute rules", () => {
+    const targeting: Targeting = {
+      attributes: [
+        { attribute: "plan", operator: "equals", value: "pro" },
+        { attribute: "tags", operator: "contains", value: "beta" },
+      ],
+    };
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { plan: "pro", tags: "beta-user" },
+      }),
+    ).toBe(true);
+  });
+
+  // --- regex URL targeting --------------------------------------------------
+
+  it("matches regex URL targeting", () => {
+    const targeting: Targeting = {
+      url: [{ type: "regex", pattern: "/products/\\d+" }],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/products/123",
+        attributes: {},
+      }),
+    ).toBe(true);
+  });
+
+  it("rejects non-matching regex URL", () => {
+    const targeting: Targeting = {
+      url: [{ type: "regex", pattern: "/products/\\d+" }],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/about",
+        attributes: {},
+      }),
+    ).toBe(false);
+  });
+
+  it("handles malformed regex gracefully", () => {
+    const targeting: Targeting = {
+      url: [{ type: "regex", pattern: "[invalid(" }],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: {},
+      }),
+    ).toBe(false);
+  });
+
+  // --- multiple include rules (OR logic) ------------------------------------
+
+  it("matches any of multiple include rules", () => {
+    const targeting: Targeting = {
+      url: [
+        { type: "simple", pattern: "*.shop.test/products/*" },
+        { type: "simple", pattern: "*.shop.test/collections/*" },
+      ],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://eu.shop.test/collections/summer",
+        attributes: {},
+      }),
+    ).toBe(true);
+  });
+
+  // --- attribute operators --------------------------------------------------
+
+  it("matches exists operator when attribute present", () => {
+    const targeting: Targeting = {
+      attributes: [{ attribute: "plan", operator: "exists" }],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { plan: "pro" },
+      }),
+    ).toBe(true);
+  });
+
+  it("rejects exists operator when attribute absent", () => {
+    const targeting: Targeting = {
+      attributes: [{ attribute: "plan", operator: "exists" }],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: {},
+      }),
+    ).toBe(false);
+  });
+
+  it("matches in operator with array value", () => {
+    const targeting: Targeting = {
+      attributes: [
+        { attribute: "plan", operator: "in", value: ["pro", "enterprise"] },
+      ],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { plan: "pro" },
+      }),
+    ).toBe(true);
+  });
+
+  it("rejects in operator when value not in array", () => {
+    const targeting: Targeting = {
+      attributes: [
+        { attribute: "plan", operator: "in", value: ["pro", "enterprise"] },
+      ],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { plan: "free" },
+      }),
+    ).toBe(false);
+  });
+
+  it("rejects contains when value is not string", () => {
+    const targeting: Targeting = {
+      attributes: [{ attribute: "count", operator: "contains", value: "3" }],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { count: 3 },
+      }),
+    ).toBe(false);
+  });
+
+  it("returns false for unknown operator", () => {
+    const targeting: Targeting = {
+      attributes: [
+        { attribute: "plan", operator: "startsWith" as any, value: "pro" },
+      ],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { plan: "pro-plus" },
+      }),
+    ).toBe(false);
+  });
+
+  it("matches runtime segment rules from visitor context", () => {
+    const targeting: Targeting = {
+      segmentRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          name: "VIP customers",
+          type: "customer",
+          include: true,
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [
+              {
+                signal: "shopify.customer_tag",
+                operator: "contains",
+                value: "VIP",
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { "shopify.customer_tag": ["VIP", "Wholesale"] },
+      }),
+    ).toBe(true);
+  });
+
+  it("matches grouped segment rules with AND blocks and OR rows", () => {
+    const targeting: Targeting = {
+      segmentRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          name: "Mobile paid traffic",
+          type: "traffic",
+          include: true,
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [
+              { signal: "device.type", operator: "equals", value: "mobile" },
+              { signal: "device.type", operator: "equals", value: "tablet" },
+              { signal: "utm.source", operator: "contains", value: "paid" },
+            ],
+            groups: [
+              [
+                { signal: "device.type", operator: "equals", value: "mobile" },
+                { signal: "device.type", operator: "equals", value: "tablet" },
+              ],
+              [{ signal: "utm.source", operator: "contains", value: "paid" }],
+            ],
+          },
+        },
+      ],
+    };
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { "device.type": "tablet", "utm.source": "paid-social" },
+      }),
+    ).toBe(true);
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { "device.type": "desktop", "utm.source": "paid-social" },
+      }),
+    ).toBe(false);
+  });
+
+  it("builds UA-first device attributes with browser, version, OS, and language signals", () => {
+    setRuntimeEnv({
+      href: "https://shop.test/products/shirt?utm_source=meta",
+      language: "de-DE",
+      platform: "iPhone",
+      referrer: "https://google.com/search?q=shirt",
+      userAgent:
+        "Mozilla/5.0 (iPhone; CPU iPhone OS 17_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Mobile/15E148 Safari/604.1",
+      width: 1440,
+    });
+    const mobileSafari = buildTargetingAttributes({}, undefined, { persistSignals: false });
+    expect(mobileSafari).toMatchObject({
+      "device.type": "mobile",
+      "device.browser": "safari",
+      "device.browser.version": "17.2",
+      "device.os": "ios",
+      "device.os.version": "17.2",
+      "navigator.language": "de-DE",
+      "utm.source": "meta",
+      referrer: "google.com",
+    });
+
+    setRuntimeEnv({
+      platform: "MacIntel",
+      maxTouchPoints: 5,
+      userAgent:
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_0) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15",
+      width: 1440,
+    });
+    expect(buildTargetingAttributes({}, undefined, { persistSignals: false })["device.type"]).toBe("tablet");
+
+    setRuntimeEnv({
+      platform: "Win32",
+      userAgent:
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+      width: 390,
+    });
+    const desktopChrome = buildTargetingAttributes({}, undefined, { persistSignals: false });
+    expect(desktopChrome).toMatchObject({
+      "device.type": "desktop",
+      "device.browser": "chrome",
+      "device.browser.version": "120.0.0.0",
+      "device.os": "windows",
+      "device.os.version": "10.0",
+    });
+
+    setRuntimeEnv({
+      platform: "Win32",
+      userAgent:
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+      userAgentData: {
+        fullVersionList: [
+          { brand: "Not A(Brand", version: "99.0.0.0" },
+          { brand: "Google Chrome", version: "120.0.6099.130" },
+        ],
+      },
+      width: 390,
+    });
+    expect(buildTargetingAttributes({}, undefined, { persistSignals: false })["device.browser.version"]).toBe(
+      "120.0.6099.130",
+    );
+  });
+
+  it("classifies Android client-hints with mobile=false as tablet, not desktop", () => {
+    setRuntimeEnv({
+      platform: "",
+      userAgent: "",
+      userAgentData: { platform: "Android", mobile: false },
+      width: 1200,
+    });
+    expect(buildTargetingAttributes({}, undefined, { persistSignals: false })["device.type"]).toBe("tablet");
+  });
+
+  it("leaves unparseable browser version empty so is_set and is_empty behave correctly", () => {
+    setRuntimeEnv({
+      userAgent: "Mozilla/5.0 MysteryBrowser Safari/605.1.15",
+      width: 1280,
+    });
+    const attrs = buildTargetingAttributes({}, undefined, { persistSignals: false });
+    expect(attrs["device.browser.version"]).toBe("");
+    expect(
+      matchesTargeting({
+        segmentRules: [
+          {
+            id: "11111111-1111-4111-8111-111111111111",
+            rules: {
+              version: 1,
+              operator: "and",
+              conditions: [{ signal: "device.browser.version", operator: "is_empty" }],
+            },
+          },
+        ],
+      }, { url: "https://shop.test/", attributes: attrs }),
+    ).toBe(true);
+    expect(
+      matchesTargeting({
+        segmentRules: [
+          {
+            id: "11111111-1111-4111-8111-111111111112",
+            rules: {
+              version: 1,
+              operator: "and",
+              conditions: [{ signal: "device.browser.version", operator: "is_set" }],
+            },
+          },
+        ],
+      }, { url: "https://shop.test/", attributes: attrs }),
+    ).toBe(false);
+  });
+
+  it("matches named cookie values after decoding", () => {
+    setRuntimeEnv({
+      cookie: "loyalty_tier=gold%20member; empty_cookie=; encoded=%E2%9C%93",
+    });
+    const targeting: Targeting = {
+      segmentRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [
+              { signal: "cookie.value", operator: "is_set", value: "loyalty_tier" },
+              { signal: "cookie.value", operator: "equals", value: "loyalty_tier=gold member" },
+              { signal: "cookie.value", operator: "contains", value: "encoded=✓" },
+              { signal: "cookie.value", operator: "is_empty", value: "missing_cookie" },
+              { signal: "cookie.value", operator: "not_contains", value: "loyalty_tier=silver" },
+            ],
+          },
+        },
+      ],
+    };
+
+    expect(matchesTargeting(targeting, { url: "https://shop.test/", attributes: {} })).toBe(true);
+  });
+
+  it("matches named URL parameters with URLSearchParams", () => {
+    const targeting: Targeting = {
+      segmentRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [
+              { signal: "url.query", operator: "is_set", value: "utm_source" },
+              { signal: "url.query", operator: "equals", value: "utm_source=meta" },
+              { signal: "url.query", operator: "contains", value: "campaign=spring" },
+              { signal: "url.query", operator: "is_empty", value: "missing_param" },
+            ],
+          },
+        },
+      ],
+    };
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/?utm_source=meta&campaign=spring-drop",
+        attributes: {},
+      }),
+    ).toBe(true);
+  });
+
+  it("keeps legacy raw-query substring matching for value-only url.query rules", () => {
+    const rule = (operator: string, value: string) => ({
+      segmentRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111112",
+          rules: {
+            version: 1,
+            operator: "and" as const,
+            conditions: [{ signal: "url.query", operator, value }],
+          },
+        },
+      ],
+    });
+
+    // No parameter named "spring" exists; the raw query string still matches.
+    expect(
+      matchesTargeting(rule("contains", "spring"), {
+        url: "https://shop.test/?season=spring&x=1",
+        attributes: {},
+      }),
+    ).toBe(true);
+    expect(
+      matchesTargeting(rule("contains", "winter"), {
+        url: "https://shop.test/?season=spring",
+        attributes: {},
+      }),
+    ).toBe(false);
+    // Presence operators keep named-parameter semantics.
+    expect(
+      matchesTargeting(rule("is_set", "spring"), {
+        url: "https://shop.test/?season=spring",
+        attributes: {},
+      }),
+    ).toBe(false);
+  });
+
+  it("matches navigator language contains rules", () => {
+    setRuntimeEnv({ language: "de-DE" });
+    const attrs = buildTargetingAttributes({}, undefined, { persistSignals: false });
+    expect(
+      matchesTargeting({
+        segmentRules: [
+          {
+            id: "11111111-1111-4111-8111-111111111111",
+            rules: {
+              version: 1,
+              operator: "and",
+              conditions: [{ signal: "navigator.language", operator: "contains", value: "de" }],
+            },
+          },
+        ],
+      }, { url: "https://shop.test/", attributes: attrs }),
+    ).toBe(true);
+  });
+
+  it("keeps referrer, returning visitor, UTM, and grouped AND/OR segment matching working", () => {
+    const targeting: Targeting = {
+      segmentRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [
+              { signal: "referrer", operator: "contains", value: "google" },
+              { signal: "visitor.returning", operator: "equals", value: true },
+              { signal: "utm.source", operator: "equals", value: "meta" },
+              { signal: "device.type", operator: "equals", value: "mobile" },
+              { signal: "device.type", operator: "equals", value: "tablet" },
+            ],
+            groups: [
+              [{ signal: "referrer", operator: "contains", value: "google" }],
+              [{ signal: "visitor.returning", operator: "equals", value: true }],
+              [{ signal: "utm.source", operator: "equals", value: "meta" }],
+              [
+                { signal: "device.type", operator: "equals", value: "mobile" },
+                { signal: "device.type", operator: "equals", value: "tablet" },
+              ],
+            ],
+          },
+        },
+      ],
+    };
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: {
+          "device.type": "tablet",
+          "utm.source": "meta",
+          referrer: "google.com",
+          "visitor.returning": true,
+        },
+      }),
+    ).toBe(true);
+  });
+
+  it("supports excluded runtime segment rules", () => {
+    const targeting: Targeting = {
+      segmentRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          include: false,
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [
+              {
+                signal: "utm.source",
+                operator: "equals",
+                value: "paid-social",
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { "utm.source": "paid-social" },
+      }),
+    ).toBe(false);
+  });
+
+  it("matches transient cart drawer surface segment rules", () => {
+    const targeting: Targeting = {
+      segmentRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          name: "Cart drawer open",
+          type: "behavior",
+          include: true,
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [
+              {
+                signal: "surface.cart_drawer.open",
+                operator: "equals",
+                value: true,
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/products/shirt",
+        attributes: { "surface.cart_drawer.open": true },
+      }),
+    ).toBe(true);
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/products/shirt",
+        attributes: { "surface.cart_drawer.open": false },
+      }),
+    ).toBe(false);
+  });
+
+  it("matches custom JS trigger segment rules", () => {
+    const targeting: Targeting = {
+      segmentRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          name: "Cart has multiple items",
+          type: "behavior",
+          include: true,
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [
+              {
+                signal: "js.trigger.cart_has_multiple_items",
+                operator: "equals",
+                value: true,
+                js: {
+                  code: "Number(attributes['cart.item_count'] || 0) >= 2",
+                },
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/products/shirt",
+        attributes: { "cart.item_count": 2 },
+      }),
+    ).toBe(true);
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/products/shirt",
+        attributes: { "cart.item_count": 1 },
+      }),
+    ).toBe(false);
+  });
+
+  it("supports expanded runtime segment operators", () => {
+    const targeting: Targeting = {
+      segmentRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [
+              { signal: "utm.source", operator: "not_equals", value: "email" },
+              { signal: "product.title", operator: "starts_with", value: "Pro" },
+              { signal: "product.sku", operator: "ends_with", value: "-XL" },
+              { signal: "cart.item_count", operator: "greater_than", value: 1 },
+              { signal: "customer.tags", operator: "not_in", value: ["employee"] },
+              { signal: "campaign.code", operator: "is_set" },
+              { signal: "discount.code", operator: "is_empty" },
+            ],
+          },
+        },
+      ],
+    };
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/products/pro-tee",
+        attributes: {
+          "utm.source": "paid",
+          "product.title": "Pro Tee",
+          "product.sku": "TEE-XL",
+          "cart.item_count": 2,
+          "customer.tags": ["vip", "wholesale"],
+          "campaign.code": "summer",
+          "discount.code": "",
+        },
+      }),
+    ).toBe(true);
+  });
+
+  it("detects targeting configs that need JS trigger re-evaluation", () => {
+    const experiments: Experiment[] = [
+      {
+        id: "exp_1",
+        status: "running",
+        variations: [],
+        targeting: {
+          segmentRules: [
+            {
+              id: "11111111-1111-4111-8111-111111111111",
+              rules: {
+                version: 1,
+                operator: "and",
+                conditions: [
+                  {
+                    signal: "js.trigger.size_guide_open",
+                    operator: "equals",
+                    value: true,
+                    js: { code: "Boolean(document.querySelector('[data-size-guide][open]'))" },
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      },
+    ];
+
+    expect(targetingHasJsTriggers(experiments)).toBe(true);
+  });
+
+  it("evaluates activate-mode JS triggers from the runtime signal", () => {
+    const targeting: Targeting = {
+      segmentRules: [
+        {
+          id: "11111111-1111-4111-8111-111111111111",
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [
+              {
+                signal: "js.trigger.cart_drawer_open",
+                operator: "equals",
+                value: true,
+                js: {
+                  mode: "activate",
+                  code: "waitForInf(() => document.querySelector('.cart.open'), () => activate());",
+                  description: "Cart drawer is open",
+                  resetCode: "document.documentElement.removeAttribute('data-cart-test');",
+                },
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: {},
+      }),
+    ).toBe(false);
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { "js.trigger.cart_drawer_open": true },
+      }),
+    ).toBe(true);
+  });
+
+  // --- multiple attributes AND logic ----------------------------------------
+
+  it("requires all attribute rules to match", () => {
+    const targeting: Targeting = {
+      attributes: [
+        { attribute: "plan", operator: "equals", value: "pro" },
+        { attribute: "region", operator: "equals", value: "eu" },
+      ],
+    };
+    // Only one matches → should fail (AND logic)
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { plan: "pro", region: "us" },
+      }),
+    ).toBe(false);
+  });
+
+  // --- empty rules ----------------------------------------------------------
+
+  it("matches when url rules array is empty", () => {
+    const targeting: Targeting = { url: [] };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/anything",
+        attributes: {},
+      }),
+    ).toBe(true);
+  });
+
+  it("matches when attributes array is empty", () => {
+    const targeting: Targeting = { attributes: [] };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://shop.test/",
+        attributes: { plan: "free" },
+      }),
+    ).toBe(true);
+  });
+
+  // --- URL with query params ------------------------------------------------
+
+  it("matches URL with query params in pattern", () => {
+    const targeting: Targeting = {
+      url: [{ type: "simple", pattern: "*.shop.test/products/*?ref=google" }],
+    };
+    expect(
+      matchesTargeting(targeting, {
+        url: "https://eu.shop.test/products/123?ref=google",
+        attributes: {},
+      }),
+    ).toBe(true);
+  });
+});