@drip-apex/sdk 0.1.0 → 0.3.0

package/src/init-test-helpers.ts

@@ -0,0 +1,287 @@
+import { afterEach, beforeEach, vi } from "vitest";
+import type { Assignment, Experiment } from "./types";
+
+// Hermeticity: weekday tests pin the most recent UTC Monday at 12:00 instead
+// of a literal calendar date.
+export const RECENT_MONDAY_NOON = (() => {
+  const d = new Date();
+  d.setUTCDate(d.getUTCDate() - ((d.getUTCDay() + 6) % 7));
+  d.setUTCHours(12, 0, 0, 0);
+  return d;
+})();
+
+export 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; },
+  };
+}
+
+export function makeClassList() {
+  const values = new Set<string>();
+  return {
+    add: (...tokens: string[]) => { tokens.forEach((token) => values.add(token)); },
+    remove: (...tokens: string[]) => { tokens.forEach((token) => values.delete(token)); },
+    contains: (token: string) => values.has(token),
+  };
+}
+
+export function appendedAntiFlickerStyle(): { id: string; remove: ReturnType<typeof vi.fn>; textContent: string } | undefined {
+  const calls = vi.mocked((globalThis as any).document.head.appendChild).mock.calls;
+  for (let index = calls.length - 1; index >= 0; index -= 1) {
+    const element = calls[index]?.[0];
+    if (element.id === "drip-antiflicker") return element;
+  }
+  return undefined;
+}
+
+export function readCookieValue(name: string): string | null {
+  const cookie = String((globalThis as any).document?.cookie ?? "");
+  const match = cookie.match(new RegExp(`(?:^|;\\s*)${name}=([^;]*)`));
+  return match?.[1] || null;
+}
+
+export function readDecodedDripContext(): string | null {
+  const value = readCookieValue("drip_ctx");
+  return value == null ? null : decodeURIComponent(value);
+}
+
+export function installCookieJar(initial = "") {
+  const cookies = new Map<string, string>();
+  for (const pair of initial.split(";")) {
+    const separator = pair.indexOf("=");
+    if (separator < 0) continue;
+    const name = pair.slice(0, separator).trim();
+    if (name) cookies.set(name, pair.slice(separator + 1).trim());
+  }
+  const writes: string[] = [];
+  Object.defineProperty((globalThis as any).document, "cookie", {
+    configurable: true,
+    get: () => Array.from(cookies, ([name, value]) => `${name}=${value}`).join("; "),
+    set: (value: string) => {
+      writes.push(value);
+      const [pair, ...attributes] = value.split(";");
+      const separator = pair.indexOf("=");
+      if (separator < 0) return;
+      const name = pair.slice(0, separator).trim();
+      const cookieValue = pair.slice(separator + 1).trim();
+      if (attributes.some((attribute) => attribute.trim().toLowerCase() === "max-age=0")) {
+        cookies.delete(name);
+      } else {
+        cookies.set(name, cookieValue);
+      }
+    },
+  });
+  return writes;
+}
+
+export function installMutationObserverStub() {
+  const observe = vi.fn();
+  const disconnect = vi.fn();
+  const takeRecords = vi.fn(() => []);
+  (globalThis as any).MutationObserver = class MutationObserver {
+    observe = observe;
+    disconnect = disconnect;
+    takeRecords = takeRecords;
+    constructor(_callback: MutationCallback) {}
+  };
+  return { observe, disconnect, takeRecords };
+}
+
+export async function flushDynamicImports() {
+  await vi.dynamicImportSettled();
+  await Promise.resolve();
+  await Promise.resolve();
+  await Promise.resolve();
+}
+
+export function configPayloadHash(experiments: unknown[]): string {
+  return JSON.stringify({
+    experiments,
+    exclusionGroups: [],
+    profile: null,
+    runtime: null,
+    signals: [],
+    commerce: null,
+    holdout: [false, 0, null],
+  });
+}
+
+export function decodeTestHandover(token: string): Record<string, unknown> {
+  const payload = token.split(".")[0];
+  const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+  return JSON.parse(atob(normalized + "=".repeat((4 - normalized.length % 4) % 4)));
+}
+
+export function verifiedHandoverResponse(
+  input: RequestInfo | URL,
+  init: RequestInit | undefined,
+  shopId = "shop_123",
+): Response | null {
+  if (!String(input).endsWith("/v1/handover/verify")) return null;
+  const body = JSON.parse(String(init?.body)) as { verifyToken: string };
+  return new Response(JSON.stringify({
+    payload: { ...decodeTestHandover(body.verifyToken), shop: shopId },
+  }), { status: 200 });
+}
+export let windowListeners: Record<string, Array<() => void>>;
+export let documentListeners: Record<string, Array<(...args: any[]) => void>>;
+export const originalWindow = (globalThis as any).window;
+export const originalDocument = (globalThis as any).document;
+export const originalHistory = (globalThis as any).history;
+export const originalLocation = (globalThis as any).location;
+export const originalNavigator = Object.getOwnPropertyDescriptor(globalThis, "navigator");
+export const originalRequestIdleCallback = Object.getOwnPropertyDescriptor(globalThis, "requestIdleCallback");
+export const originalCancelIdleCallback = Object.getOwnPropertyDescriptor(globalThis, "cancelIdleCallback");
+export const originalLocalStorage = (globalThis as any).localStorage;
+export const originalSessionStorage = (globalThis as any).sessionStorage;
+export const originalCustomEvent = (globalThis as any).CustomEvent;
+export const originalMutationObserver = (globalThis as any).MutationObserver;
+export const originalElement = (globalThis as any).Element;
+export const originalNode = (globalThis as any).Node;
+export const originalFetch = globalThis.fetch;
+
+export function registerInitTestLifecycle() {
+
+
+    beforeEach(() => {
+      vi.resetModules();
+      vi.useFakeTimers();
+      vi.spyOn(Math, "random").mockReturnValue(0.99);
+      delete (globalThis as any).__drip;
+      delete (globalThis as any).__dripPredecided;
+      delete (globalThis as any).__dripReplayRecorder;
+      delete (globalThis as any).Shopify;
+      delete (globalThis as any).hj;
+      delete (globalThis as any).adbq;
+      delete (globalThis as any).posthog;
+      delete (globalThis as any).OnetrustActiveGroups;
+      delete (globalThis as any).UC_UI;
+      delete (globalThis as any).Cookiebot;
+      delete (globalThis as any).CCM;
+      delete (globalThis as any).Pandectes;
+      delete (globalThis as any).CookieScript;
+      delete (globalThis as any).dr_cookiebanner_options;
+      windowListeners = {};
+      documentListeners = {};
+
+      const windowStub: Record<string, any> = {
+        addEventListener: vi.fn((type: string, handler: () => void) => {
+          windowListeners[type] = windowListeners[type] ?? [];
+          windowListeners[type].push(handler);
+        }),
+        clearInterval: (id: number) => clearInterval(id),
+        clearTimeout: (id: number) => clearTimeout(id),
+        innerHeight: 800,
+        removeEventListener: vi.fn((type: string, handler: () => void) => {
+          windowListeners[type] = (windowListeners[type] ?? []).filter((listener) => listener !== handler);
+        }),
+        setInterval: (fn: TimerHandler, ms?: number) => setInterval(fn, ms),
+        setTimeout: (fn: TimerHandler, ms?: number) => setTimeout(fn, ms),
+        Shopify: undefined,
+      };
+      windowStub.self = windowStub;
+      windowStub.top = windowStub;
+
+      (globalThis as any).window = windowStub;
+      (globalThis as any).location = {
+        hash: "",
+        hostname: "plain.test",
+        href: "https://plain.test/",
+        origin: "https://plain.test",
+        pathname: "/",
+        reload: vi.fn(),
+        search: "",
+      };
+      (globalThis as any).history = {
+        pushState: vi.fn(),
+        replaceState: vi.fn(),
+      };
+      (globalThis as any).document = {
+        addEventListener: vi.fn((type: string, handler: () => void) => {
+          documentListeners[type] = documentListeners[type] ?? [];
+          documentListeners[type].push(handler);
+        }),
+        body: { scrollHeight: 1200 },
+        createElement: vi.fn((tag: string) => ({
+          id: "",
+          remove: vi.fn(),
+          textContent: "",
+          tagName: tag.toUpperCase(),
+        })),
+        dispatchEvent: vi.fn(),
+        documentElement: {
+          classList: makeClassList(),
+          scrollHeight: 1200,
+        },
+        getElementById: vi.fn(() => null),
+        head: { appendChild: vi.fn() },
+        querySelector: vi.fn(() => null),
+        querySelectorAll: vi.fn(() => []),
+        referrer: "",
+        removeEventListener: vi.fn(),
+        title: "Plain probe",
+      };
+      Object.defineProperty(globalThis, "navigator", {
+        configurable: true,
+        value: { userAgent: "Mozilla/5.0", doNotTrack: "0", sendBeacon: vi.fn(() => true) },
+      });
+      (globalThis as any).localStorage = makeStorage();
+      (globalThis as any).sessionStorage = makeStorage();
+      (globalThis as any).CustomEvent = class CustomEvent {
+        type: string;
+        constructor(type: string) {
+          this.type = type;
+        }
+      };
+      globalThis.fetch = vi.fn(async () => new Response("ok", { status: 202 })) as any;
+    });
+
+
+    afterEach(async () => {
+      await vi.dynamicImportSettled();
+      vi.doUnmock("./shopify-cart");
+      vi.useRealTimers();
+      vi.restoreAllMocks();
+      delete (globalThis as any).__drip;
+      delete (globalThis as any).__dripReplayRecorder;
+      delete (globalThis as any).Shopify;
+      delete (globalThis as any).hj;
+      delete (globalThis as any).adbq;
+      delete (globalThis as any).posthog;
+      delete (globalThis as any).OnetrustActiveGroups;
+      delete (globalThis as any).UC_UI;
+      delete (globalThis as any).Cookiebot;
+      delete (globalThis as any).CCM;
+      delete (globalThis as any).Pandectes;
+      delete (globalThis as any).dr_cookiebanner_options;
+      (globalThis as any).window = originalWindow;
+      (globalThis as any).document = originalDocument;
+      (globalThis as any).history = originalHistory;
+      (globalThis as any).location = originalLocation;
+      if (originalNavigator) {
+        Object.defineProperty(globalThis, "navigator", originalNavigator);
+      }
+      if (originalRequestIdleCallback) {
+        Object.defineProperty(globalThis, "requestIdleCallback", originalRequestIdleCallback);
+      } else {
+        delete (globalThis as any).requestIdleCallback;
+      }
+      if (originalCancelIdleCallback) {
+        Object.defineProperty(globalThis, "cancelIdleCallback", originalCancelIdleCallback);
+      } else {
+        delete (globalThis as any).cancelIdleCallback;
+      }
+      (globalThis as any).localStorage = originalLocalStorage;
+      (globalThis as any).sessionStorage = originalSessionStorage;
+      (globalThis as any).CustomEvent = originalCustomEvent;
+      (globalThis as any).MutationObserver = originalMutationObserver;
+      (globalThis as any).Element = originalElement;
+      (globalThis as any).Node = originalNode;
+      globalThis.fetch = originalFetch;
+    });
+}

