@drip-apex/sdk 0.1.0 → 0.3.0

package/src/runtime.test.ts

@@ -53,6 +53,26 @@ describe("platform/router runtime", () => {
     expect(resolveRouterMode(config, "spa")).toBe("navigation");
   });
 
+  it("keeps auto-routed SPA page targeting observable without Navigation API", () => {
+    const g = globalThis as Record<string, unknown>;
+    g.navigation = undefined;
+    const config: InitConfig = {
+      platformHint: "spa",
+      experiments: [{
+        id: "exp_page_rule",
+        variations: [{ id: "var_1", weight: 1, mutations: [] }],
+        targeting: {
+          pageRules: [{
+            id: "products",
+            includeRules: [{ type: "simple", pattern: "/products/*" }],
+          }],
+        },
+      }],
+    };
+
+    expect(resolveRouterMode(config, resolvePlatform(config))).toBe("history");
+  });
+
   it("resolves activation mode to observer by default", () => {
     expect(resolveActivationMode({ experiments: [] })).toBe("observer");
     expect(resolveActivationMode({ experiments: [], activationMode: "manual" })).toBe("manual");
@@ -74,6 +94,112 @@ describe("platform/router runtime", () => {
     expect(deps.hash).toBe(true);
   });
 
+  it("builds path-only URL diff needs from published page targeting rules", () => {
+    const deps = computeUrlDiffNeeds([{
+      id: "exp_page_rule",
+      variations: [{ id: "var_1", weight: 1, mutations: [] }],
+      targeting: {
+        pageRules: [{
+          id: "products",
+          includeRules: [{ type: "simple", pattern: "/products/*" }],
+        }],
+      },
+    }]);
+
+    expect(deps).toEqual({ path: true, search: false, hash: false });
+    expect(shouldReevaluateForUrlChange(
+      "https://example.com/products/a?q=1",
+      "https://example.com/collections?q=1",
+      deps,
+    )).toBe(true);
+    expect(shouldReevaluateForUrlChange(
+      "https://example.com/products/a?q=1",
+      "https://example.com/products/a?q=2",
+      deps,
+    )).toBe(false);
+  });
+
+  it("builds URL diff needs from goal-only Page rules", () => {
+    const deps = computeUrlDiffNeeds([{
+      id: "exp_goal_page_rule",
+      variations: [{ id: "var_1", weight: 1, mutations: [] }],
+      goalPageRules: [{
+        id: "checkout",
+        includeRules: [{ type: "simple", pattern: "/checkout?step=*" }],
+      }],
+    }]);
+
+    expect(deps).toEqual({ path: true, search: true, hash: false });
+  });
+
+  it("reevaluates goal-only Page rules when a force-link signature changes", () => {
+    const deps = computeUrlDiffNeeds([{
+      id: "exp_goal_page_rule",
+      variations: [{ id: "var_1", weight: 1, mutations: [] }],
+      goalPageRules: [{
+        id: "products",
+        includeRules: [{ type: "simple", pattern: "/products/*" }],
+      }],
+    }]);
+
+    expect(deps).toEqual({ path: true, search: false, hash: false });
+    expect(shouldReevaluateForUrlChange(
+      "https://example.com/products/a",
+      "https://example.com/products/a?drip_force=exp_goal_page_rule:var_1",
+      deps,
+    )).toBe(true);
+    expect(shouldReevaluateForUrlChange(
+      "https://example.com/products/a?q=1",
+      "https://example.com/products/a?q=2",
+      deps,
+    )).toBe(false);
+    expect(shouldReevaluateForUrlChange(
+      "https://example.com/products/a?q=1",
+      "https://example.com/collections?q=1",
+      deps,
+    )).toBe(true);
+  });
+
+  it("builds URL diff needs from URL-backed audience rules and advanced JS", () => {
+    const audienceDeps = computeUrlDiffNeeds([{
+      id: "exp_audience",
+      variations: [{ id: "var_1", weight: 1, mutations: [] }],
+      targeting: {
+        attributes: [{ attribute: "url.path", operator: "contains", value: "/products" }],
+        segmentRules: [{
+          id: "query",
+          rules: {
+            version: 1,
+            operator: "and",
+            conditions: [{ signal: "url.query", operator: "is_set", value: "campaign" }],
+          },
+        }],
+      },
+    }]);
+    expect(audienceDeps).toEqual({ path: true, search: true, hash: false });
+
+    const jsDeps = computeUrlDiffNeeds([{
+      id: "exp_js",
+      variations: [{ id: "var_1", weight: 1, mutations: [] }],
+      targeting: {
+        pageRules: [{ id: "advanced", advancedCondition: { code: "return location.hash === '#sale';" } }],
+      },
+    }]);
+    expect(jsDeps).toEqual({ path: true, search: true, hash: true });
+
+    const documentJsDeps = computeUrlDiffNeeds([{
+      id: "exp_document_js",
+      variations: [{ id: "var_1", weight: 1, mutations: [] }],
+      targeting: {
+        pageRules: [{
+          id: "advanced-document",
+          advancedCondition: { code: "return document.documentURI.endsWith('#sale');" },
+        }],
+      },
+    }]);
+    expect(documentJsDeps).toEqual({ path: true, search: true, hash: true });
+  });
+
   it("builds URL diff needs from route-captured runtime signals", () => {
     const queryDeps = computeUrlDiffNeeds([], [
       {
@@ -122,6 +248,14 @@ describe("platform/router runtime", () => {
     ).toBe(true);
   });
 
+  it("treats the clear sentinel as an observable force signature", () => {
+    expect(shouldReevaluateForUrlChange(
+      "https://example.com/products/a?drip_force=exp_1:var_a",
+      "https://example.com/products/a?drip_force=clear",
+      { path: false, search: false, hash: false },
+    )).toBe(true);
+  });
+
   it("reevaluates when readable force params change without URL targeting deps", () => {
     const deps = { path: false, search: false, hash: false };
     expect(
@@ -157,13 +291,46 @@ describe("platform/router runtime", () => {
     expect(a).toBe(b);
   });
 
-  it("allows perf flag overrides per init config", () => {
-    const flags = readPerfFlags({
-      experiments: [],
-      perfFlags: { perf_spa_incremental_reapply_v1: false },
-    });
-    expect(flags.perf_platform_router_v1).toBe(true);
-    expect(flags.perf_spa_incremental_reapply_v1).toBe(false);
+  it("changes the assignment signature when the active URL block changes", () => {
+    const first = assignmentSignature([
+      {
+        experimentId: "exp_a",
+        variationId: "var_1",
+        activeUrlBlockId: "product-a",
+      } as any,
+    ]);
+    const second = assignmentSignature([
+      {
+        experimentId: "exp_a",
+        variationId: "var_1",
+        activeUrlBlockId: "product-b",
+      } as any,
+    ]);
+    const flat = assignmentSignature([
+      {
+        experimentId: "exp_a",
+        variationId: "var_1",
+      } as any,
+    ]);
+
+    expect(first).not.toBe(second);
+    expect(first).not.toBe(flat);
+    expect(first).not.toContain("mutations");
+  });
+
+  it("changes the assignment signature when page activity changes", () => {
+    const active = assignmentSignature([
+      { experimentId: "exp_a", variationId: "var_1", pageActive: true } as any,
+    ]);
+    const inactive = assignmentSignature([
+      { experimentId: "exp_a", variationId: "var_1", pageActive: false } as any,
+    ]);
+
+    expect(active).not.toBe(inactive);
+  });
+
+  it("defaults the surviving empty-project perf flag off", () => {
+    const flags = readPerfFlags({ experiments: [] });
     expect(flags.perf_empty_project_v1).toBe(false);
   });
 

package/src/runtime.ts

@@ -17,9 +17,6 @@ type UrlDiffNeeds = {
 export type PerfFlagState = Record<PerfFeatureFlag, boolean>;
 
 const PERF_FLAG_DEFAULTS: PerfFlagState = {
-  perf_platform_router_v1: true,
-  perf_shopify_pixel_buffer_v1: true,
-  perf_spa_incremental_reapply_v1: true,
   perf_empty_project_v1: false,
 };
 
@@ -157,8 +154,10 @@ function parseMaybeUrl(url: string): URL | null {
 }
 
 function readForceSignature(params: URLSearchParams): string {
-  const canonical = params.get("drip_force") ?? "";
-  if (canonical) return canonical;
+  const canonical = params.get("drip_force");
+  if (canonical !== null) {
+    return canonical.trim().toLowerCase() === "clear" ? "__drip_force_clear__" : canonical;
+  }
   const experimentId =
     params.get("drip_experiment_id") ??
     params.get("drip_experiment") ??
@@ -179,7 +178,7 @@ function readForceSignature(params: URLSearchParams): string {
 function markUrlDepsForPattern(
   deps: UrlDiffNeeds,
   pattern: string,
-  type: "regex" | "simple",
+  type: "regex" | "simple" | undefined,
 ): void {
   if (type === "regex") {
     deps.path = true;
@@ -192,18 +191,86 @@ function markUrlDepsForPattern(
   if (pattern.includes("#")) deps.hash = true;
 }
 
+function markUrlDepsForSignal(deps: UrlDiffNeeds, signal: string): void {
+  if (signal === "url.path") deps.path = true;
+  if (signal === "url.query") deps.search = true;
+  if (signal === "url.full") {
+    deps.path = true;
+    deps.search = true;
+    deps.hash = true;
+  }
+}
+
+function jsMayReadUrl(code: string | undefined): boolean {
+  // `document` is included because document.documentURI/baseURI expose the
+  // full URL without mentioning `location` or `url`.
+  return Boolean(code?.trim() && /\b(?:location|url|document)\b/i.test(code));
+}
+
 export function computeUrlDiffNeeds(
   experiments: Experiment[],
   signals: InitConfig["signals"] = [],
 ): UrlDiffNeeds {
   const deps: UrlDiffNeeds = { path: false, search: false, hash: false };
+  let hasUrlTargeting = false;
   for (const exp of experiments) {
     const rules = exp.targeting?.url;
-    if (!rules || rules.length === 0) continue;
-    for (const rule of rules) {
+    for (const rule of rules ?? []) {
+      hasUrlTargeting = true;
       markUrlDepsForPattern(deps, rule.pattern, rule.type);
       if (deps.path && deps.search && deps.hash) return deps;
     }
+    for (const rule of [
+      ...(exp.targeting?.pageRules ?? []),
+      ...(exp.goalPageRules ?? []),
+    ]) {
+      hasUrlTargeting = true;
+      // Published rules without a recognized matcher still depend on the
+      // current page. Never let an unknown shape suppress pathname rechecks.
+      deps.path = true;
+      for (const urlRule of [...(rule.includeRules ?? []), ...(rule.excludeRules ?? [])]) {
+        markUrlDepsForPattern(deps, urlRule.pattern, urlRule.type);
+      }
+      if (
+        jsMayReadUrl(rule.advancedCondition?.code)
+        || jsMayReadUrl(rule.trigger?.triggerJs)
+      ) {
+        deps.path = true;
+        deps.search = true;
+        deps.hash = true;
+      }
+      if (deps.path && deps.search && deps.hash) return deps;
+    }
+    for (const rule of exp.targeting?.attributes ?? []) {
+      markUrlDepsForSignal(deps, rule.attribute);
+      if (rule.attribute.startsWith("url.")) hasUrlTargeting = true;
+    }
+    for (const rule of exp.targeting?.segmentRules ?? []) {
+      const conditions = [
+        ...(rule.rules?.conditions ?? []),
+        ...(rule.rules?.groups ?? []).flat(),
+      ];
+      for (const condition of conditions) {
+        markUrlDepsForSignal(deps, condition.signal);
+        if (condition.signal.startsWith("url.")) hasUrlTargeting = true;
+        if (jsMayReadUrl(condition.js?.code) || jsMayReadUrl(condition.js?.resetCode)) {
+          hasUrlTargeting = true;
+          deps.path = true;
+          deps.search = true;
+          deps.hash = true;
+        }
+      }
+      if (deps.path && deps.search && deps.hash) return deps;
+    }
+    for (const variation of exp.variations) {
+      for (const block of variation.urlBlocks ?? []) {
+        for (const rule of block.urlRules) {
+          hasUrlTargeting = true;
+          markUrlDepsForPattern(deps, rule.pattern, rule.type);
+          if (deps.path && deps.search && deps.hash) return deps;
+        }
+      }
+    }
   }
 
   for (const definition of signals ?? []) {
@@ -219,6 +286,7 @@ export function computeUrlDiffNeeds(
     if (deps.path && deps.search && deps.hash) return deps;
   }
 
+  if (hasUrlTargeting && !deps.path && !deps.search && !deps.hash) deps.path = true;
   return deps;
 }
 
@@ -231,21 +299,27 @@ export function shouldReevaluateForUrlChange(
   const prev = parseMaybeUrl(previousUrl);
   const next = parseMaybeUrl(nextUrl);
   if (!prev || !next) return true;
+  const prevForce = readForceSignature(prev.searchParams);
+  const nextForce = readForceSignature(next.searchParams);
+  if (prevForce !== nextForce) return true;
   if (deps.path && prev.pathname !== next.pathname) return true;
   if (deps.search && prev.search !== next.search) return true;
   if (deps.hash && prev.hash !== next.hash) return true;
-  if (!deps.path && !deps.search && !deps.hash) {
-    const prevForce = readForceSignature(prev.searchParams);
-    const nextForce = readForceSignature(next.searchParams);
-    return prevForce !== nextForce;
-  }
   return false;
 }
 
 export function assignmentSignature(assignments: Assignment[]): string {
   if (!assignments.length) return "none";
   return assignments
-    .map((item) => item.experimentId + ":" + item.variationId)
+    .map((item) =>
+      item.experimentId +
+      ":" +
+      item.variationId +
+      ":" +
+      (item.activeUrlBlockId ? `block:${item.activeUrlBlockId}` : "flat") +
+      ":" +
+      (item.pageActive ? 1 : 0),
+    )
     .sort()
     .join("|");
 }

package/src/sanitize.test.ts

@@ -0,0 +1,34 @@
+// @vitest-environment jsdom
+import { describe, expect, it } from "vitest";
+import { isSafeMutationAttribute, sanitizeHtml } from "./sanitize";
+
+describe("isSafeMutationAttribute", () => {
+  it("allows removals without allowing dangerous attribute writes", () => {
+    expect(isSafeMutationAttribute("onclick", null)).toBe(true);
+    expect(isSafeMutationAttribute("onclick", "x")).toBe(false);
+    expect(isSafeMutationAttribute("srcdoc", null)).toBe(true);
+    expect(isSafeMutationAttribute("", null)).toBe(false);
+    expect(isSafeMutationAttribute("href", "https://example.com")).toBe(true);
+    expect(isSafeMutationAttribute("href", "javascript:alert(1)")).toBe(false);
+  });
+});
+
+describe("sanitizeHtml", () => {
+  it("unconditionally strips unsafe mutation attributes", () => {
+    const sanitized = sanitizeHtml([
+      '<iframe srcdoc="<script>alert(1)</script>"></iframe>',
+      '<a href="data:text/html,alert(1)" onclick="alert(1)">data</a>',
+      '<a href="java\nscript:alert(1)">javascript</a>',
+      '<img src="data:image/png;base64,iVBORw0KGgo=">',
+    ].join(""));
+    const template = document.createElement("template");
+    template.innerHTML = sanitized;
+    expect(template.content.querySelector("iframe")?.hasAttribute("srcdoc")).toBe(false);
+    const anchors = template.content.querySelectorAll("a");
+    expect(anchors[0]?.hasAttribute("href")).toBe(false);
+    expect(anchors[0]?.hasAttribute("onclick")).toBe(false);
+    expect(anchors[1]?.hasAttribute("href")).toBe(false);
+    expect(template.content.querySelector("img")?.getAttribute("src"))
+      .toBe("data:image/png;base64,iVBORw0KGgo=");
+  });
+});

package/src/sanitize.ts

@@ -1,3 +1,25 @@
+const URL_ATTRIBUTES = new Set(["href", "src", "action", "formaction", "xlink:href"]);
+const SAFE_DATA_URL_MEDIA_TYPES = new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp",
+  "image/avif",
+]);
+
+export function isSafeMutationAttribute(name: string, value: string | null): boolean {
+  const normalizedName = name.trim().toLowerCase();
+  if (!normalizedName) return false;
+  if (value === null) return true;
+  if (normalizedName.startsWith("on") || normalizedName === "srcdoc") return false;
+  if (!URL_ATTRIBUTES.has(normalizedName)) return true;
+  const normalizedValue = value.replace(/[\u0000-\u0020]+/g, "").toLowerCase();
+  if (normalizedValue.startsWith("javascript:")) return false;
+  if (!normalizedValue.startsWith("data:")) return true;
+  const mediaType = normalizedValue.slice(5).split(/[;,]/, 1)[0];
+  return SAFE_DATA_URL_MEDIA_TYPES.has(mediaType);
+}
+
 /**
  * Lightweight HTML sanitizer using the browser's DOMParser.
  * Strips <script> tags, on* event handlers, and javascript: URLs.
@@ -13,19 +35,8 @@ export function sanitizeHtml(html: string): string {
   // Walk every element to strip dangerous attributes
   for (const el of Array.from(doc.body.querySelectorAll("*"))) {
     for (const attr of Array.from(el.attributes)) {
-      // Remove on* event handler attributes (onclick, onerror, etc.)
-      if (attr.name.toLowerCase().startsWith("on")) {
+      if (!isSafeMutationAttribute(attr.name, attr.value)) {
         el.removeAttribute(attr.name);
-        continue;
-      }
-
-      // Remove javascript: URLs in href, src, action, formaction, xlink:href
-      const urlAttrs = ["href", "src", "action", "formaction", "xlink:href"];
-      if (urlAttrs.includes(attr.name.toLowerCase())) {
-        const value = attr.value.replace(/\s+/g, "").toLowerCase();
-        if (value.startsWith("javascript:")) {
-          el.removeAttribute(attr.name);
-        }
       }
     }
   }

package/src/shadow.test.ts

@@ -0,0 +1,187 @@
+// @vitest-environment jsdom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { setupGoals } from "./goals";
+import { applyMutations, applyToElement, resetAppliedMutations } from "./mutate";
+import { trackAppliedMutation, resetReassertSentinel } from "./reassert-sentinel";
+import { queryAllDeep } from "./shadow";
+
+class BookingDrawer extends HTMLElement {
+  readonly root = this.attachShadow({ mode: "open" });
+
+  render(): void {
+    this.root.innerHTML = `
+      <section class="booking" data-step="control">
+        <strong class="title">Control</strong>
+        <button class="continue">Continue</button>
+      </section>`;
+  }
+
+  renderWithoutContinue(): void {
+    this.root.innerHTML = `
+      <section class="booking" data-step="control">
+        <strong class="title">Control</strong>
+      </section>`;
+  }
+}
+
+if (!customElements.get("booking-drawer")) customElements.define("booking-drawer", BookingDrawer);
+
+function fixture(): BookingDrawer {
+  const drawer = document.createElement("booking-drawer") as BookingDrawer;
+  drawer.render();
+  document.body.appendChild(drawer);
+  queryAllDeep("[data-shadow-registry-probe]");
+  return drawer;
+}
+
+describe("open shadow DOM support", () => {
+  afterEach(() => {
+    setupGoals([], [], vi.fn());
+    resetReassertSentinel();
+    resetAppliedMutations();
+    document.body.innerHTML = "";
+    localStorage.clear();
+  });
+
+  it("applies text, html, and attribute mutations inside an open root", () => {
+    const drawer = fixture();
+    applyMutations([
+      { selector: ".title", action: "text", text: "Treatment" },
+      { selector: ".continue", action: "html", html: "<span>Book now</span>" },
+      { selector: ".booking", action: "attribute", attributes: { "data-step": "treatment" } },
+    ]);
+
+    expect(drawer.root.querySelector(".title")?.textContent).toBe("Treatment");
+    expect(drawer.root.querySelector(".continue")?.innerHTML).toBe("<span>Book now</span>");
+    expect(drawer.root.querySelector(".booking")?.getAttribute("data-step")).toBe("treatment");
+  });
+
+  it("reasserts text, html, and attribute mutations after the widget replaces its shadow children", async () => {
+    const drawer = fixture();
+    await Promise.resolve();
+    const mutations = [
+      { selector: ".title", action: "text" as const, text: "Treatment" },
+      { selector: ".continue", action: "html" as const, html: "<span>Book now</span>" },
+      { selector: ".booking", action: "attribute" as const, attributes: { "data-step": "treatment" } },
+    ];
+    for (const mutation of mutations) {
+      const original = queryAllDeep(mutation.selector)[0];
+      applyToElement(mutation, original);
+      trackAppliedMutation(original, mutation, {}, (element, treatment) => applyToElement(treatment, element));
+    }
+
+    drawer.render();
+    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+
+    expect(drawer.root.querySelector(".title")?.textContent).toBe("Treatment");
+    expect(drawer.root.querySelector(".continue")?.innerHTML).toBe("<span>Book now</span>");
+    expect(drawer.root.querySelector(".booking")?.getAttribute("data-step")).toBe("treatment");
+
+    // A second full re-render must also reassert: the entry has to migrate to
+    // the replacement element's observer root, not stay keyed under the
+    // disconnected element (where the next observe() sweep would purge it).
+    drawer.render();
+    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+
+    expect(drawer.root.querySelector(".title")?.textContent).toBe("Treatment");
+    expect(drawer.root.querySelector(".continue")?.innerHTML).toBe("<span>Book now</span>");
+    expect(drawer.root.querySelector(".booking")?.getAttribute("data-step")).toBe("treatment");
+  });
+
+  it("resurrects a sibling treatment whose replacement appears only in a later re-render", async () => {
+    const drawer = fixture();
+    await Promise.resolve();
+    const mutations = [
+      { selector: ".title", action: "text" as const, text: "Treatment" },
+      { selector: ".continue", action: "text" as const, text: "Book now" },
+    ];
+    for (const mutation of mutations) {
+      const original = queryAllDeep(mutation.selector)[0];
+      applyToElement(mutation, original);
+      trackAppliedMutation(original, mutation, {}, (element, treatment) => applyToElement(treatment, element));
+    }
+
+    // Partial re-render: .title migrates (running observe()'s GC sweep) while
+    // .continue has no replacement in this batch — its entry must survive.
+    drawer.renderWithoutContinue();
+    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+    expect(drawer.root.querySelector(".title")?.textContent).toBe("Treatment");
+
+    drawer.render();
+    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+    expect(drawer.root.querySelector(".title")?.textContent).toBe("Treatment");
+    expect(drawer.root.querySelector(".continue")?.textContent).toBe("Book now");
+  });
+
+  it("discovers hosts that attach a shadow root after insertion", () => {
+    const el = document.createElement("div");
+    document.body.appendChild(el);
+    const root = el.attachShadow({ mode: "open" });
+    root.innerHTML = '<button class="late-btn">Go</button>';
+
+    const found = queryAllDeep(".late-btn");
+    expect(found).toHaveLength(1);
+    expect(found[0]).toBe(root.querySelector(".late-btn"));
+  });
+
+  it("returns multi-host matches in document order, not registration order", () => {
+    const first = fixture();
+    const second = fixture();
+    // Re-insert the first host at the front: registration order is now
+    // (second, first) while document order is (first, second).
+    first.remove();
+    queryAllDeep("[data-shadow-registry-probe]");
+    document.body.insertBefore(first, second);
+
+    const titles = queryAllDeep(".title");
+    expect(titles).toHaveLength(2);
+    expect(titles[0]).toBe(first.root.querySelector(".title"));
+    expect(titles[1]).toBe(second.root.querySelector(".title"));
+  });
+
+  it("fires selector and text click goals from a shadow-internal target", () => {
+    const drawer = fixture();
+    const callback = vi.fn();
+    setupGoals(
+      [{ experimentId: "exp", variationId: "var" }],
+      [{ id: "exp", goals: [{ id: "click", type: "click", selector: ".booking .continue", textMatch: "Continue" }] }],
+      callback,
+    );
+
+    (drawer.root.querySelector(".continue") as HTMLButtonElement).click();
+    expect(callback).toHaveBeenCalledWith(
+      "click",
+      { experimentId: "exp", variationId: "var" },
+      {},
+    );
+  });
+
+  it("fires click goals when the composed path starts at a Text node", () => {
+    const drawer = fixture();
+    const callback = vi.fn();
+    setupGoals(
+      [{ experimentId: "exp", variationId: "var" }],
+      [{ id: "exp", goals: [{ id: "click", type: "click", selector: ".booking .continue" }] }],
+      callback,
+    );
+
+    const textNode = drawer.root.querySelector(".continue")!.firstChild!;
+    textNode.dispatchEvent(new MouseEvent("click", { bubbles: true, composed: true }));
+    expect(callback).toHaveBeenCalledWith(
+      "click",
+      { experimentId: "exp", variationId: "var" },
+      {},
+    );
+  });
+
+  it("issues no per-host queries on a shadow-free document", () => {
+    document.body.innerHTML = '<div class="missing"></div>';
+    const documentQuery = vi.spyOn(document, "querySelectorAll");
+
+    expect(queryAllDeep(".absent")).toEqual([]);
+    // One selector query plus the one miss-path host rescan — nothing else.
+    expect(documentQuery).toHaveBeenCalledTimes(2);
+    expect(documentQuery).toHaveBeenNthCalledWith(1, ".absent");
+    expect(documentQuery).toHaveBeenNthCalledWith(2, "*");
+  });
+});