@drip-apex/sdk 0.1.0

package/dist/types/wait.d.ts

@@ -0,0 +1,7 @@
+import { Mutation } from "./types";
+export declare function waitForElement(selector: string, callback: (el: Element) => void, options?: {
+    ttlMs?: number;
+    onMiss?: () => void;
+}): void;
+export declare function applyMutationWithWait(mutation: Mutation, index: number, onApplied?: ((mutation: Mutation, element: Element, index: number) => void) | null, onMiss?: ((mutation: Mutation, index: number) => void) | null): void;
+export declare function resetWaitEntries(): void;

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@drip-apex/sdk",
+  "version": "0.1.0",
+  "license": "MIT",
+  "main": "dist/drip.js",
+  "types": "dist/types/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/drip.js"
+    },
+    "./define": {
+      "types": "./dist/types/define.d.ts",
+      "default": "./src/define.ts"
+    },
+    "./flags": {
+      "types": "./dist/types/flags.d.ts",
+      "default": "./src/flags.ts"
+    },
+    "./react": {
+      "types": "./dist/types/react/index.d.ts",
+      "default": "./dist/react/index.js"
+    },
+    "./chooser": {
+      "types": "./dist/types/module.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "node build.mjs && npm run build:types",
+    "build:types": "tsc -p tsconfig.json --emitDeclarationOnly --outDir dist/types",
+    "typecheck": "tsc --noEmit",
+    "deploy:pages": "npm run build && ../worker/node_modules/.bin/wrangler pages deploy dist --project-name drip-sdk",
+    "deploy:pages:staging": "npm run build && ../worker/node_modules/.bin/wrangler pages deploy dist --project-name ${SDK_PAGES_PROJECT_STAGING:-drip-sdk-staging}",
+    "test": "vitest run && npm run build && node --test bundle-report.test.mjs package-entry.test.mjs",
+    "check:docs": "node check-docs-init-config.mjs",
+    "test:watch": "vitest"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.1",
+    "@drip/event-schema": "file:../event-schema",
+    "@types/react": "^19.2.14",
+    "esbuild": "0.28.1",
+    "jsdom": "^27.3.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "terser": "5.48.0",
+    "typescript": "^5.6.3",
+    "vitest": "^3.2.6"
+  },
+  "overrides": {
+    "esbuild": "0.28.1",
+    "picomatch": "^4.0.4",
+    "postcss": "^8.5.15",
+    "rollup": "^4.60.4",
+    "vite": "7.3.5"
+  }
+}

package/src/analytics.ts