package/src/inline-bootstrap.test.ts

@@ -0,0 +1,184 @@
+import { gzipSync } from "node:zlib";
+import { beforeEach, describe, expect, it } from "vitest";
+import { INLINE_BOOTSTRAP_CODE } from "../../worker/src/_inline-bootstrap";
+import { writePersistedAssignments } from "./assignment-store";
+import { decideAssignments } from "./decide-assignments";
+import { browserGroupStickyStore, resolveExclusionGroups } from "./exclusion-groups";
+import { hashToFloat } from "./hash";
+import type { Experiment } from "./types";
+
+const variation = (id: string, weight: number) => ({ id, name: id, weight, mutations: [] });
+const experiment = (id: string, weights = [0.5, 0.5], assignmentEpoch = 1): Experiment => ({
+  id, name: id, status: "running", assignmentEpoch,
+  variations: weights.map((weight, index) => variation(`${id}_${index}`, weight)),
+});
+
+let storageReads = 0;
+let values: Map<string, string>;
+let cookies: Map<string, string>;
+
+function bootstrap(input: Record<string, unknown>) {
+  return globalThis.__dripComputePredecided({
+    experiments: [], configRevision: 7, url: "https://shop.test/products/a",
+    provisionalVisitorId: "provisional", ...input,
+  });
+}
+
+describe("generated inline bootstrap parity", () => {
+  beforeEach(() => {
+    values = new Map();
+    cookies = new Map();
+    storageReads = 0;
+    Object.defineProperty(globalThis, "localStorage", { configurable: true, value: {
+      clear: () => values.clear(),
+      getItem: (key: string) => { storageReads += 1; return values.get(key) ?? null; },
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+    }});
+    Object.defineProperty(globalThis, "document", { configurable: true, value: {
+      get cookie() { return [...cookies].map(([key, value]) => `${key}=${value}`).join("; "); },
+      set cookie(raw: string) {
+        const [pair] = raw.split(";");
+        const index = pair.indexOf("=");
+        const key = pair.slice(0, index);
+        const value = pair.slice(index + 1);
+        if (/Max-Age=0/i.test(raw)) cookies.delete(key); else cookies.set(key, value);
+      },
+    }});
+    Object.defineProperty(globalThis, "navigator", { configurable: true, value: { doNotTrack: "0" } });
+    (0, eval)(INLINE_BOOTSTRAP_CODE);
+  });
+
+  it("round-trips production assignment writes across sticky and epoch behavior", () => {
+    writePersistedAssignments({
+      sticky: { variationId: "sticky_1", epoch: 2, assignedAt: 10 },
+      epoch: { variationId: "epoch_1", epoch: 2, assignedAt: 11 },
+    });
+    values.set("drip_uid", "returning-visitor");
+    const experiments = [experiment("sticky", [1, 0], 2), experiment("epoch", [1, 0], 3)];
+    const actual = bootstrap({ experiments });
+    expect(actual.visitorId).toBe("returning-visitor");
+    expect(actual.decision).toEqual(decideAssignments({
+      experiments, visitorId: "returning-visitor", now: expect.any(Number),
+      url: "https://shop.test/products/a",
+      storedAssignments: {
+        sticky: { variationId: "sticky_1", epoch: 2, assignedAt: 10 },
+        epoch: { variationId: "epoch_1", epoch: 2, assignedAt: 11 },
+      },
+    }).map((item) => [item.experimentId, item.variationId]));
+    expect(actual.decision.find((item: any) => item[0] === "sticky")?.[1]).toBe("sticky_1");
+    expect(actual.decision.find((item: any) => item[0] === "epoch")?.[1]).toBe("epoch_0");
+  });
+
+  it("declines custom-hash predecisions while preserving default-hash decisions", () => {
+    const visitorId = "visitor-2";
+    const attributeValue = "attribute-2";
+    const customHashExperiment = {
+      ...experiment("hash-attribute"),
+      trafficAllocation: 0.5,
+      hashAttribute: "plan",
+    };
+    const defaultHashExperiment = {
+      ...experiment("default-0"),
+      trafficAllocation: 0.5,
+    };
+    expect(hashToFloat(customHashExperiment.id, visitorId)).toBeLessThan(0.5);
+    expect(hashToFloat(customHashExperiment.id, attributeValue)).toBeGreaterThanOrEqual(0.5);
+    expect(hashToFloat(defaultHashExperiment.id, visitorId)).toBeLessThan(0.5);
+
+    values.set("drip_uid", visitorId);
+    const actual = bootstrap({ experiments: [customHashExperiment, defaultHashExperiment] });
+    expect(actual.decision.map((item: any) => item[0])).toEqual(["default-0"]);
+  });
+
+  it("round-trips the production exclusion-group write and resolves after targeting", () => {
+    browserGroupStickyStore.write("group", { experimentId: "ineligible", epoch: 4 });
+    values.set("drip_uid", "returning-visitor");
+    const experiments = [experiment("ineligible"), experiment("eligible")];
+    const predecided = bootstrap({ experiments });
+    expect(predecided.decision.map((item: any) => item[0])).toEqual(["ineligible", "eligible"]);
+    expect(predecided.groups).toEqual({ group: ["ineligible", 4] });
+
+    const allAssignments = decideAssignments({ experiments, visitorId: predecided.visitorId, now: 1, url: "https://shop.test/products/a" });
+    const sticky = resolveExclusionGroups(allAssignments, [{
+      id: "group", epoch: 4,
+      members: [{ experimentId: "ineligible", share: 1 }, { experimentId: "eligible", share: 1 }],
+    }], {
+      userId: predecided.visitorId,
+      store: {
+        read: (id) => {
+          const value = predecided.groups[id];
+          return value ? { experimentId: value[0], epoch: value[1] } : null;
+        },
+        write: () => undefined,
+      },
+    });
+    expect(sticky.assignments.map((item) => item.experimentId)).toEqual(["ineligible"]);
+
+    // This is the SDK ordering: page targeting removes the prior winner first,
+    // then exclusion resolution sees the eligible subset and serves its member.
+    const eligibleOnly = decideAssignments({ experiments: [experiments[1]], visitorId: predecided.visitorId, now: 1, url: "https://shop.test/products/a" });
+    const resolved = resolveExclusionGroups(eligibleOnly, [{
+      id: "group", epoch: 4,
+      members: [{ experimentId: "ineligible", share: 1 }, { experimentId: "eligible", share: 1 }],
+    }], { userId: predecided.visitorId, persist: false });
+    expect(resolved.assignments.map((item) => item.experimentId)).toEqual(["eligible"]);
+  });
+
+  it.each([
+    ["required without consent", { consentModeEnabled: true }],
+    ["explicitly denied", { requireConsent: true, hasConsent: false }],
+    ["DNT", { respectDoNotTrack: true, dnt: "1" }],
+  ])("uses only the provisional id and reads no persistent stores when %s", (_label, options) => {
+    values.set("drip_uid", "persistent-id");
+    values.set("drip_assignments_v1", JSON.stringify({ exp: ["exp_1", 1, 1] }));
+    values.set("drip_xgroups_v1", JSON.stringify({ group: ["exp", 1] }));
+    Object.defineProperty(globalThis, "navigator", { configurable: true, value: { doNotTrack: options.dnt ?? "0" } });
+    storageReads = 0;
+    const result = bootstrap({ experiments: [experiment("exp")], ...options });
+    expect(result.visitorId).toBe("provisional");
+    expect(result.groups).toEqual({});
+    expect(storageReads).toBe(0);
+  });
+
+  it("allows the real consent cookie before reading persistent stores", () => {
+    cookies.set("drip_consent", "1");
+    values.set("drip_uid", "consented-id");
+    const result = bootstrap({ consentModeEnabled: true });
+    expect(result.visitorId).toBe("consented-id");
+    expect(storageReads).toBeGreaterThan(0);
+  });
+
+  it("fails closed for CookieScript when only a residual consent cookie remains", () => {
+    cookies.set("drip_consent", "1");
+    values.set("drip_uid", "stale-consented-id");
+    storageReads = 0;
+    const result = bootstrap({ consentModeEnabled: true, consentProvider: "cookiescript" });
+    expect(result.visitorId).toBe("provisional");
+    expect(result.groups).toEqual({});
+    expect(storageReads).toBe(0);
+  });
+
+  it("uses the stored visitor id when CookieScript consent is available from its cookie", () => {
+    cookies.set("CookieScriptConsent", encodeURIComponent(JSON.stringify({
+      action: "accept",
+      categories: JSON.stringify(["performance"]),
+    })));
+    values.set("drip_uid", "cookiescript-consented-id");
+    const result = bootstrap({
+      consentModeEnabled: true,
+      consentProvider: "cookiescript",
+      consentRequiredGroup: "analytics",
+    });
+    expect(result.visitorId).toBe("cookiescript-consented-id");
+    expect(result.consentAllowed).toBe(true);
+  });
+
+  it("stays within the 2KB gzip inline budget", () => {
+    expect(gzipSync(INLINE_BOOTSTRAP_CODE).byteLength).toBeLessThanOrEqual(2048);
+  });
+});
+
+declare global {
+  var __dripComputePredecided: (input: any) => any;
+}

