@drip-apex/sdk 0.1.0

package/src/targeting.ts

@@ -0,0 +1,1024 @@
+import {
+  AttributeRule,
+  ActivationGateDiagnostic,
+  Experiment,
+  PageTargetingRule,
+  SegmentCondition,
+  SegmentTargetingRule,
+  Targeting,
+  TargetingDiagnostics,
+  UrlRule,
+} from "./types";
+import { createApexRuntimeTools } from "./runtime-tools";
+import { safeRegexTest } from "./safe-regex";
+import { getSignals, rememberProduct } from "./signals";
+import { evaluateTargetingGatesWithConditionDiagnostics } from "./targeting-diagnostics";
+
+declare const __DRIP_QA_BUILD__: boolean;
+
+function evalSimpleUrlPart(actual: string, pattern: string, isPath: boolean): boolean {
+  try {
+    let escaped = pattern
+      .replace(/[*.+?^${}()|[\]\\]/g, "\\$&")
+      .replace(/_____/g, ".*");
+    if (isPath) {
+      escaped = "\\/?" + escaped.replace(/(^\/|\/$)/g, "") + "\\/?";
+    }
+    const regex = new RegExp("^" + escaped + "$", "i");
+    return regex.test(actual);
+  } catch {
+    return false;
+  }
+}
+
+function evalSimpleUrlTarget(actual: URL, pattern: string): boolean {
+  try {
+    const expected = new URL(
+      pattern.replace(/^([^:/?]*)\./i, "https://$1.").replace(/\*/g, "_____"),
+      "https://_____",
+    );
+    const comps: Array<[string, string, boolean]> = [
+      [actual.host, expected.host, false],
+      [actual.pathname, expected.pathname, true],
+    ];
+    if (expected.hash) comps.push([actual.hash, expected.hash, false]);
+    expected.searchParams.forEach((v, k) => {
+      comps.push([actual.searchParams.get(k) || "", v, false]);
+    });
+    return !comps.some((data) => !evalSimpleUrlPart(data[0], data[1], data[2]));
+  } catch {
+    return false;
+  }
+}
+
+function unescapeRegexLiteral(value: string): string {
+  return value.replace(/\\([.*+?^${}()|[\]\\\/])/g, "$1");
+}
+
+export function evalUrlRule(url: string, rule: UrlRule): boolean {
+  try {
+    const parsed = new URL(url, "https://_");
+    const matchType = rule.matchType ?? rule.match_type;
+    if (matchType === "contains") {
+      const actual = parsed.href.toLowerCase();
+      const pattern = rule.pattern.toLowerCase();
+      return actual.includes(pattern) || actual.includes(unescapeRegexLiteral(pattern));
+    }
+    if (rule.type === "regex") {
+      const escaped = rule.pattern.replace(/([^\\])\//g, "$1\\/");
+      return safeRegexTest(escaped, parsed.href) || safeRegexTest(escaped, parsed.href.substring(parsed.origin.length));
+    }
+    return evalSimpleUrlTarget(parsed, rule.pattern);
+  } catch {
+    return false;
+  }
+}
+
+function normalizeRuntimeUrlRule(value: unknown): UrlRule | null {
+  if (typeof value === "string") {
+    const pattern = value.trim();
+    return pattern ? { type: "simple", pattern, include: true } : null;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+
+  const raw = value as Record<string, unknown>;
+  const rawPattern = raw.pattern ?? raw.value ?? raw.url ?? raw.path;
+  const pattern = typeof rawPattern === "string" ? rawPattern.trim() : "";
+  if (!pattern) return null;
+
+  const include = typeof raw.include === "boolean" ? raw.include : true;
+  const matchType =
+    raw.matchType === "exact" ||
+    raw.matchType === "contains" ||
+    raw.matchType === "wildcard" ||
+    raw.matchType === "regex"
+      ? raw.matchType
+      : raw.match_type === "exact" ||
+          raw.match_type === "contains" ||
+          raw.match_type === "wildcard" ||
+          raw.match_type === "regex"
+        ? raw.match_type
+        : raw.type === "url_contains"
+          ? "contains"
+          : undefined;
+
+  if (raw.type === "url_contains") {
+    return { type: "simple", pattern, include, matchType: "contains" };
+  }
+  return {
+    type: raw.type === "regex" || raw.type === "url_regex" ? "regex" : "simple",
+    pattern,
+    include,
+    ...(matchType ? { matchType } : {}),
+  };
+}
+
+export function normalizeRuntimeUrlRules(targeting: Targeting | undefined): UrlRule[] {
+  const raw = targeting as unknown as Record<string, unknown> | undefined;
+  if (!raw || typeof raw !== "object") return [];
+
+  const urlSource = Array.isArray(raw.url)
+    ? raw.url
+    : raw.url === undefined || raw.url === null
+      ? []
+      : [raw.url];
+  const legacyRules = Array.isArray(raw.rules) ? raw.rules : [];
+
+  return urlSource
+    .concat(legacyRules)
+    .map(normalizeRuntimeUrlRule)
+    .filter((rule): rule is UrlRule => Boolean(rule));
+}
+
+export function matchUrlRules(url: string, rules: UrlRule[]): boolean {
+  if (!rules.length) return true;
+  let hasInclude = false;
+  let included = false;
+  for (const rule of rules) {
+    const match = evalUrlRule(url, rule);
+    if (rule.include === false) {
+      if (match) return false;
+    } else {
+      hasInclude = true;
+      if (match) included = true;
+    }
+  }
+  return included || !hasInclude;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function jsErrorReason(error: unknown): string {
+  const message = errorMessage(error);
+  return message ? `js_error: ${message}` : "js_error";
+}
+
+type BooleanDiagnosticResult = {
+  matched: boolean;
+  reason?: string;
+  error?: unknown;
+};
+
+export function evaluatePageAdvancedConditionResult(
+  rule: PageTargetingRule,
+  ctx: { url: string; attributes: Record<string, unknown> },
+): BooleanDiagnosticResult {
+  const code = rule.advancedCondition?.code?.trim();
+  if (!code) return { matched: true };
+  try {
+    const url = new URL(
+      ctx.url,
+      typeof location !== "undefined" ? location.origin : "https://_",
+    );
+    const fn = new Function(
+      "context",
+      `"use strict";` +
+        `const attributes=context.attributes;` +
+        `const document=context.document;` +
+        `const location=context.location;` +
+        `const url=context.url;` +
+        `const window=context.window;` +
+        `return Boolean((function(){${/\breturn\b|;\s*$|\bthrow\b/.test(code) ? code : `return (${code});`}}).call(window));`,
+    );
+    const matched = Boolean(fn({
+      attributes: ctx.attributes,
+      document: typeof document !== "undefined" ? document : undefined,
+      location: typeof location !== "undefined" ? location : undefined,
+      url,
+      window: typeof window !== "undefined" ? window : undefined,
+    }));
+    return { matched, reason: matched ? undefined : "js_false" };
+  } catch (error) {
+    return { matched: false, reason: jsErrorReason(error), error };
+  }
+}
+
+function evaluatePageAdvancedCondition(
+  rule: PageTargetingRule,
+  ctx: { url: string; attributes: Record<string, unknown> },
+): boolean {
+  const result = evaluatePageAdvancedConditionResult(rule, ctx);
+  if (!result.matched && result.reason?.startsWith("js_error")) {
+    try {
+      console.warn("[drip] Page trigger failed closed", {
+        pageId: rule.id,
+        pageName: rule.name,
+        error: result.error,
+      });
+    } catch {}
+  }
+  return result.matched;
+}
+
+export function pageManualTriggerMatches(
+  rule: PageTargetingRule,
+  ctx: { attributes: Record<string, unknown> },
+): boolean {
+  const mode = rule.trigger?.mode;
+  if (mode !== "manual-callback" && mode !== "manual-api") return true;
+  const signal = rule.trigger?.signal;
+  if (!signal) return false;
+  return ctx.attributes[signal] === true;
+}
+
+function matchPageTargetingRule(
+  rule: PageTargetingRule,
+  ctx: { url: string; attributes: Record<string, unknown> },
+): boolean {
+  if (rule.disabled || rule.trigger?.disabled) return false;
+  const includeRules = rule.includeRules ?? [];
+  const excludeRules = (rule.excludeRules ?? []).map((item) => ({ ...item, include: false }));
+  const urlMatched = matchUrlRules(ctx.url, [...includeRules, ...excludeRules]);
+  return urlMatched && pageManualTriggerMatches(rule, ctx) && evaluatePageAdvancedCondition(rule, ctx);
+}
+
+function matchPageRules(
+  rules: PageTargetingRule[],
+  ctx: { url: string; attributes: Record<string, unknown> },
+): boolean {
+  if (!rules.length) return true;
+  let hasInclude = false;
+  let included = false;
+
+  for (const rule of rules) {
+    const matched = matchPageTargetingRule(rule, ctx);
+    if (rule.include === false) {
+      if (matched) return false;
+    } else {
+      hasInclude = true;
+      if (matched) included = true;
+    }
+  }
+
+  return included || !hasInclude;
+}
+
+export function matchAttributeRule(
+  attrs: Record<string, unknown>,
+  rule: AttributeRule,
+): boolean {
+  const value = attrs[rule.attribute];
+  switch (rule.operator) {
+    case "exists":
+      return value !== undefined && value !== null;
+    case "equals":
+      return value === rule.value;
+    case "contains":
+      return typeof value === "string" && typeof rule.value === "string"
+        ? value.includes(rule.value)
+        : false;
+    case "in":
+      return Array.isArray(rule.value) ? rule.value.includes(String(value)) : false;
+    default:
+      return false;
+  }
+}
+
+function wildcardToRegex(pattern: string): string {
+  return `^${pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`;
+}
+
+type RuntimeNavigator = Navigator & {
+  userAgentData?: {
+    mobile?: boolean;
+    platform?: string;
+    brands?: Array<{ brand: string; version: string }>;
+    fullVersionList?: Array<{ brand: string; version: string }>;
+    getHighEntropyValues?: (hints: string[]) => Promise<unknown>;
+  };
+};
+
+type BrowserInfo = {
+  name: string;
+  version: string;
+};
+
+type OsInfo = {
+  name: string;
+  version: string;
+};
+
+const EMPTY_BROWSER_INFO: BrowserInfo = { name: "", version: "" };
+const EMPTY_OS_INFO: OsInfo = { name: "", version: "" };
+let highEntropyBrowserInfo: BrowserInfo | null = null;
+let highEntropyBrowserInfoRequested = false;
+
+function runtimeNavigator(): RuntimeNavigator | undefined {
+  return typeof navigator === "undefined" ? undefined : navigator as RuntimeNavigator;
+}
+
+function lower(value: unknown): string {
+  return typeof value === "string" ? value.toLowerCase() : "";
+}
+
+function normalizeVersion(value: unknown): string {
+  if (typeof value !== "string") return "";
+  const match = value.match(/\d+(?:[._]\d+)*/);
+  return match ? match[0].replace(/_/g, ".") : "";
+}
+
+function firstVersionMatch(ua: string, patterns: RegExp[]): string {
+  for (const pattern of patterns) {
+    const match = ua.match(pattern);
+    const version = normalizeVersion(match?.[1]);
+    if (version) return version;
+  }
+  return "";
+}
+
+function getUserAgent(): string {
+  return runtimeNavigator()?.userAgent ?? "";
+}
+
+function getPlatform(): string {
+  const nav = runtimeNavigator();
+  return nav?.userAgentData?.platform || nav?.platform || "";
+}
+
+function getDeviceTypeFromUserAgent(ua: string, platform: string): string {
+  const normalizedUa = ua.toLowerCase();
+  const normalizedPlatform = platform.toLowerCase();
+  if (!normalizedUa && !normalizedPlatform) return "";
+
+  const isIpad =
+    /\bipad\b/.test(normalizedUa) ||
+    (normalizedPlatform === "macintel" &&
+      typeof navigator !== "undefined" &&
+      Number((navigator as Navigator).maxTouchPoints || 0) > 1);
+  if (isIpad || /\btablet\b|playbook|silk|kindle|nexus 7|nexus 9|sm-t|gt-p/i.test(ua)) {
+    return "tablet";
+  }
+  if (/\bmobi\b|iphone|ipod|android.*mobile|windows phone|blackberry|bb10/i.test(ua)) {
+    return "mobile";
+  }
+  if (/android/i.test(ua)) return "tablet";
+  // Client-hints platform "Android" with mobile=false and no UA string is a
+  // tablet, not a desktop.
+  if (/android/i.test(normalizedPlatform)) return "tablet";
+  if (/windows|macintosh|mac os x|linux|x11|cros/i.test(ua) || normalizedPlatform) {
+    return "desktop";
+  }
+  return "";
+}
+
+function getDeviceType(): string {
+  const nav = runtimeNavigator();
+  if (nav?.userAgentData?.mobile === true) return "mobile";
+
+  const fromUa = getDeviceTypeFromUserAgent(getUserAgent(), getPlatform());
+  if (fromUa) return fromUa;
+
+  if (typeof window === "undefined") return "";
+  const width = window.innerWidth || 0;
+  if (width > 0 && width < 768) return "mobile";
+  if (width >= 768 && width < 1024) return "tablet";
+  return "desktop";
+}
+
+function browserInfoFromBrands(brands: unknown): BrowserInfo {
+  if (!Array.isArray(brands)) return EMPTY_BROWSER_INFO;
+
+  for (const item of brands) {
+    if (!item || typeof item !== "object") continue;
+    const record = item as Record<string, unknown>;
+    const brand = lower(record.brand);
+    const version = normalizeVersion(record.version);
+    if (!brand || brand.includes("not") || brand.includes("brand")) continue;
+    if (brand.includes("edge")) return { name: "edge", version };
+    if (brand.includes("chrome") || brand.includes("chromium")) return { name: "chrome", version };
+    if (brand.includes("firefox")) return { name: "firefox", version };
+    if (brand.includes("safari")) return { name: "safari", version };
+  }
+
+  return EMPTY_BROWSER_INFO;
+}
+
+function requestHighEntropyBrowserInfo(): void {
+  const userAgentData = runtimeNavigator()?.userAgentData;
+  if (!userAgentData?.getHighEntropyValues || highEntropyBrowserInfoRequested) return;
+  highEntropyBrowserInfoRequested = true;
+  try {
+    userAgentData
+      .getHighEntropyValues(["brands", "fullVersionList"])
+      .then((values) => {
+        if (!values || typeof values !== "object") return;
+        const record = values as Record<string, unknown>;
+        const info = browserInfoFromBrands(record.fullVersionList ?? record.brands);
+        if (info.name) highEntropyBrowserInfo = info;
+      })
+      .catch(() => {});
+  } catch {}
+}
+
+function getBrowserInfoFromClientHints(): BrowserInfo {
+  const userAgentData = runtimeNavigator()?.userAgentData;
+  const fullVersionInfo = browserInfoFromBrands(userAgentData?.fullVersionList);
+  if (fullVersionInfo.name) return fullVersionInfo;
+  if (highEntropyBrowserInfo?.name) return highEntropyBrowserInfo;
+  requestHighEntropyBrowserInfo();
+  return browserInfoFromBrands(userAgentData?.brands);
+}
+
+function browserWithVersionPriority(name: string, uaVersion: string, hinted: BrowserInfo): BrowserInfo {
+  return {
+    name,
+    version: hinted.name === name && hinted.version ? hinted.version : uaVersion || hinted.version,
+  };
+}
+
+function getBrowserInfo(): BrowserInfo {
+  const hinted = getBrowserInfoFromClientHints();
+  const ua = getUserAgent();
+  if (!ua) return hinted;
+
+  if (/Edg\//.test(ua)) {
+    return browserWithVersionPriority("edge", firstVersionMatch(ua, [/Edg\/([\d.]+)/]), hinted);
+  }
+  if (/Firefox\//.test(ua)) {
+    return browserWithVersionPriority("firefox", firstVersionMatch(ua, [/Firefox\/([\d.]+)/]), hinted);
+  }
+  if (/CriOS\//.test(ua)) {
+    return browserWithVersionPriority("chrome", firstVersionMatch(ua, [/CriOS\/([\d.]+)/]), hinted);
+  }
+  if (/Chrome\//.test(ua) && !/Chromium|OPR\/|Edg\//.test(ua)) {
+    return browserWithVersionPriority("chrome", firstVersionMatch(ua, [/Chrome\/([\d.]+)/]), hinted);
+  }
+  if (/Version\/[\d.]+.*Safari\//.test(ua) && !/Chrome|CriOS|FxiOS|Edg\//.test(ua)) {
+    return browserWithVersionPriority("safari", firstVersionMatch(ua, [/Version\/([\d.]+)/]), hinted);
+  }
+
+  return hinted;
+}
+
+function getOsInfo(): OsInfo {
+  const ua = getUserAgent();
+  const platform = getPlatform();
+  const normalized = `${ua} ${platform}`.toLowerCase();
+  if (!normalized.trim()) return EMPTY_OS_INFO;
+
+  if (/iphone|ipad|ipod/.test(normalized) || (platform === "MacIntel" && typeof navigator !== "undefined" && Number(navigator.maxTouchPoints || 0) > 1)) {
+    return { name: "ios", version: firstVersionMatch(ua, [/OS ([\d_]+)/]) };
+  }
+  if (/android/.test(normalized)) {
+    return { name: "android", version: firstVersionMatch(ua, [/Android ([\d.]+)/]) };
+  }
+  if (/windows/.test(normalized)) {
+    return { name: "windows", version: firstVersionMatch(ua, [/Windows NT ([\d.]+)/]) };
+  }
+  if (/mac os x|macintosh|macintel/.test(normalized)) {
+    return { name: "macos", version: firstVersionMatch(ua, [/Mac OS X ([\d_]+)/]) };
+  }
+  if (/linux|x11/.test(normalized)) {
+    return { name: "linux", version: "" };
+  }
+
+  return EMPTY_OS_INFO;
+}
+
+function getLanguage(): string {
+  const navLanguage = runtimeNavigator()?.language;
+  if (typeof navLanguage === "string" && navLanguage.trim()) return navLanguage;
+  if (typeof document !== "undefined") return document.documentElement.lang || "";
+  return "";
+}
+
+function decodeCookieComponent(value: string): string {
+  try {
+    return decodeURIComponent(value.replace(/\+/g, " "));
+  } catch {
+    return value;
+  }
+}
+
+function getCookieValue(name: string): string | undefined {
+  if (typeof document === "undefined") return undefined;
+  const needle = name.trim();
+  if (!needle) return undefined;
+  const pairs = document.cookie ? document.cookie.split(";") : [];
+  for (const pair of pairs) {
+    const index = pair.indexOf("=");
+    const rawName = (index >= 0 ? pair.slice(0, index) : pair).trim();
+    if (decodeCookieComponent(rawName) !== needle) continue;
+    return decodeCookieComponent(index >= 0 ? pair.slice(index + 1) : "");
+  }
+  return undefined;
+}
+
+function parseNamedValue(value: unknown): { name: string; expected: string } {
+  const raw = String(value ?? "").trim();
+  const index = raw.indexOf("=");
+  if (index < 0) return { name: raw, expected: "" };
+  return {
+    name: raw.slice(0, index).trim(),
+    expected: raw.slice(index + 1),
+  };
+}
+
+function getPersistedUtmValue(key: string): string {
+  try {
+    const params = new URLSearchParams(location.search);
+    const direct = params.get(key);
+    if (direct) return direct;
+  } catch {}
+  try {
+    const stored = sessionStorage.getItem("drip_utm");
+    if (!stored) return "";
+    const parsed = JSON.parse(stored) as Record<string, unknown>;
+    return typeof parsed[key] === "string" ? parsed[key] : "";
+  } catch {
+    return "";
+  }
+}
+
+function normalizeReferrer(): string {
+  if (typeof document === "undefined") return "";
+  const referrer = document.referrer;
+  if (!referrer) return "(direct)";
+  try {
+    const host = new URL(referrer).hostname;
+    return host === location.hostname ? "(internal)" : host;
+  } catch {
+    return "(direct)";
+  }
+}
+
+function normalizeTrafficSource(utmSource: unknown, referrer: unknown): string {
+  const source = typeof utmSource === "string" ? utmSource.toLowerCase() : "";
+  const ref = typeof referrer === "string" ? referrer.toLowerCase() : "";
+  if (source.includes("facebook") || source.includes("instagram") || source.includes("meta") || source.includes("tiktok")) {
+    return "paid-social";
+  }
+  if (source.includes("google") || source.includes("bing") || ref.includes("google") || ref.includes("bing")) {
+    return "search";
+  }
+  if (source.includes("email") || source.includes("newsletter")) return "email";
+  if (source) return source;
+  if (ref && ref !== "(direct)" && ref !== "(internal)") return "referral";
+  return "direct";
+}
+
+function readShopifySignal(signal: string): unknown {
+  if (typeof window === "undefined") return undefined;
+  const root = (window as any).ShopifyAnalytics?.meta ?? (window as any).Shopify?.analytics?.meta;
+  if (!root || typeof root !== "object") return undefined;
+
+  if (signal === "shopify.page_type") {
+    return root.page?.pageType ?? root.page?.page_type ?? root.pageType;
+  }
+  if (signal === "shopify.product_type") {
+    return root.product?.type ?? root.product?.product_type;
+  }
+  if (signal === "shopify.product_tag") {
+    return root.product?.tags;
+  }
+  if (signal === "shopify.customer_tag") {
+    return root.customer?.tags;
+  }
+  return undefined;
+}
+
+export function buildTargetingAttributes(
+  baseAttributes: Record<string, unknown> = {},
+  currentUrl?: string,
+  options: { persistSignals?: boolean } = {},
+): Record<string, unknown> {
+  const attrs: Record<string, unknown> = { ...baseAttributes };
+  const href = currentUrl || (typeof location !== "undefined" ? location.href : "");
+  const persistSignals = options.persistSignals !== false;
+
+  try {
+    const parsed = new URL(href, typeof location !== "undefined" ? location.origin : "https://_");
+    attrs["url.full"] ??= parsed.href;
+    attrs["url.path"] ??= parsed.pathname;
+    attrs["url.query"] ??= parsed.search;
+  } catch {}
+
+  attrs["utm.source"] ??= baseAttributes.utm_source ?? getPersistedUtmValue("utm_source");
+  attrs["utm.medium"] ??= baseAttributes.utm_medium ?? getPersistedUtmValue("utm_medium");
+  attrs["utm.campaign"] ??= baseAttributes.utm_campaign ?? getPersistedUtmValue("utm_campaign");
+  attrs.referrer ??= normalizeReferrer();
+  attrs["device.type"] ??= baseAttributes.device ?? getDeviceType();
+  const browser = getBrowserInfo();
+  attrs["device.browser"] ??= browser.name;
+  attrs["device.browser.version"] ??= browser.version;
+  const os = getOsInfo();
+  attrs["device.os"] ??= os.name;
+  attrs["device.os.version"] ??= os.version;
+  attrs["navigator.language"] ??= getLanguage();
+  attrs["traffic.source"] ??= normalizeTrafficSource(attrs["utm.source"], attrs.referrer);
+
+  for (const signal of [
+    "shopify.page_type",
+    "shopify.product_type",
+    "shopify.product_tag",
+    "shopify.customer_tag",
+  ]) {
+    attrs[signal] ??= readShopifySignal(signal);
+  }
+
+  if (persistSignals) {
+    const productMeta = readShopifyProductMeta();
+    if (productMeta) rememberProduct(productMeta);
+  }
+
+  for (const [signal, value] of Object.entries(getSignals({ markVisitorSeen: persistSignals }))) {
+    attrs[signal] ??= value;
+  }
+
+  return attrs;
+}
+
+function resolveUrlQueryValue(url: string, conditionValue: unknown): string | undefined {
+  const { name } = parseNamedValue(conditionValue);
+  if (!name) return undefined;
+  try {
+    const parsed = new URL(url, typeof location !== "undefined" ? location.origin : "https://_");
+    return parsed.searchParams.get(name) ?? undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function resolveNamedConditionActual(
+  condition: SegmentCondition,
+  ctx: { url: string; attributes: Record<string, unknown> },
+): unknown {
+  if (condition.signal === "cookie.value") {
+    const { name } = parseNamedValue(condition.value);
+    return getCookieValue(name);
+  }
+  if (condition.signal === "url.query") {
+    if (isLegacyRawQueryCondition(condition)) {
+      return rawQueryString(ctx.url);
+    }
+    return resolveUrlQueryValue(ctx.url, condition.value);
+  }
+  return condition.js
+    ? evaluateJsTrigger(condition, ctx)
+    : resolveSignalValue(ctx.attributes, ctx.url, condition.signal);
+}
+
+export function resolveNamedConditionExpected(condition: SegmentCondition): SegmentCondition["value"] {
+  if (condition.signal !== "cookie.value" && condition.signal !== "url.query") return condition.value;
+  if (condition.operator === "is_set" || condition.operator === "is_empty") return condition.value;
+  if (condition.signal === "url.query" && isLegacyRawQueryCondition(condition)) {
+    return condition.value;
+  }
+  return parseNamedValue(condition.value).expected;
+}
+
+// Pre-fix url.query rules matched against the raw query string. Substring
+// operators without a name=value form keep that raw semantics so existing
+// audiences like `url.query contains "spring"` continue to match; presence
+// and equality operators use the named-parameter semantics from APX-59.
+const LEGACY_RAW_QUERY_OPERATORS = new Set(["contains", "not_contains", "starts_with", "ends_with"]);
+
+function isLegacyRawQueryCondition(condition: SegmentCondition): boolean {
+  if (!LEGACY_RAW_QUERY_OPERATORS.has(String(condition.operator))) return false;
+  return !String(condition.value ?? "").includes("=");
+}
+
+function rawQueryString(url: string): string {
+  try {
+    const parsed = new URL(url, typeof location !== "undefined" ? location.origin : "https://_");
+    return parsed.search || "";
+  } catch {
+    return "";
+  }
+}
+
+function readShopifyProductMeta(): Parameters<typeof rememberProduct>[0] | null {
+  if (typeof window === "undefined") return null;
+  const root = (window as any).ShopifyAnalytics?.meta ?? (window as any).Shopify?.analytics?.meta;
+  const product = root?.product;
+  if (!product || typeof product !== "object") return null;
+  const id = product.id ?? product.gid ?? product.product_id;
+  if (!id && !product.handle) return null;
+  return {
+    id,
+    handle: product.handle,
+    title: product.title,
+    type: product.type ?? product.product_type,
+    vendor: product.vendor,
+    tags: Array.isArray(product.tags) ? product.tags : undefined,
+    price: product.price,
+  };
+}
+
+function resolveSignalValue(
+  attrs: Record<string, unknown>,
+  url: string,
+  signal: string,
+): unknown {
+  if (attrs[signal] !== undefined) return attrs[signal];
+
+  try {
+    const parsed = new URL(url, "https://_");
+    if (signal === "url.full") return parsed.href;
+    if (signal === "url.path") return parsed.pathname;
+    if (signal === "url.query") return parsed.search;
+  } catch {}
+
+  return undefined;
+}
+
+function buildJsTriggerSource(code: string): string {
+  const trimmed = code.trim();
+  if (!trimmed) return "return false;";
+  if (/\breturn\b/.test(trimmed)) return trimmed;
+  return `return (${trimmed});`;
+}
+
+function isActivateJsTrigger(condition: SegmentCondition): boolean {
+  const code = condition.js?.code ?? "";
+  return condition.js?.mode === "activate" ||
+    /\bactivate\s*\(/.test(code) ||
+    /\bcallbackFn\b/.test(code);
+}
+
+function evaluateJsTrigger(
+  condition: SegmentCondition,
+  ctx: { url: string; attributes: Record<string, unknown> },
+): unknown {
+  return evaluateJsTriggerResult(condition, ctx).actual;
+}
+
+export function evaluateJsTriggerResult(
+  condition: SegmentCondition,
+  ctx: { url: string; attributes: Record<string, unknown> },
+): { actual: unknown; reason?: string } {
+  const code = condition.js?.code?.trim();
+  if (!code || code.length > 4000) return { actual: undefined };
+  if (isActivateJsTrigger(condition)) {
+    return { actual: resolveSignalValue(ctx.attributes, ctx.url, condition.signal) };
+  }
+
+  try {
+    const url = new URL(
+      ctx.url,
+      typeof location !== "undefined" ? location.origin : "https://_",
+    );
+    const apexTools = createApexRuntimeTools();
+    const context = {
+      apexTools,
+      attributes: ctx.attributes,
+      document: typeof document !== "undefined" ? document : undefined,
+      location: typeof location !== "undefined" ? location : undefined,
+      signal: condition.signal,
+      url,
+      value: condition.value,
+      window: typeof window !== "undefined" ? window : undefined,
+    };
+    const fn = new Function(
+      "context",
+      `"use strict";` +
+        `const attributes=context.attributes;` +
+        `const apexTools=context.apexTools;` +
+        `const document=context.document;` +
+        `const location=context.location;` +
+        `const signal=context.signal;` +
+        `const url=context.url;` +
+        `const value=context.value;` +
+        `const window=context.window;` +
+        `return Boolean((function(){${buildJsTriggerSource(code)}}).call(window));`,
+    );
+    const actual = Boolean(fn(context));
+    return { actual, reason: actual ? undefined : "js_false" };
+  } catch (error) {
+    return { actual: false, reason: jsErrorReason(error) };
+  }
+}
+
+function stringValues(value: unknown): string[] {
+  if (Array.isArray(value)) {
+    return value
+      .map((item) => String(item).trim())
+      .filter(Boolean);
+  }
+  if (value === undefined || value === null) return [];
+  return [String(value)];
+}
+
+function hasMeaningfulValue(value: unknown): boolean {
+  if (value === undefined || value === null) return false;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "string") return value.trim().length > 0;
+  return true;
+}
+
+function compareNumber(actual: unknown, expected: unknown, predicate: (a: number, b: number) => boolean): boolean {
+  const actualNumber = Number(Array.isArray(actual) ? actual[0] : actual);
+  const expectedNumber = Number(Array.isArray(expected) ? expected[0] : expected);
+  return Number.isFinite(actualNumber) &&
+    Number.isFinite(expectedNumber) &&
+    predicate(actualNumber, expectedNumber);
+}
+
+function matchSegmentCondition(
+  condition: SegmentCondition,
+  ctx: { url: string; attributes: Record<string, unknown> },
+): boolean {
+  const actual = resolveNamedConditionActual(condition, ctx);
+  const expected = resolveNamedConditionExpected(condition);
+  return matchSegmentConditionValues(condition, actual, expected);
+}
+
+export function matchSegmentConditionValues(
+  condition: SegmentCondition,
+  actual: unknown,
+  expected: SegmentCondition["value"],
+): boolean {
+  const actualValues = stringValues(actual);
+  const expectedValues = stringValues(expected);
+  const firstExpected = expectedValues[0] ?? "";
+
+  switch (condition.operator) {
+    case "equals":
+      return actualValues.some((value) => value === String(expected ?? ""));
+    case "not_equals":
+      return !actualValues.some((value) => value === String(expected ?? ""));
+    case "contains":
+      return actualValues.some((value) =>
+        expectedValues.length > 1
+          ? expectedValues.includes(value)
+          : value.includes(firstExpected),
+      );
+    case "not_contains":
+      return !actualValues.some((value) =>
+        expectedValues.length > 1
+          ? expectedValues.includes(value)
+          : value.includes(firstExpected),
+      );
+    case "starts_with":
+      return actualValues.some((value) => value.startsWith(firstExpected));
+    case "ends_with":
+      return actualValues.some((value) => value.endsWith(firstExpected));
+    case "is_set":
+      return hasMeaningfulValue(actual);
+    case "is_empty":
+      return !hasMeaningfulValue(actual);
+    case "in":
+      return actualValues.some((value) => expectedValues.includes(value));
+    case "not_in":
+      return !actualValues.some((value) => expectedValues.includes(value));
+    case "matches_wildcard":
+      return actualValues.some((value) => safeRegexTest(wildcardToRegex(firstExpected), value));
+    case "matches_regex":
+      return actualValues.some((value) => safeRegexTest(firstExpected, value));
+    case "greater_than":
+      return compareNumber(actual, expected, (a, b) => a > b);
+    case "greater_than_or_equal":
+      return compareNumber(actual, expected, (a, b) => a >= b);
+    case "less_than":
+      return compareNumber(actual, expected, (a, b) => a < b);
+    case "less_than_or_equal":
+      return compareNumber(actual, expected, (a, b) => a <= b);
+    default:
+      return false;
+  }
+}
+
+function matchSegmentRule(
+  rule: SegmentTargetingRule,
+  ctx: { url: string; attributes: Record<string, unknown> },
+): boolean {
+  const groups = Array.isArray(rule.rules?.groups)
+    ? rule.rules.groups.filter((group) => Array.isArray(group) && group.length > 0)
+    : [];
+  if (groups.length) {
+    return groups.every((group) =>
+      group.some((condition) => matchSegmentCondition(condition, ctx)),
+    );
+  }
+
+  const conditions = rule.rules?.conditions ?? [];
+  if (!conditions.length) return true;
+  if (rule.rules.operator === "or") {
+    return conditions.some((condition) => matchSegmentCondition(condition, ctx));
+  }
+  return conditions.every((condition) => matchSegmentCondition(condition, ctx));
+}
+
+function matchSegmentRules(
+  rules: SegmentTargetingRule[],
+  ctx: { url: string; attributes: Record<string, unknown> },
+): boolean {
+  if (!rules.length) return true;
+  let hasInclude = false;
+  let included = false;
+
+  for (const rule of rules) {
+    const matched = matchSegmentRule(rule, ctx);
+    if (rule.include === false) {
+      if (matched) return false;
+    } else {
+      hasInclude = true;
+      if (matched) included = true;
+    }
+  }
+
+  return included || !hasInclude;
+}
+
+export function matchesTargeting(
+  targeting: Targeting | undefined,
+  ctx: { url: string; attributes: Record<string, unknown> },
+): boolean {
+  return evaluateTargetingGates(targeting, ctx).matched;
+}
+
+export function targetingHasJsTriggers(experiments: Experiment[]): boolean {
+  return experiments.some((experiment) =>
+    (experiment.targeting?.pageRules ?? []).some((rule) =>
+      Boolean(rule.advancedCondition?.code?.trim()) ||
+        Boolean(rule.trigger?.triggerJs?.trim()),
+    ) ||
+      (experiment.targeting?.segmentRules ?? []).some((rule) =>
+        (rule.rules?.conditions ?? []).some((condition) =>
+          Boolean(condition.js?.code?.trim()),
+        ),
+      ),
+  );
+}
+
+export function evaluateTargetingGatesDetailed(
+  targeting: Targeting | undefined,
+  ctx: { url: string; attributes: Record<string, unknown> },
+): TargetingDiagnostics {
+  if (!__DRIP_QA_BUILD__) {
+    const aggregate = evaluateTargetingGates(targeting, ctx);
+    return { ...aggregate, conditions: [] };
+  }
+  return evaluateTargetingGatesWithConditionDiagnostics(targeting, ctx);
+}
+
+export function evaluateTargetingGates(
+  targeting: Targeting | undefined,
+  ctx: { url: string; attributes: Record<string, unknown> },
+): { matched: boolean; gates: ActivationGateDiagnostic[] } {
+  const gates: ActivationGateDiagnostic[] = [];
+  if (!targeting) {
+    return {
+      matched: true,
+      gates: [
+        { id: "page", label: "Page check", status: "skipped", reason: "no_page_rules" },
+        { id: "audience", label: "Audience check", status: "skipped", reason: "no_audience_rules" },
+      ],
+    };
+  }
+
+  const urlRules = normalizeRuntimeUrlRules(targeting);
+  const pageRules = targeting.pageRules ?? [];
+  const pageHasRules = urlRules.length > 0 || pageRules.length > 0;
+  const pageMatched = pageHasRules
+    ? matchUrlRules(ctx.url, urlRules) && matchPageRules(pageRules, ctx)
+    : true;
+  gates.push({
+    id: "page",
+    label: "Page check",
+    status: pageHasRules ? (pageMatched ? "passed" : "failed") : "skipped",
+    reason: pageHasRules ? (pageMatched ? "url_matched" : "url_mismatch") : "no_page_rules",
+    detail: pageHasRules ? { url: ctx.url, rules: urlRules.length, pageRules: pageRules.length } : undefined,
+  });
+
+  if (!pageMatched) {
+    gates.push({
+      id: "audience",
+      label: "Audience check",
+      status: "skipped",
+      reason: "page_mismatch",
+      detail: { skipped: true },
+    });
+    return { matched: false, gates };
+  }
+
+  let attributesMatched = true;
+  const attributeRules = targeting.attributes ?? [];
+  for (const rule of attributeRules) {
+    if (!matchAttributeRule(ctx.attributes, rule)) {
+      attributesMatched = false;
+      break;
+    }
+  }
+
+  const segmentRules = targeting.segmentRules ?? [];
+  const segmentRulesMatched = matchSegmentRules(segmentRules, ctx);
+  const audienceHasRules = attributeRules.length > 0 || segmentRules.length > 0;
+  const audienceMatched = attributesMatched && segmentRulesMatched;
+  gates.push({
+    id: "audience",
+    label: "Audience check",
+    status: audienceHasRules ? (audienceMatched ? "passed" : "failed") : "skipped",
+    reason: audienceHasRules
+      ? (audienceMatched ? "audience_matched" : !attributesMatched ? "attribute_mismatch" : "segment_mismatch")
+      : "no_audience_rules",
+    detail: audienceHasRules ? { attributeRules: attributeRules.length, segmentRules: segmentRules.length } : undefined,
+  });
+
+  return {
+    matched: pageMatched && audienceMatched,
+    gates,
+  };
+}