@drip-apex/sdk 0.1.0 → 0.2.0

package/src/storefront-vitals.test.ts

@@ -0,0 +1,217 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+type Listener = () => void;
+
+function browserHarness() {
+  const documentListeners = new Map<string, Listener>();
+  const windowListeners = new Map<string, Listener>();
+  const sendBeacon = vi.fn(() => true);
+  vi.stubGlobal("document", {
+    visibilityState: "visible",
+    addEventListener: vi.fn((name: string, listener: Listener) => documentListeners.set(name, listener)),
+    removeEventListener: vi.fn(),
+  });
+  vi.stubGlobal("window", {
+    addEventListener: vi.fn((name: string, listener: Listener) => windowListeners.set(name, listener)),
+    removeEventListener: vi.fn(),
+  });
+  vi.stubGlobal("navigator", { sendBeacon });
+  vi.stubGlobal("location", { origin: "https://shop.test", pathname: "/products/a" });
+  vi.stubGlobal("fetch", vi.fn());
+  return { documentListeners, windowListeners, sendBeacon };
+}
+
+describe("storefront vitals", () => {
+  afterEach(async () => {
+    const { resetStorefrontVitalsForTest } = await import("./storefront-vitals");
+    resetStorefrontVitalsForTest();
+    vi.unstubAllGlobals();
+    vi.resetModules();
+  });
+
+  it("keeps one page-level sampling decision across reconfiguration", async () => {
+    const { sendBeacon, windowListeners } = browserHarness();
+    vi.stubGlobal("PerformanceObserver", undefined);
+    const { startStorefrontVitals } = await import("./storefront-vitals");
+    const random = vi.fn(() => 0.05);
+    const base = { endpoint: "https://events.test", shopId: "shop", experimentActive: false };
+    startStorefrontVitals({ ...base, sampleRate: 0.1 }, random);
+    startStorefrontVitals({ ...base, sampleRate: 0 }, random);
+    windowListeners.get("pagehide")?.();
+    expect(random).toHaveBeenCalledTimes(1);
+    expect(sendBeacon).toHaveBeenCalledTimes(1);
+  });
+
+  it("aggregates observer metrics and flushes only once", async () => {
+    const { documentListeners, windowListeners, sendBeacon } = browserHarness();
+    const callbacks = new Map<string, PerformanceObserverCallback>();
+    vi.stubGlobal("performance", { getEntriesByType: () => [{ responseStart: 123 }] });
+    vi.stubGlobal("PerformanceObserver", class {
+      constructor(callback: PerformanceObserverCallback) { this.callback = callback; }
+      callback: PerformanceObserverCallback;
+      observe(options: PerformanceObserverInit) { callbacks.set(String(options.type), this.callback); }
+      disconnect() {}
+      takeRecords() { return []; }
+    });
+    const emit = (type: string, entries: unknown[]) => callbacks.get(type)?.(
+      { getEntries: () => entries } as PerformanceObserverEntryList,
+      {} as PerformanceObserver,
+    );
+    const { startStorefrontVitals } = await import("./storefront-vitals");
+    startStorefrontVitals({ endpoint: "https://events.test/", shopId: "shop", sampleRate: 1, experimentActive: true });
+    expect([...callbacks.keys()]).toEqual(["largest-contentful-paint", "layout-shift", "event"]);
+    emit("largest-contentful-paint", [{ startTime: 900, renderTime: 875 }]);
+    emit("layout-shift", [
+      { startTime: 100, value: 0.08, hadRecentInput: false },
+      { startTime: 500, value: 0.04, hadRecentInput: false },
+      { startTime: 600, value: 1, hadRecentInput: true },
+    ]);
+    emit("event", [
+      { interactionId: 7, duration: 80 },
+      { interactionId: 7, duration: 120 },
+      { interactionId: 8, duration: 90 },
+    ]);
+    Object.defineProperty(document, "visibilityState", { value: "hidden" });
+    documentListeners.get("visibilitychange")?.();
+    windowListeners.get("pagehide")?.();
+    expect(sendBeacon).toHaveBeenCalledTimes(1);
+    const body = JSON.parse(await (sendBeacon.mock.calls[0]![1] as Blob).text());
+    expect(body).toMatchObject({ lcp_ms: 875, inp_ms: 120, cls: 0.12, ttfb_navigation_start_to_response_start_ms: 123 });
+    // Google-threshold ratings ride on the sample so dashboards and alerts
+    // read a bucket without re-deriving thresholds.
+    expect(body).toMatchObject({
+      lcp_rating: "good",
+      inp_rating: "good",
+      cls_rating: "needs-improvement",
+      ttfb_rating: "good",
+    });
+  });
+
+  it("rates each vital against the Google CWV thresholds", async () => {
+    const { rateVital } = await import("./storefront-vitals");
+    expect(rateVital("lcp_ms", 2_500)).toBe("good");
+    expect(rateVital("lcp_ms", 2_501)).toBe("needs-improvement");
+    expect(rateVital("lcp_ms", 4_001)).toBe("poor");
+    expect(rateVital("inp_ms", 200)).toBe("good");
+    expect(rateVital("inp_ms", 501)).toBe("poor");
+    expect(rateVital("cls", 0.09)).toBe("good");
+    expect(rateVital("cls", 0.26)).toBe("poor");
+    expect(rateVital("ttfb_ms", undefined)).toBeUndefined();
+  });
+
+  it("uses loadTime when an LCP entry has a zero renderTime", async () => {
+    const { windowListeners, sendBeacon } = browserHarness();
+    let lcpCallback: PerformanceObserverCallback | undefined;
+    vi.stubGlobal("performance", { getEntriesByType: () => [] });
+    vi.stubGlobal("PerformanceObserver", class {
+      constructor(callback: PerformanceObserverCallback) { lcpCallback ??= callback; }
+      observe() {}
+      disconnect() {}
+      takeRecords() { return []; }
+    });
+    const { startStorefrontVitals } = await import("./storefront-vitals");
+    startStorefrontVitals({ endpoint: "https://events.test", shopId: "shop", sampleRate: 1, experimentActive: false });
+    lcpCallback?.({ getEntries: () => [{ startTime: 1200, renderTime: 0, loadTime: 1234 }] } as PerformanceObserverEntryList, {} as PerformanceObserver);
+    windowListeners.get("pagehide")?.();
+    const body = JSON.parse(await (sendBeacon.mock.calls[0]![1] as Blob).text());
+    expect(body.lcp_ms).toBe(1234);
+  });
+
+  it("reads deferred anti-flicker reveal duration when the sample flushes", async () => {
+    const { windowListeners, sendBeacon } = browserHarness();
+    vi.stubGlobal("PerformanceObserver", undefined);
+    let revealDuration: number | undefined;
+    const { startStorefrontVitals } = await import("./storefront-vitals");
+    startStorefrontVitals({
+      endpoint: "https://events.test",
+      shopId: "shop",
+      sampleRate: 1,
+      experimentActive: true,
+      getAntiFlickerInsertedToRevealMs: () => revealDuration,
+    });
+    revealDuration = 1450;
+    windowListeners.get("pagehide")?.();
+    const body = JSON.parse(await (sendBeacon.mock.calls[0]![1] as Blob).text());
+    expect(body.anti_flicker_inserted_to_reveal_ms).toBe(1450);
+  });
+
+  it("falls back without observers or sendBeacon", async () => {
+    const { windowListeners } = browserHarness();
+    vi.stubGlobal("PerformanceObserver", undefined);
+    vi.stubGlobal("navigator", {});
+    const fetch = vi.fn(() => Promise.resolve(new Response(null, { status: 202 })));
+    vi.stubGlobal("fetch", fetch);
+    const { startStorefrontVitals } = await import("./storefront-vitals");
+    expect(() => startStorefrontVitals({ endpoint: "https://events.test", shopId: "shop", sampleRate: 1, experimentActive: false })).not.toThrow();
+    windowListeners.get("pagehide")?.();
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(new URL(String(fetch.mock.calls[0]![0])).pathname).toBe("/storefront-vitals");
+    const body = JSON.parse(String(fetch.mock.calls[0]![1]?.body));
+    expect(body).not.toHaveProperty("cls");
+  });
+
+  it("uses the same-origin proxy for storefront vitals and retries direct when sendBeacon rejects it", async () => {
+    const { windowListeners, sendBeacon } = browserHarness();
+    vi.stubGlobal("PerformanceObserver", undefined);
+    sendBeacon.mockReturnValueOnce(false).mockReturnValueOnce(true);
+    const { startStorefrontVitals } = await import("./storefront-vitals");
+    startStorefrontVitals({
+      endpoint: "https://events.test",
+      proxyEventDelivery: { enabled: true },
+      shopId: "shop",
+      sampleRate: 1,
+      experimentActive: false,
+    });
+    windowListeners.get("pagehide")?.();
+
+    expect(sendBeacon).toHaveBeenCalledTimes(2);
+    expect(sendBeacon.mock.calls.map(([url]) => String(url))).toEqual([
+      "https://shop.test/apps/apex/storefront-vitals",
+      "https://events.test/storefront-vitals",
+    ]);
+    const directBody = JSON.parse(await (sendBeacon.mock.calls[1]![1] as Blob).text());
+    expect(directBody.delivery_downgrade).toBe("proxy_failed");
+  });
+
+  it("retries a failed proxy fetch directly once", async () => {
+    const { windowListeners } = browserHarness();
+    vi.stubGlobal("PerformanceObserver", undefined);
+    vi.stubGlobal("navigator", {});
+    const fetch = vi.fn()
+      .mockResolvedValueOnce(new Response(null, { status: 502 }))
+      .mockResolvedValueOnce(new Response(null, { status: 202 }));
+    vi.stubGlobal("fetch", fetch);
+    const { startStorefrontVitals } = await import("./storefront-vitals");
+    startStorefrontVitals({
+      endpoint: "https://events.test",
+      proxyEventDelivery: { enabled: true },
+      shopId: "shop",
+      sampleRate: 1,
+      experimentActive: false,
+    });
+    windowListeners.get("pagehide")?.();
+    await vi.waitFor(() => expect(fetch).toHaveBeenCalledTimes(2));
+
+    expect(fetch.mock.calls.map(([url]) => String(url))).toEqual([
+      "https://shop.test/apps/apex/storefront-vitals",
+      "https://events.test/storefront-vitals",
+    ]);
+    expect(String(fetch.mock.calls[1]![1]?.body)).toContain('"delivery_downgrade":"proxy_failed"');
+  });
+
+  it("reports a legitimate zero CLS when layout shifts are supported", async () => {
+    const { windowListeners, sendBeacon } = browserHarness();
+    vi.stubGlobal("performance", { getEntriesByType: () => [] });
+    vi.stubGlobal("PerformanceObserver", class {
+      constructor(_callback: PerformanceObserverCallback) {}
+      observe() {}
+      disconnect() {}
+      takeRecords() { return []; }
+    });
+    const { startStorefrontVitals } = await import("./storefront-vitals");
+    startStorefrontVitals({ endpoint: "https://events.test", shopId: "shop", sampleRate: 1, experimentActive: false });
+    windowListeners.get("pagehide")?.();
+    const body = JSON.parse(await (sendBeacon.mock.calls[0]![1] as Blob).text());
+    expect(body.cls).toBe(0);
+  });
+});