package/src/inline-bootstrap.ts

@@ -0,0 +1,73 @@
+import { evaluateSynchronousConsentForProvider, readConsentCookie, readCookieScriptConsent, STORAGE_ALLOWED } from "./consent-evaluation";
+import { decodePersistedAssignments, decodePersistedGroupSelections, type CompactGroupSelections } from "./persistence-decoders";
+import { decideVariationIdsPregated } from "./decide-assignments";
+import type { Experiment } from "./types";
+
+export type PredecidedAssignments = {
+  decision: Array<[experimentId: string, variationId: string]>;
+  configRevision: number;
+  visitorId: string;
+  groups: CompactGroupSelections;
+  consentAllowed: boolean;
+};
+
+function local(name: string): string {
+  try { return localStorage.getItem(name) || ""; } catch { return ""; }
+}
+
+function dnt(): string {
+  const nav = globalThis.navigator as Navigator & { msDoNotTrack?: string };
+  return nav.doNotTrack || nav.msDoNotTrack || (globalThis as typeof globalThis & { doNotTrack?: string }).doNotTrack || "";
+}
+
+/** Synchronous, read-only bootstrap entrypoint. Bundled into the Worker snippet. */
+export function computePredecided(input: {
+  experiments: Experiment[];
+  holdout?: { enabled?: boolean; percentage?: number };
+  configRevision: number;
+  url: string;
+  provisionalVisitorId: string;
+  requireConsent?: boolean;
+  hasConsent?: boolean;
+  consentModeEnabled?: boolean;
+  consentProvider?: "custom" | "onetrust" | "usercentrics" | "cookiebot" | "ccm19" | "pandectes" | "cookiescript" | "borlabs";
+  consentRequiredGroup?: string;
+  respectDoNotTrack?: boolean;
+}): PredecidedAssignments {
+  // Consent and DNT are evaluated before any identity or assignment store read.
+  const storageAllowed = Boolean(evaluateSynchronousConsentForProvider({
+    requireConsent: input.requireConsent,
+    hasConsent: input.hasConsent,
+    consentModeEnabled: input.consentModeEnabled,
+    configuredConsentGranted: input.consentProvider === "cookiescript"
+      ? readCookieScriptConsent(input.consentRequiredGroup)
+      : null,
+    provider: input.consentProvider,
+    consentCookieGranted: readConsentCookie("drip_consent") === "1",
+    respectDoNotTrack: input.respectDoNotTrack,
+    doNotTrackValue: dnt(),
+  }) & STORAGE_ALLOWED);
+  const visitorId = storageAllowed
+    ? local("drip_uid") || readConsentCookie("drip_uid") || input.provisionalVisitorId
+    : input.provisionalVisitorId;
+  const storedAssignments = storageAllowed
+    ? decodePersistedAssignments(local("drip_assignments_v1"), readConsentCookie("drip_assignments_v1"))
+    : {};
+  const storedGroupSelections = storageAllowed
+    ? decodePersistedGroupSelections(local("drip_xgroups_v1"), readConsentCookie("drip_xgroups_v1"))
+    : {};
+  return {
+    decision: decideVariationIdsPregated({
+      experiments: input.experiments.filter((experiment) => !experiment.hashAttribute),
+      holdout: input.holdout,
+      visitorId,
+      storedAssignments,
+      now: Date.now(),
+      url: input.url,
+    }),
+    configRevision: input.configRevision,
+    visitorId,
+    groups: storedGroupSelections,
+    consentAllowed: storageAllowed,
+  };
+}