@@ -0,0 +1,146 @@
+/**
+ * analytics.ts — Automatic pageview and engagement tracking.
+ *
+ * Fires two event types through the existing track() pipeline:
+ *   - "pageview" on every page load / SPA navigation
+ *   - "page_exit" on navigation away / tab close (with duration + scroll depth)
+ */
+
+type TrackFn = (type: string, data?: Record<string, unknown>) => void;
+
+let pageEnteredAt = 0;
+let maxScrollDepth = 0;
+let scrollCleanup: (() => void) | null = null;
+let referrer = "";
+let utmParams: Record<string, string> = {};
+let initialized = false;
+
+/** Parse UTM params from URL. Persist in sessionStorage so they stick across the session. */
+function captureUtm(): Record<string, string> {
+  const KEY = "drip_utm";
+  try {
+    const stored = sessionStorage.getItem(KEY);
+    if (stored) return JSON.parse(stored);
+  } catch {}
+  const params = new URLSearchParams(location.search);
+  const utms: Record<string, string> = {};
+  for (const k of [
+    "utm_source",
+    "utm_medium",
+    "utm_campaign",
+    "utm_term",
+    "utm_content",
+  ]) {
+    const v = params.get(k);
+    if (v) utms[k] = v;
+  }
+  if (Object.keys(utms).length) {
+    try {
+      sessionStorage.setItem(KEY, JSON.stringify(utms));
+    } catch {}
+  }
+  return utms;
+}
+
+/** Capture and normalise the referring domain. */
+function captureReferrer(): string {
+  const ref = document.referrer;
+  if (!ref) return "(direct)";
+  try {
+    const host = new URL(ref).hostname;
+    if (host === location.hostname) return "(internal)";
+    return host;
+  } catch {
+    return "(direct)";
+  }
+}
+
+/** Track max scroll depth as 0-100 percentage. Returns cleanup fn. */
+function startScrollTracking(): () => void {
+  const handler = () => {
+    // The snippet can execute in <head> before <body> exists.
+    if (!document.body) return;
+    const docHeight = Math.max(
+      document.body.scrollHeight,
+      document.documentElement.scrollHeight,
+    );
+    const viewportHeight = window.innerHeight;
+    if (docHeight <= viewportHeight) {
+      maxScrollDepth = 100;
+      return;
+    }
+    const pct = Math.round(((window.scrollY + viewportHeight) / docHeight) * 100);
+    if (pct > maxScrollDepth) maxScrollDepth = pct;
+  };
+  window.addEventListener("scroll", handler, { passive: true });
+  let domReady: (() => void) | null = null;
+  if (document.body) {
+    handler();
+  } else {
+    domReady = () => handler();
+    document.addEventListener("DOMContentLoaded", domReady, { once: true });
+  }
+  return () => {
+    window.removeEventListener("scroll", handler);
+    // A page exit before DOM readiness must not leave the deferred
+    // measurement alive to contaminate the next page's scroll depth.
+    if (domReady) document.removeEventListener("DOMContentLoaded", domReady);
+  };
+}
+
+/** Clean URL: origin + pathname only (strips query params). */
+export function cleanUrl(): string {
+  return location.origin + location.pathname;
+}
+
+/** Called on every page load / SPA navigation. */
+export function onPageEnter(trackFn: TrackFn): void {
+  pageEnteredAt = Date.now();
+  maxScrollDepth = 0;
+
+  // Capture referrer + UTMs once per session
+  if (!initialized) {
+    referrer = captureReferrer();
+    utmParams = captureUtm();
+    initialized = true;
+  }
+
+  // Start scroll tracking
+  if (scrollCleanup) {
+    scrollCleanup();
+    scrollCleanup = null;
+  }
+  scrollCleanup = startScrollTracking();
+
+  // Fire pageview
+  const data: Record<string, unknown> = {
+    referrer,
+    path: location.pathname,
+    title: document.title,
+  };
+  // Merge UTMs into event data (only non-empty values)
+  for (const [k, v] of Object.entries(utmParams)) {
+    if (v) data[k] = v;
+  }
+  trackFn("pageview", data);
+}
+
+/** Called on SPA navigation away / page unload. */
+export function onPageExit(trackFn: TrackFn): void {
+  if (!pageEnteredAt) return;
+  const duration = Math.round((Date.now() - pageEnteredAt) / 1000);
+
+  if (scrollCleanup) {
+    scrollCleanup();
+    scrollCleanup = null;
+  }
+
+  trackFn("page_exit", {
+    duration,
+    scroll_depth: maxScrollDepth,
+    path: location.pathname,
+  });
+
+  pageEnteredAt = 0;
+  maxScrollDepth = 0;
+}

package/src/antiflicker.test.ts