package/src/storefront-vitals.ts

@@ -0,0 +1,206 @@
+export type StorefrontVitalsContext = {
+  endpoint: string;
+  proxyEventDelivery?: { enabled: boolean; path?: string };
+  shopId: string;
+  ingestShopId?: string;
+  ingestSignature?: string;
+  visitorId?: string;
+  sampleRate?: number;
+  experimentActive: boolean;
+  sdkBootToInitMs?: number;
+  getAntiFlickerInsertedToRevealMs?: () => number | undefined;
+  sdkInitStartToAssignmentReadyMs?: number;
+};
+
+type LayoutShift = PerformanceEntry & { value?: number; hadRecentInput?: boolean };
+type EventTiming = PerformanceEntry & { duration?: number; interactionId?: number };
+type LargestPaint = PerformanceEntry & { renderTime?: number; loadTime?: number };
+
+const observers: Array<{ observer: PerformanceObserver; consume: (entries: PerformanceEntry[]) => void }> = [];
+let cleanup: (() => void) | null = null;
+let pageSampleDecision: boolean | undefined;
+
+function finite(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
+export type VitalRating = "good" | "needs-improvement" | "poor";
+
+// Google CWV thresholds (web.dev): the same buckets PageSpeed reports, so
+// dashboards and alerts can read a rating without re-deriving thresholds.
+const RATING_THRESHOLDS: Record<string, [number, number]> = {
+  lcp_ms: [2_500, 4_000],
+  inp_ms: [200, 500],
+  cls: [0.1, 0.25],
+  ttfb_ms: [800, 1_800],
+};
+
+export function rateVital(metric: keyof typeof RATING_THRESHOLDS, value: number | undefined): VitalRating | undefined {
+  const thresholds = RATING_THRESHOLDS[metric];
+  if (!thresholds || value === undefined) return undefined;
+  return value <= thresholds[0] ? "good" : value <= thresholds[1] ? "needs-improvement" : "poor";
+}
+
+function navigationTtfb(): number | undefined {
+  try {
+    const navigation = performance.getEntriesByType("navigation")[0] as PerformanceNavigationTiming | undefined;
+    return finite(navigation?.responseStart);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Starts one dependency-free, observer-only storefront vitals sample. */
+export function startStorefrontVitals(context: StorefrontVitalsContext, random = Math.random): void {
+  stopStorefrontVitals();
+  const rate = finite(context.sampleRate) ?? 0.1;
+  if (pageSampleDecision === undefined) pageSampleDecision = rate > 0 && (rate >= 1 || random() < rate);
+  if (!pageSampleDecision || !context.endpoint || !context.shopId || typeof document === "undefined") return;
+
+  let flushed = false;
+  let lcpMs: number | undefined;
+  let cls = 0;
+  let clsSupported = false;
+  let clsWindow = 0;
+  let clsWindowStart = 0;
+  let clsLastShift = 0;
+  const interactions = new Map<number, number>();
+
+  const observe = (type: string, callback: (entries: PerformanceEntry[]) => void, options?: PerformanceObserverInit): boolean => {
+    if (typeof PerformanceObserver === "undefined") return false;
+    try {
+      const observer = new PerformanceObserver((list) => callback(list.getEntries()));
+      observer.observe(options ?? { type, buffered: true });
+      observers.push({ observer, consume: callback });
+      return true;
+    } catch {
+      // Unsupported entry types are expected on older browsers.
+      return false;
+    }
+  };
+
+  observe("largest-contentful-paint", (entries) => {
+    const last = entries[entries.length - 1] as LargestPaint | undefined;
+    if (last) {
+      // Cross-origin LCP resources can expose renderTime as zero. A real LCP
+      // cannot occur at navigation start, so use the entry's effective time.
+      lcpMs = (finite(last.renderTime) || undefined) ?? finite(last.loadTime) ?? finite(last.startTime);
+    }
+  });
+  clsSupported = observe("layout-shift", (entries) => {
+    for (const raw of entries) {
+      const entry = raw as LayoutShift;
+      if (entry.hadRecentInput || finite(entry.value) === undefined) continue;
+      if (entry.startTime - clsLastShift > 1_000 || entry.startTime - clsWindowStart > 5_000) {
+        clsWindow = 0;
+        clsWindowStart = entry.startTime;
+      }
+      clsWindow += entry.value!;
+      clsLastShift = entry.startTime;
+      cls = Math.max(cls, clsWindow);
+    }
+  });
+  observe("event", (entries) => {
+    for (const raw of entries) {
+      const entry = raw as EventTiming;
+      const id = finite(entry.interactionId);
+      const duration = finite(entry.duration);
+      if (!id || duration === undefined) continue;
+      // One interaction can produce multiple EventTiming entries. INP uses the
+      // longest entry for that interaction, never a double-counted sum.
+      interactions.set(id, Math.max(interactions.get(id) ?? 0, duration));
+    }
+  }, { type: "event", buffered: true, durationThreshold: 40 } as PerformanceObserverInit);
+
+  const flush = () => {
+    if (flushed) return;
+    flushed = true;
+    const ttfbMs = navigationTtfb();
+    for (const { observer, consume } of observers.splice(0)) {
+      try { consume(observer.takeRecords()); } catch {}
+      observer.disconnect();
+    }
+    const interactionDurations = [...interactions.values()].sort((a, b) => b - a);
+    // The CWV INP estimator ignores one extreme interaction per 50 observed
+    // interactions, after first collapsing multiple EventTiming entries by ID.
+    const inpMs = interactionDurations[Math.min(Math.floor(interactionDurations.length / 50), interactionDurations.length - 1)];
+    const sample = {
+      _shopId: context.ingestShopId ?? context.shopId,
+      _signature: context.ingestSignature,
+      shop_id: context.shopId,
+      visitor_id: context.visitorId,
+      url: location.origin + location.pathname,
+      path: location.pathname,
+      lcp_ms: lcpMs,
+      inp_ms: inpMs,
+      cls: clsSupported ? Math.round(cls * 100_000) / 100_000 : undefined,
+      ttfb_navigation_start_to_response_start_ms: ttfbMs,
+      lcp_rating: rateVital("lcp_ms", lcpMs),
+      inp_rating: rateVital("inp_ms", inpMs),
+      cls_rating: clsSupported ? rateVital("cls", cls) : undefined,
+      ttfb_rating: rateVital("ttfb_ms", ttfbMs),
+      experiment_active: context.experimentActive,
+      sdk_boot_to_init_start_ms: context.sdkBootToInitMs,
+      // Reveal can happen well after initialization (hydration/deferred holds),
+      // so resolve this live rather than freezing an incomplete init snapshot.
+      anti_flicker_inserted_to_reveal_ms: context.getAntiFlickerInsertedToRevealMs?.(),
+      sdk_init_start_to_assignment_ready_ms: context.sdkInitStartToAssignmentReadyMs,
+      timestamp: new Date().toISOString(),
+    };
+    const payload = JSON.stringify(sample);
+    const endpoint = context.endpoint.replace(/\/+$/, "") + "/storefront-vitals";
+    const proxyEndpoint = context.proxyEventDelivery?.enabled === true && typeof location?.origin === "string"
+      ? `${location.origin}/apps/apex/storefront-vitals`
+      : null;
+    const downgradedPayload = () => JSON.stringify({ ...sample, delivery_downgrade: "proxy_failed" });
+
+    if (proxyEndpoint) {
+      try {
+        if (navigator.sendBeacon) {
+          if (navigator.sendBeacon(proxyEndpoint, new Blob([payload], { type: "text/plain" }))) return;
+          const directPayload = downgradedPayload();
+          if (navigator.sendBeacon(endpoint, new Blob([directPayload], { type: "text/plain" }))) return;
+          try { void fetch(endpoint, { method: "POST", body: directPayload, headers: { "Content-Type": "text/plain" }, keepalive: true }); } catch {}
+          return;
+        }
+      } catch {
+        const directPayload = downgradedPayload();
+        try {
+          if (navigator.sendBeacon?.(endpoint, new Blob([directPayload], { type: "text/plain" }))) return;
+        } catch {}
+        try { void fetch(endpoint, { method: "POST", body: directPayload, headers: { "Content-Type": "text/plain" }, keepalive: true }); } catch {}
+        return;
+      }
+      void fetch(proxyEndpoint, {
+        method: "POST", body: payload, headers: { "Content-Type": "text/plain" }, keepalive: true,
+      }).then((response) => {
+        if (!response.ok) throw new Error(`Proxy storefront vitals returned ${response.status}`);
+      }).catch(() => fetch(endpoint, {
+        method: "POST", body: downgradedPayload(), headers: { "Content-Type": "text/plain" }, keepalive: true,
+      })).catch(() => undefined);
+      return;
+    }
+    try {
+      if (navigator.sendBeacon?.(endpoint, new Blob([payload], { type: "text/plain" }))) return;
+    } catch {}
+    try { void fetch(endpoint, { method: "POST", body: payload, headers: { "Content-Type": "text/plain" }, keepalive: true }); } catch {}
+  };
+  const onVisibility = () => { if (document.visibilityState === "hidden") flush(); };
+  document.addEventListener("visibilitychange", onVisibility);
+  window.addEventListener("pagehide", flush, { once: true });
+  cleanup = () => {
+    document.removeEventListener("visibilitychange", onVisibility);
+    window.removeEventListener("pagehide", flush);
+  };
+}
+
+export function stopStorefrontVitals(): void {
+  cleanup?.();
+  cleanup = null;
+  for (const { observer } of observers.splice(0)) observer.disconnect();
+}
+
+export function resetStorefrontVitalsForTest(): void {
+  stopStorefrontVitals();
+  pageSampleDecision = undefined;
+}

package/src/surface-signals.ts

@@ -111,6 +111,7 @@ export function installCartDrawerOpenListener(
 
   let current = detectCartDrawerOpen();
 
+  let stopped = false;
   let timeoutId: number | null = null;
   const check = () => {
     timeoutId = null;
@@ -120,6 +121,9 @@ export function installCartDrawerOpenListener(
     onChange(next);
   };
   const schedule = () => {
+    // A mutation record may already be queued when stop() disconnects the
+    // observer. Do not let that stale callback re-arm the check timer.
+    if (stopped) return;
     if (timeoutId !== null) return;
     timeoutId = window.setTimeout(check, 80);
   };
@@ -144,10 +148,12 @@ export function installCartDrawerOpenListener(
   document.addEventListener("keyup", schedule, true);
 
   return () => {
+    stopped = true;
     observer.disconnect();
     document.removeEventListener("click", schedule, true);
     document.removeEventListener("keyup", schedule, true);
     if (timeoutId !== null) window.clearTimeout(timeoutId);
+    timeoutId = null;
   };
 }
 

package/src/targeting-conformance.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest";
+import { targetingConformanceCorpus } from "@drip/event-schema/targeting-conformance";
+import { evaluateConformanceCase } from "@drip/event-schema/targeting-core";
+
+describe("shared targeting conformance", () => {
+  for (const entry of targetingConformanceCorpus) {
+    it(entry.name, () => expect(evaluateConformanceCase(entry)).toBe(entry.verdict));
+  }
+});

package/src/targeting-diagnostics.ts

@@ -11,6 +11,7 @@ import type {
 } from "./types";
 import {
   evalUrlRule,
+  evalUrlRuleForIncludeOrigin,
   evaluateJsTriggerResult,
   evaluatePageAdvancedConditionResult,
   matchAttributeRule,
@@ -29,6 +30,7 @@ function urlRuleOperator(rule: UrlRule): string {
 function diagnoseUrlRules(
   url: string,
   rules: UrlRule[],
+  hostAgnosticIncludeOrigin?: string | string[],
 ): { matched: boolean; conditions: ConditionDiagnostic[] } {
   const conditions: ConditionDiagnostic[] = [];
   if (!rules.length) return { matched: true, conditions };
@@ -53,7 +55,13 @@ function diagnoseUrlRules(
       continue;
     }
 
-    const rawMatched = evalUrlRule(url, rule);
+    const rawMatched = hostAgnosticIncludeOrigin
+      ? evalUrlRuleForIncludeOrigin(
+          url,
+          rule,
+          hostAgnosticIncludeOrigin,
+        )
+      : evalUrlRule(url, rule);
     const passed = rule.include === false ? !rawMatched : rawMatched;
     conditions.push({
       id: `url:${index}`,
@@ -276,6 +284,14 @@ function diagnoseSegmentCondition(
 ): { matched: boolean; diagnostic: ConditionDiagnostic } {
   const resolved = resolveSegmentConditionForDiagnostics(condition, ctx);
   const matched = matchSegmentConditionValues(condition, resolved.actual, resolved.expected);
+  const unresolvedActual =
+    resolved.actual === undefined ||
+    resolved.actual === null ||
+    (typeof resolved.actual === "string" && resolved.actual.trim() === "");
+  const diagnosticActual =
+    condition.signal === "device.type" && resolved.actual === undefined
+      ? ""
+      : resolved.actual;
   return {
     matched,
     diagnostic: segmentConditionDiagnostic(
@@ -283,8 +299,10 @@ function diagnoseSegmentCondition(
       condition,
       index,
       matched ? "passed" : "failed",
-      matched ? undefined : resolved.jsReason ?? "segment_mismatch",
-      resolved.actual,
+      matched
+        ? undefined
+        : resolved.jsReason ?? (!condition.js && unresolvedActual ? "signal_unresolved" : "segment_mismatch"),
+      diagnosticActual,
       resolved.expected,
     ),
   };
@@ -479,7 +497,11 @@ function skippedSegmentConditions(rules: SegmentTargetingRule[], reason: string)
 
 export function evaluateTargetingGatesWithConditionDiagnostics(
   targeting: Targeting | undefined,
-  ctx: { url: string; attributes: Record<string, unknown> },
+  ctx: {
+    url: string;
+    attributes: Record<string, unknown>;
+    hostAgnosticIncludeOrigin?: string | string[];
+  },
 ): TargetingDiagnostics {
   const conditions: ConditionDiagnostic[] = [];
   if (!targeting) {
@@ -497,7 +519,11 @@ export function evaluateTargetingGatesWithConditionDiagnostics(
   const urlRules = normalizeRuntimeUrlRules(targeting);
   const pageRules = targeting.pageRules ?? [];
   const pageHasRules = urlRules.length > 0 || pageRules.length > 0;
-  const url = diagnoseUrlRules(ctx.url, urlRules);
+  const url = diagnoseUrlRules(
+    ctx.url,
+    urlRules,
+    ctx.hostAgnosticIncludeOrigin,
+  );
   conditions.push(...url.conditions);
 
   let pageRulesMatched = true;
@@ -521,6 +547,10 @@ export function evaluateTargetingGatesWithConditionDiagnostics(
 
   const attributeRules = targeting.attributes ?? [];
   const segmentRules = targeting.segmentRules ?? [];
+  const segmentRefs = targeting.segments ?? [];
+  const segmentsExpanded = segmentRefs.every((ref) =>
+    segmentRules.some((rule) => rule.id === ref.id)
+  );
   if (!pageMatched) {
     conditions.push(...skippedAttributeConditions(attributeRules, "page_mismatch"));
     conditions.push(...skippedSegmentConditions(segmentRules, "page_mismatch"));
@@ -540,14 +570,14 @@ export function evaluateTargetingGatesWithConditionDiagnostics(
   const segments = diagnoseSegmentRules(segmentRules, ctx);
   conditions.push(...segments.conditions);
 
-  const audienceHasRules = attributeRules.length > 0 || segmentRules.length > 0;
-  const audienceMatched = attributes.matched && segments.matched;
+  const audienceHasRules = attributeRules.length > 0 || segmentRules.length > 0 || segmentRefs.length > 0;
+  const audienceMatched = segmentsExpanded && attributes.matched && segments.matched;
   gates.push({
     id: "audience",
     label: "Audience check",
     status: audienceHasRules ? (audienceMatched ? "passed" : "failed") : "skipped",
     reason: audienceHasRules
-      ? (audienceMatched ? "audience_matched" : !attributes.matched ? "attribute_mismatch" : "segment_mismatch")
+      ? (audienceMatched ? "audience_matched" : !segmentsExpanded ? "segments_unexpanded" : !attributes.matched ? "attribute_mismatch" : "segment_mismatch")
       : "no_audience_rules",
     detail: audienceHasRules ? { attributeRules: attributeRules.length, segmentRules: segmentRules.length } : undefined,
   });