package/src/js.test.ts

@@ -1,6 +1,10 @@
 // @vitest-environment jsdom
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { loadExternalJs, setJsPolicy } from "./js";
+import {
+  loadExternalJs,
+  removeExternalJsForOwner,
+  setJsPolicy,
+} from "./js";
 
 describe("external JavaScript policy", () => {
   afterEach(() => {
@@ -23,4 +27,50 @@ describe("external JavaScript policy", () => {
     script.onload?.(new Event("load"));
     await loading;
   });
+
+  it("keeps shared external JavaScript until its final Page owner tears down", async () => {
+    const loading = loadExternalJs(
+      "https://example.com/shared.js",
+      "shared",
+      ["page-a"],
+    );
+    const script = document.querySelector("script") as HTMLScriptElement;
+    script.onload?.(new Event("load"));
+    await loading;
+
+    await loadExternalJs(
+      "https://example.com/shared.js",
+      "shared",
+      ["page-b"],
+    );
+    removeExternalJsForOwner("page-a");
+    expect(document.querySelector("script")).toBe(script);
+
+    removeExternalJsForOwner("page-b");
+    expect(document.querySelector("script")).toBeNull();
+  });
+
+  it("removes single-owner external JavaScript and reloads it on reactivation", async () => {
+    const firstLoading = loadExternalJs(
+      "https://example.com/page-a.js",
+      "page-a",
+      ["page-a"],
+    );
+    const firstScript = document.querySelector("script") as HTMLScriptElement;
+    firstScript.onload?.(new Event("load"));
+    await firstLoading;
+
+    removeExternalJsForOwner("page-a");
+    expect(document.querySelector("script")).toBeNull();
+
+    const secondLoading = loadExternalJs(
+      "https://example.com/page-a.js",
+      "page-a",
+      ["page-a"],
+    );
+    const secondScript = document.querySelector("script") as HTMLScriptElement;
+    expect(secondScript).not.toBe(firstScript);
+    secondScript.onload?.(new Event("load"));
+    await secondLoading;
+  });
 });