@@ -0,0 +1,127 @@
+// @vitest-environment jsdom
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { applyAntiFlicker, removeAntiFlicker, resolveAntiFlickerCss } from "./antiflicker";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  if (vi.isFakeTimers()) {
+    removeAntiFlicker();
+    vi.runAllTimers();
+  }
+  vi.useRealTimers();
+  document.head.innerHTML = "";
+  document.documentElement.className = "";
+});
+
+describe("anti-flicker css resolution", () => {
+  it("does not fall back to full-page hiding for scoped mode without selectors", () => {
+    expect(resolveAntiFlickerCss("scoped")).toBeNull();
+    expect(resolveAntiFlickerCss("scoped", [])).toBeNull();
+  });
+
+  it("builds scoped css when selectors are available", () => {
+    const css = resolveAntiFlickerCss("scoped", [".hero h1", ".cta"]);
+    expect(css).toContain(".hero h1,.cta");
+    expect(css).toContain("visibility: hidden");
+  });
+
+  it("preserves explicit full-page hiding", () => {
+    const css = resolveAntiFlickerCss("full");
+    expect(css).toContain("html.drip-af");
+    expect(css).toContain("opacity: 0");
+  });
+
+  it("binds reveal timers to their owner document after the global DOM tears down", () => {
+    vi.useFakeTimers();
+    applyAntiFlicker("full", 100);
+
+    const ownerDocument = document;
+    expect(ownerDocument.documentElement.classList.contains("drip-af")).toBe(true);
+    expect(ownerDocument.getElementById("drip-antiflicker")).not.toBeNull();
+
+    vi.stubGlobal("document", undefined);
+    expect(() => vi.advanceTimersByTime(180)).not.toThrow();
+
+    expect(ownerDocument.documentElement.classList.contains("drip-af")).toBe(false);
+    expect(ownerDocument.documentElement.classList.contains("drip-af-reveal")).toBe(false);
+    expect(ownerDocument.getElementById("drip-antiflicker")).toBeNull();
+  });
+
+  it("clears old timers and supports a fresh anti-flicker cycle after cleanup", () => {
+    vi.useFakeTimers();
+    applyAntiFlicker("full", 1_000);
+
+    removeAntiFlicker();
+    vi.advanceTimersByTime(80);
+    expect(document.getElementById("drip-antiflicker")).toBeNull();
+    expect(document.documentElement.classList.contains("drip-af-reveal")).toBe(false);
+
+    applyAntiFlicker("full", 200);
+    vi.advanceTimersByTime(160);
+    expect(document.documentElement.classList.contains("drip-af-reveal")).toBe(true);
+    vi.advanceTimersByTime(120);
+
+    expect(document.getElementById("drip-antiflicker")).toBeNull();
+    expect(document.documentElement.classList.contains("drip-af")).toBe(false);
+    expect(document.documentElement.classList.contains("drip-af-reveal")).toBe(false);
+  });
+
+  it("re-arms immediately when re-init starts during reveal cleanup", () => {
+    vi.useFakeTimers();
+    applyAntiFlicker("full", 1_000);
+    const originalStyle = document.getElementById("drip-antiflicker");
+
+    removeAntiFlicker();
+    expect(document.documentElement.classList.contains("drip-af-reveal")).toBe(true);
+    applyAntiFlicker("full", 200);
+
+    expect(document.getElementById("drip-antiflicker")).toBe(originalStyle);
+    expect(document.documentElement.classList.contains("drip-af")).toBe(true);
+    expect(document.documentElement.classList.contains("drip-af-reveal")).toBe(false);
+
+    vi.advanceTimersByTime(160);
+    expect(document.documentElement.classList.contains("drip-af-reveal")).toBe(true);
+    vi.advanceTimersByTime(120);
+    expect(document.getElementById("drip-antiflicker")).toBeNull();
+  });
+
+  it("is safe when invoked without a DOM", () => {
+    vi.useFakeTimers();
+    vi.stubGlobal("document", undefined);
+
+    expect(() => applyAntiFlicker("full", 100)).not.toThrow();
+    expect(() => removeAntiFlicker()).not.toThrow();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("can explicitly clean its owner document after the global DOM disappears", () => {
+    vi.useFakeTimers();
+    applyAntiFlicker("full", 1_000);
+    const ownerDocument = document;
+    vi.stubGlobal("document", undefined);
+
+    expect(() => removeAntiFlicker()).not.toThrow();
+    vi.advanceTimersByTime(80);
+
+    expect(ownerDocument.getElementById("drip-antiflicker")).toBeNull();
+    expect(ownerDocument.documentElement.classList.contains("drip-af")).toBe(false);
+    expect(ownerDocument.documentElement.classList.contains("drip-af-reveal")).toBe(false);
+  });
+
+  it("cleans its owner when the ambient document changes", () => {
+    vi.useFakeTimers();
+    applyAntiFlicker("full", 1_000);
+    const ownerDocument = document;
+    const replacementDocument = document.implementation.createHTMLDocument("replacement");
+    vi.stubGlobal("document", replacementDocument);
+
+    removeAntiFlicker();
+    vi.advanceTimersByTime(80);
+
+    expect(ownerDocument.getElementById("drip-antiflicker")).toBeNull();
+    expect(ownerDocument.documentElement.classList.contains("drip-af")).toBe(false);
+    expect(ownerDocument.documentElement.classList.contains("drip-af-reveal")).toBe(false);
+    expect(replacementDocument.documentElement.className).toBe("");
+  });
+});

package/src/antiflicker.ts

@@ -0,0 +1,147 @@
+import type { AntiFlickerMode } from "./types";
+
+const STYLE_ID = "drip-antiflicker";
+const DEFAULT_TIMEOUT_MS = 1200;
+const PROGRESSIVE_REVEAL_RATIO = 0.8; // Start progressive reveal at 80% of timeout
+const REVEAL_CLEANUP_MS = 80;
+
+const FULL_PAGE_CSS =
+  "html.drip-af { opacity: 0 !important; }" +
+  " html.drip-af-reveal { transition: opacity 0.05s ease-in !important; }";
+
+let progressiveRevealTimer: ReturnType<typeof setTimeout> | null = null;
+let hardRevealTimer: ReturnType<typeof setTimeout> | null = null;
+let cleanupTimer: ReturnType<typeof setTimeout> | null = null;
+let antiFlickerOwnerDocument: Document | null = null;
+
+function activeDocument(): Document | null {
+  if (typeof document === "undefined" || !document.documentElement) return null;
+  return document;
+}
+
+function clearTimers(): void {
+  if (progressiveRevealTimer !== null) {
+    clearTimeout(progressiveRevealTimer);
+    progressiveRevealTimer = null;
+  }
+  if (hardRevealTimer !== null) {
+    clearTimeout(hardRevealTimer);
+    hardRevealTimer = null;
+  }
+  if (cleanupTimer !== null) {
+    clearTimeout(cleanupTimer);
+    cleanupTimer = null;
+  }
+}
+
+function cleanupDocumentImmediately(ownerDocument: Document): void {
+  ownerDocument.documentElement?.classList.remove("drip-af", "drip-af-reveal");
+  ownerDocument.getElementById(STYLE_ID)?.remove();
+  if (antiFlickerOwnerDocument === ownerDocument) antiFlickerOwnerDocument = null;
+}
+
+export function resolveAntiFlickerCss(
+  mode: AntiFlickerMode = "scoped",
+  scopedSelectors?: string[],
+  customCss?: string,
+): string | null {
+  if (mode === "off") return null;
+
+  if (mode === "custom") {
+    return customCss && customCss.trim() ? customCss : null;
+  }
+
+  if (mode === "scoped") {
+    if (!scopedSelectors || scopedSelectors.length === 0) {
+      return null;
+    }
+
+    const selectorList = scopedSelectors.join(",");
+    return (
+      selectorList + " { visibility: hidden !important; }" +
+      " .drip-af-reveal " + selectorList + " { visibility: visible !important; transition: visibility 0s, opacity 0.05s ease-in !important; }"
+    );
+  }
+
+  return FULL_PAGE_CSS;
+}
+
+/**
+ * Apply anti-flicker hiding based on mode.
+ * - "scoped": only hides elements matching provided selectors (preferred).
+ * - "full": hides entire page with opacity:0 (legacy).
+ * - "off": no-op.
+ * Scoped mode is a no-op when no selectors are available.
+ *
+ * Progressive reveal: at 80% of timeout, begins a CSS transition to fade
+ * content in gradually rather than a sudden flash at timeout expiry.
+ */
+export function applyAntiFlicker(
+  mode: AntiFlickerMode = "scoped",
+  timeoutMs: number = DEFAULT_TIMEOUT_MS,
+  scopedSelectors?: string[],
+  customCss?: string,
+): void {
+  const ownerDocument = activeDocument();
+  if (!ownerDocument) return;
+  const existingStyle = ownerDocument.getElementById(STYLE_ID);
+  // A live barrier owns its current timers. During the short reveal cleanup
+  // window, however, network config or re-init may need to arm a fresh barrier
+  // immediately against the same document.
+  if (existingStyle && cleanupTimer === null) return;
+  const css = resolveAntiFlickerCss(mode, scopedSelectors, customCss);
+  if (!css) return;
+  clearTimers();
+  if (antiFlickerOwnerDocument && antiFlickerOwnerDocument !== ownerDocument) {
+    cleanupDocumentImmediately(antiFlickerOwnerDocument);
+  }
+  antiFlickerOwnerDocument = ownerDocument;
+
+  const root = ownerDocument.documentElement;
+  const style = existingStyle ?? ownerDocument.createElement("style");
+  style.id = STYLE_ID;
+
+  style.textContent = css;
+  root.classList.remove("drip-af-reveal");
+  if (mode === "full") {
+    root.classList.add("drip-af");
+  } else {
+    root.classList.remove("drip-af");
+  }
+
+  if (!style.isConnected) (ownerDocument.head || root).appendChild(style);
+
+  // Progressive reveal: at 80% of timeout, begin transition before hard timeout
+  const progressiveMs = Math.round(timeoutMs * PROGRESSIVE_REVEAL_RATIO);
+  progressiveRevealTimer = setTimeout(() => {
+    progressiveRevealTimer = null;
+    // Add reveal class to start transition (content fades in over 50ms)
+    root.classList.add("drip-af-reveal");
+  }, progressiveMs);
+
+  // Hard timeout: fully remove anti-flicker
+  hardRevealTimer = setTimeout(() => {
+    hardRevealTimer = null;
+    removeAntiFlickerFrom(ownerDocument);
+  }, timeoutMs);
+}
+
+function removeAntiFlickerFrom(ownerDocument: Document | null): void {
+  clearTimers();
+  if (!ownerDocument?.documentElement) return;
+  const root = ownerDocument.documentElement;
+  root.classList.remove("drip-af");
+  root.classList.add("drip-af-reveal");
+  const el = ownerDocument.getElementById(STYLE_ID);
+  // Remove style (if present) and class after transition completes
+  cleanupTimer = setTimeout(() => {
+    cleanupTimer = null;
+    el?.remove();
+    root.classList.remove("drip-af-reveal");
+    if (antiFlickerOwnerDocument === ownerDocument) antiFlickerOwnerDocument = null;
+  }, REVEAL_CLEANUP_MS);
+}
+
+export function removeAntiFlicker(): void {
+  removeAntiFlickerFrom(antiFlickerOwnerDocument ?? activeDocument());
+}

package/src/assignment-store.test.ts

@@ -0,0 +1,171 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { Experiment } from "./types";
+
+function makeStorage() {
+  const map = new Map<string, string>();
+  return {
+    getItem: (key: string) => (map.has(key) ? map.get(key)! : null),
+    key: (index: number) => Array.from(map.keys())[index] ?? null,
+    removeItem: (key: string) => {
+      map.delete(key);
+    },
+    setItem: (key: string, value: string) => {
+      map.set(key, value);
+    },
+    get length() {
+      return map.size;
+    },
+  };
+}
+
+function experiment(
+  id: string,
+  weights: [number, number],
+  epoch = 1,
+): Experiment {
+  return {
+    id,
+    status: "running",
+    trafficAllocation: 1,
+    assignmentEpoch: epoch,
+    variations: [
+      { id: `${id}_control`, weight: weights[0], mutations: [], isControl: true },
+      { id: `${id}_variant`, weight: weights[1], mutations: [] },
+    ],
+  };
+}
+
+describe("persisted assignment store", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    (globalThis as any).localStorage = makeStorage();
+    (globalThis as any).document = { cookie: "" };
+    (globalThis as any).location = {
+      href: "https://store.test/products/a",
+      origin: "https://store.test",
+      pathname: "/products/a",
+      search: "",
+    };
+  });
+
+  it("reuses a valid persisted assignment even when weights would now choose another arm", async () => {
+    const { evaluate } = await import("./index");
+    const first = evaluate([experiment("exp_1", [1, 0])], {
+      url: "https://store.test/products/a",
+      userId: "visitor-1",
+    });
+    expect(first[0]?.variationId).toBe("exp_1_control");
+
+    const second = evaluate([experiment("exp_1", [0, 1])], {
+      url: "https://store.test/products/a",
+      userId: "visitor-1",
+    });
+    expect(second[0]?.variationId).toBe("exp_1_control");
+    expect(second[0]?.assignmentEpoch).toBe(1);
+  });
+
+  it("computes and persists a fresh assignment after an epoch bump", async () => {
+    const { evaluate } = await import("./index");
+    evaluate([experiment("exp_1", [1, 0], 1)], {
+      url: "https://store.test/products/a",
+      userId: "visitor-1",
+    });
+
+    const bumped = evaluate([experiment("exp_1", [0, 1], 2)], {
+      url: "https://store.test/products/a",
+      userId: "visitor-1",
+    });
+
+    expect(bumped[0]?.variationId).toBe("exp_1_variant");
+    expect(bumped[0]?.assignmentEpoch).toBe(2);
+    expect(JSON.parse(localStorage.getItem("drip_assignments_v1") ?? "{}")).toEqual({
+      exp_1: ["exp_1_variant", 2, expect.any(Number)],
+    });
+  });
+
+  it("persists parallel experiment assignments independently", async () => {
+    const { evaluate } = await import("./index");
+    const assignments = evaluate(
+      [experiment("exp_1", [1, 0]), experiment("exp_2", [0, 1])],
+      {
+        url: "https://store.test/products/a",
+        userId: "visitor-1",
+      },
+    );
+
+    expect(assignments.map((assignment) => assignment.variationId)).toEqual([
+      "exp_1_control",
+      "exp_2_variant",
+    ]);
+    expect(JSON.parse(localStorage.getItem("drip_assignments_v1") ?? "{}")).toMatchObject({
+      exp_1: ["exp_1_control", 1, expect.any(Number)],
+      exp_2: ["exp_2_variant", 1, expect.any(Number)],
+    });
+  });
+
+  it("does not create a new persistent assignment while off target", async () => {
+    const { evaluate } = await import("./index");
+    const offTarget = experiment("exp_1", [1, 0]);
+    offTarget.targeting = {
+      lifecycle: { mode: "persistent" },
+      url: [{ type: "simple", pattern: "/collections/*" }],
+    };
+
+    expect(evaluate([offTarget], {
+      url: "https://store.test/products/a",
+      userId: "visitor-1",
+    })).toEqual([]);
+    expect(localStorage.getItem("drip_assignments_v1")).toBeNull();
+  });
+
+  it("does not restore when non-page audience targeting is no longer eligible", async () => {
+    localStorage.setItem(
+      "drip_assignments_v1",
+      JSON.stringify({ exp_1: ["exp_1_control", 1, 123] }),
+    );
+    const { evaluate } = await import("./index");
+    const offTarget = experiment("exp_1", [1, 0]);
+    offTarget.targeting = {
+      attributes: [{ attribute: "customer_tier", operator: "equals", value: "vip" }],
+      lifecycle: { mode: "persistent" },
+      url: [{ type: "simple", pattern: "/collections/*" }],
+    };
+
+    expect(evaluate([offTarget], {
+      attributes: { customer_tier: "standard" },
+      url: "https://store.test/products/a",
+      userId: "visitor-1",
+    })).toEqual([]);
+  });
+
+  it("does not resurrect a persisted assignment that loses its exclusion group", async () => {
+    localStorage.setItem(
+      "drip_assignments_v1",
+      JSON.stringify({ exp_1: ["exp_1_control", 1, 123] }),
+    );
+    const { evaluate } = await import("./index");
+    const restored = experiment("exp_1", [1, 0]);
+    restored.trafficAllocation = 0;
+    restored.targeting = {
+      lifecycle: { mode: "persistent" },
+      url: [{ type: "simple", pattern: "/collections/*" }],
+    };
+    const winner = experiment("exp_2", [1, 0]);
+
+    const assignments = evaluate([restored, winner], {
+      exclusionGroups: [
+        {
+          id: "group_1",
+          members: [
+            { experimentId: "exp_1", share: 0 },
+            { experimentId: "exp_2", share: 1 },
+          ],
+        },
+      ],
+      url: "https://store.test/products/a",
+      userId: "visitor-1",
+    });
+
+    expect(assignments.map((assignment) => assignment.experimentId)).toEqual(["exp_2"]);
+  });
+});