@drip-apex/sdk 0.1.0 → 0.3.0

package/src/redirect.ts

@@ -0,0 +1,572 @@
+import type { Assignment, Experiment } from "./types";
+import { persistAssignmentForExperiment } from "./assignment-store";
+import {
+  evalUrlRule,
+  matchUrlRules,
+  normalizeRuntimeUrlRules,
+} from "./targeting";
+import {
+  bucketingHandoverExpiresAtMs,
+  createBucketingHandoverPayload,
+  verifyBucketingHandoverToken,
+} from "./handover";
+import type { ExternalTrackingSettings } from "./types";
+
+export const REDIRECT_ASSIGNMENT_PARAM = "_apex_assignment";
+export const REDIRECT_ASSIGNMENT_PENDING_KEY = "drip_redirect_assignment_pending_v1";
+const MAX_PENDING_REDIRECT_CARRY_TTL_MS = 10 * 60 * 1000;
+type RedirectCarry = {
+  e: string;
+  v: string;
+  epoch: number;
+  handover: string;
+  exposureSent: boolean;
+  destinationPath?: string;
+};
+
+export type ParsedRedirectCarry = {
+  experimentId: string;
+  variationId: string;
+  assignmentEpoch: number;
+  handoverToken: string;
+  expiresAt: number;
+  exposureSent: boolean;
+  destinationPath?: string;
+};
+
+export type VerifiedRedirectCarry = ParsedRedirectCarry & {
+  visitorId: string;
+  attributionToken?: string;
+  attributionDestinationUrl?: string;
+  attributionIssuedAt?: number;
+};
+
+export type ImportedRedirectCarry = {
+  experiment: Experiment;
+  variationId: string;
+  visitorId: string;
+  exposureSent: boolean;
+  attributionToken?: string;
+  attributionDestinationUrl?: string;
+  attributionIssuedAt?: number;
+};
+
+const REDIRECT_ATTRIBUTION_COOKIE = "drip_ra";
+const REDIRECT_ATTRIBUTION_TTL_MS = 30_000;
+
+function canonicalRedirectAttributionDestination(value: string): string {
+  const parsed = new URL(value);
+  parsed.searchParams.delete(REDIRECT_ASSIGNMENT_PARAM);
+  const normalizedPathname = parsed.pathname.replace(/\/$/, "") || "/";
+  const pairs: Array<[string, string]> = [];
+  parsed.searchParams.forEach((queryValue, key) => pairs.push([key, queryValue]));
+  const compareCodePoints = (left: string, right: string): number =>
+    left < right ? -1 : left > right ? 1 : 0;
+  pairs.sort(([leftKey, leftValue], [rightKey, rightValue]) =>
+    compareCodePoints(leftKey, rightKey) || compareCodePoints(leftValue, rightValue));
+  const normalized = new URL(parsed.origin + normalizedPathname);
+  for (const [key, queryValue] of pairs) normalized.searchParams.append(key, queryValue);
+  return normalized.toString();
+}
+
+function normalizedEpoch(value: number | undefined): number {
+  return Math.max(1, Number.isSafeInteger(value) ? value! : 1);
+}
+
+const generatedRedirectCarryValues = new Set<string>();
+
+function normalizeRedirectPath(pathname: string): string {
+  return pathname.replace(/\/+$/, "") || "/";
+}
+
+export function hasGeneratedRedirectAssignmentCarry(destination: URL): boolean {
+  const carry = destination.searchParams.get(REDIRECT_ASSIGNMENT_PARAM);
+  return carry !== null && generatedRedirectCarryValues.has(carry);
+}
+
+export function buildRedirectDestination(currentHref: string, redirectUrl: string,
+  assignment: Pick<Assignment, "experimentId" | "variationId" | "assignmentEpoch">,
+  visitorId = "",
+  handoverSettings?: ExternalTrackingSettings,
+  includeAssignmentCarry = true,
+  exposureSent = false): URL | null {
+  try {
+    const current = new URL(currentHref);
+    const destination = new URL(redirectUrl, current);
+    if (!/https?:/.test(destination.protocol)) return null;
+    const destinationKeys = new Set<string>();
+    destination.searchParams.forEach((_value, key) => destinationKeys.add(key));
+    current.searchParams.forEach((value, key) => {
+      if (!destinationKeys.has(key) && key !== REDIRECT_ASSIGNMENT_PARAM) destination.searchParams.append(key, value);
+    });
+    if (!destination.hash && current.hash) destination.hash = current.hash;
+    // Browser storage is origin-scoped, including protocol and port.
+    if (current.origin !== destination.origin && includeAssignmentCarry) {
+      if (destination.searchParams.has(REDIRECT_ASSIGNMENT_PARAM)) {
+        console.warn(
+          `[drip] Redirect destination already uses reserved ${REDIRECT_ASSIGNMENT_PARAM}; preserving the merchant-authored value and omitting assignment carry.`,
+        );
+        return destination;
+      }
+      const carry: RedirectCarry = {
+        e: assignment.experimentId,
+        v: assignment.variationId,
+        epoch: normalizedEpoch(assignment.assignmentEpoch),
+        handover: createBucketingHandoverPayload(visitorId, [assignment], handoverSettings),
+        exposureSent,
+        destinationPath: destination.pathname,
+      };
+      destination.searchParams.set(REDIRECT_ASSIGNMENT_PARAM, JSON.stringify(carry));
+      generatedRedirectCarryValues.add(JSON.stringify(carry));
+    }
+    return destination;
+  } catch { return null; }
+}
+
+export function markRedirectAssignmentCarryExposed(destination: URL): void {
+  try {
+    if (!hasGeneratedRedirectAssignmentCarry(destination)) return;
+    const value = destination.searchParams.get(REDIRECT_ASSIGNMENT_PARAM);
+    if (!value) return;
+    const carry = JSON.parse(value) as Partial<RedirectCarry>;
+    if (
+      typeof carry.e !== "string" ||
+      typeof carry.v !== "string" ||
+      !Number.isSafeInteger(carry.epoch) ||
+      typeof carry.handover !== "string"
+    ) return;
+    const nextValue = JSON.stringify({ ...carry, exposureSent: true });
+    generatedRedirectCarryValues.delete(value);
+    generatedRedirectCarryValues.add(nextValue);
+    destination.searchParams.set(REDIRECT_ASSIGNMENT_PARAM, nextValue);
+  } catch {}
+}
+
+export function finalizeRedirectAssignmentCarryHandover(
+  destination: URL,
+  verifiedToken: string | null,
+): void {
+  try {
+    if (!hasGeneratedRedirectAssignmentCarry(destination)) return;
+    const value = destination.searchParams.get(REDIRECT_ASSIGNMENT_PARAM);
+    if (!value || !verifiedToken) {
+      if (value) generatedRedirectCarryValues.delete(value);
+      destination.searchParams.delete(REDIRECT_ASSIGNMENT_PARAM);
+      return;
+    }
+    const carry = JSON.parse(value) as Partial<RedirectCarry>;
+    if (
+      typeof carry.e !== "string" ||
+      typeof carry.v !== "string" ||
+      !Number.isSafeInteger(carry.epoch) ||
+      typeof carry.handover !== "string"
+    ) {
+      generatedRedirectCarryValues.delete(value);
+      destination.searchParams.delete(REDIRECT_ASSIGNMENT_PARAM);
+      return;
+    }
+    const nextValue = JSON.stringify({ ...carry, handover: verifiedToken });
+    generatedRedirectCarryValues.delete(value);
+    generatedRedirectCarryValues.add(nextValue);
+    destination.searchParams.set(REDIRECT_ASSIGNMENT_PARAM, nextValue);
+  } catch {
+    const value = destination.searchParams.get(REDIRECT_ASSIGNMENT_PARAM);
+    if (value) generatedRedirectCarryValues.delete(value);
+    destination.searchParams.delete(REDIRECT_ASSIGNMENT_PARAM);
+  }
+}
+
+export function isRedirectLoop(currentHref: string, destination: URL): boolean {
+  try {
+    const current = new URL(currentHref);
+    current.searchParams.delete(REDIRECT_ASSIGNMENT_PARAM);
+    const compared = new URL(destination.href);
+    compared.searchParams.delete(REDIRECT_ASSIGNMENT_PARAM);
+    return current.origin === compared.origin && normalizeRedirectPath(current.pathname) === normalizeRedirectPath(compared.pathname) &&
+      current.search === compared.search && current.hash === compared.hash;
+  } catch { return true; }
+}
+
+function destinationMatchesSourceRules(
+  sourceHref: string,
+  destination: URL,
+  sourceRules: ReturnType<typeof normalizeRuntimeUrlRules>,
+  storeOrigin?: string | string[],
+): boolean {
+  try {
+    if (storeOrigin) {
+      return matchUrlRules(destination.href, sourceRules, storeOrigin);
+    }
+    const source = new URL(sourceHref);
+    if (source.origin === destination.origin) {
+      return matchUrlRules(destination.href, sourceRules);
+    }
+
+    const probe = new URL(destination.href);
+    probe.hostname = "apex-host-probe.invalid";
+    const matchingHostIncludes = sourceRules.filter(
+      (rule) =>
+        rule.include !== false &&
+        evalUrlRule(destination.href, rule) &&
+        !evalUrlRule(probe.href, rule),
+    );
+    const destinationRules = [
+      ...matchingHostIncludes,
+      ...sourceRules.filter((rule) => rule.include === false),
+    ];
+    return (
+      matchingHostIncludes.length > 0 &&
+      matchUrlRules(destination.href, destinationRules)
+    );
+  } catch {
+    return matchUrlRules(destination.href, sourceRules);
+  }
+}
+
+function redirectPlanForCandidate(
+  experiment: Experiment | undefined,
+  assignment: Assignment,
+  currentHref: string,
+  visitorId: string,
+  handoverSettings?: ExternalTrackingSettings,
+  includeAssignmentCarry = true,
+  storeOrigin?: string | string[],
+): { destination: URL; assignment: Assignment } | null {
+  if (
+    experiment?.experimentType !== "redirect" ||
+    assignment.isControl ||
+    !assignment.redirectUrl
+  ) {
+    return null;
+  }
+
+  const sourceRules = normalizeRuntimeUrlRules(experiment.targeting);
+  if (!sourceRules.some((rule) => rule.include !== false)) return null;
+  if (!matchUrlRules(currentHref, sourceRules, storeOrigin)) return null;
+
+  const destination = buildRedirectDestination(
+    currentHref,
+    assignment.redirectUrl,
+    assignment,
+    visitorId,
+    handoverSettings,
+    includeAssignmentCarry,
+    false,
+  );
+  if (
+    !destination ||
+    isRedirectLoop(currentHref, destination) ||
+    destinationMatchesSourceRules(
+      currentHref,
+      destination,
+      sourceRules,
+      storeOrigin,
+    )
+  ) {
+    return null;
+  }
+
+  return { destination, assignment };
+}
+
+export function filterUnsafeRedirectAssignments(
+  experiments: Experiment[],
+  assignments: Assignment[],
+  currentHref: string,
+  visitorId = "",
+  handoverSettings?: ExternalTrackingSettings,
+  preserveAssignment?: (assignment: Assignment) => boolean,
+  storeOrigin?: string | string[],
+): Assignment[] {
+  const experimentsById = new Map(
+    experiments.map((experiment) => [experiment.id, experiment]),
+  );
+  return assignments.filter((assignment) => {
+    if (preserveAssignment?.(assignment)) return true;
+    const experiment = experimentsById.get(assignment.experimentId);
+    if (experiment?.experimentType !== "redirect" || assignment.isControl) {
+      return true;
+    }
+    if (assignment.redirectUrl) {
+      const destination = buildRedirectDestination(
+        currentHref,
+        assignment.redirectUrl,
+        assignment,
+        visitorId,
+        handoverSettings,
+      );
+      // A sticky redirect treatment remains an active, exposable assignment
+      // after arrival. This classification must survive reloads, when the
+      // one-init carry-import marker no longer exists.
+      if (destination && isRedirectLoop(currentHref, destination)) return true;
+    }
+    return Boolean(
+      redirectPlanForCandidate(
+        experiment,
+        assignment,
+        currentHref,
+        visitorId,
+        handoverSettings,
+        true,
+        storeOrigin,
+      ),
+    );
+  });
+}
+
+export function redirectPlanForAssignment(experiments: Experiment[], assignments: Assignment[], currentHref: string,
+  visitorId = "", handoverSettings?: ExternalTrackingSettings,
+  includeAssignmentCarry = true,
+  storeOrigin?: string | string[]): { destination: URL; assignment: Assignment } | null {
+  for (const assignment of assignments) {
+    const experiment = experiments.find((candidate) => candidate.id === assignment.experimentId);
+    const plan = redirectPlanForCandidate(
+      experiment,
+      assignment,
+      currentHref,
+      visitorId,
+      handoverSettings,
+      includeAssignmentCarry,
+      storeOrigin,
+    );
+    if (plan) return plan;
+  }
+  return null;
+}
+
+export function redirectForAssignment(experiments: Experiment[], assignments: Assignment[], currentHref: string,
+  visitorId = "", handoverSettings?: ExternalTrackingSettings,
+  includeAssignmentCarry = true,
+  storeOrigin?: string | string[]): URL | null {
+  return redirectPlanForAssignment(
+    experiments,
+    assignments,
+    currentHref,
+    visitorId,
+    handoverSettings,
+    includeAssignmentCarry,
+    storeOrigin,
+  )?.destination ?? null;
+}
+
+export function parseRedirectAssignmentCarry(href: string): ParsedRedirectCarry | null {
+  try {
+    const current = new URL(href);
+    const value = current.searchParams.get(REDIRECT_ASSIGNMENT_PARAM);
+    if (!value) return null;
+    const carry = JSON.parse(value) as Partial<RedirectCarry>;
+    if (typeof carry.e !== "string" || typeof carry.v !== "string" || !Number.isSafeInteger(carry.epoch) || typeof carry.handover !== "string") return null;
+    if (carry.destinationPath !== undefined && (
+      typeof carry.destinationPath !== "string" ||
+      normalizeRedirectPath(carry.destinationPath) !== normalizeRedirectPath(current.pathname)
+    )) return null;
+    const expiresAt = bucketingHandoverExpiresAtMs(carry.handover);
+    if (
+      expiresAt === null ||
+      expiresAt <= Date.now()
+    ) return null;
+    return {
+      experimentId: carry.e,
+      variationId: carry.v,
+      assignmentEpoch: normalizedEpoch(carry.epoch),
+      handoverToken: carry.handover,
+      expiresAt,
+      // Carries emitted by pre-fix SDKs always implied that the source had
+      // exposed the assignment. Explicit false is the new gated-source case.
+      exposureSent: carry.exposureSent !== false,
+      destinationPath: carry.destinationPath,
+    };
+  } catch { return null; }
+}
+
+export function persistPendingRedirectAssignmentCarry(
+  carry: ParsedRedirectCarry | null,
+): void {
+  if (!carry) return;
+  try {
+    const expiresAt = Math.min(
+      carry.expiresAt,
+      Date.now() + MAX_PENDING_REDIRECT_CARRY_TTL_MS,
+    );
+    if (expiresAt <= Date.now()) {
+      sessionStorage.removeItem(REDIRECT_ASSIGNMENT_PENDING_KEY);
+      return;
+    }
+    sessionStorage.setItem(
+      REDIRECT_ASSIGNMENT_PENDING_KEY,
+      JSON.stringify({ ...carry, expiresAt }),
+    );
+  } catch {}
+}
+
+export function readPendingRedirectAssignmentCarry(): ParsedRedirectCarry | null {
+  try {
+    const raw = sessionStorage.getItem(REDIRECT_ASSIGNMENT_PENDING_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw) as Partial<ParsedRedirectCarry>;
+    const now = Date.now();
+    if (
+      typeof parsed.experimentId !== "string" ||
+      typeof parsed.variationId !== "string" ||
+      !Number.isSafeInteger(parsed.assignmentEpoch) ||
+      typeof parsed.handoverToken !== "string" ||
+      !parsed.handoverToken ||
+      (parsed.exposureSent !== undefined && typeof parsed.exposureSent !== "boolean") ||
+      typeof parsed.expiresAt !== "number" ||
+      (parsed.destinationPath !== undefined && typeof parsed.destinationPath !== "string") ||
+      !Number.isFinite(parsed.expiresAt) ||
+      parsed.expiresAt <= now ||
+      parsed.expiresAt > now + MAX_PENDING_REDIRECT_CARRY_TTL_MS
+    ) {
+      sessionStorage.removeItem(REDIRECT_ASSIGNMENT_PENDING_KEY);
+      return null;
+    }
+    return {
+      experimentId: parsed.experimentId,
+      variationId: parsed.variationId,
+      assignmentEpoch: normalizedEpoch(parsed.assignmentEpoch),
+      handoverToken: parsed.handoverToken,
+      expiresAt: parsed.expiresAt,
+      exposureSent: parsed.exposureSent !== false,
+      destinationPath: parsed.destinationPath,
+    };
+  } catch {
+    try { sessionStorage.removeItem(REDIRECT_ASSIGNMENT_PENDING_KEY); } catch {}
+    return null;
+  }
+}
+
+export function clearPendingRedirectAssignmentCarry(): void {
+  try {
+    sessionStorage.removeItem(REDIRECT_ASSIGNMENT_PENDING_KEY);
+  } catch {}
+}
+
+export async function verifyRedirectAssignmentCarry(
+  carry: ParsedRedirectCarry | null,
+  shopId: string,
+  verifyToken: (token: string) => Promise<unknown>,
+): Promise<VerifiedRedirectCarry | null> {
+  if (!carry || carry.expiresAt <= Date.now()) return null;
+  const handover = await verifyBucketingHandoverToken(
+    carry.handoverToken,
+    shopId,
+    verifyToken,
+  );
+  if (
+    !handover?.visitorId ||
+    handover.forceMap?.[carry.experimentId] !== carry.variationId
+  ) {
+    return null;
+  }
+  const attribution = handover.redirectAttribution;
+  const matchingAttribution = attribution
+    && attribution.experimentId === carry.experimentId
+    && attribution.variationId === carry.variationId
+    ? attribution
+    : undefined;
+  return {
+    ...carry,
+    visitorId: handover.visitorId,
+    attributionToken: matchingAttribution?.token,
+    attributionDestinationUrl: matchingAttribution?.destinationUrl,
+    attributionIssuedAt: matchingAttribution?.issuedAt,
+  };
+}
+
+export function validateRedirectAssignmentCarry(
+  experiments: Experiment[],
+  carry: VerifiedRedirectCarry | null,
+  href?: string,
+): ImportedRedirectCarry | null {
+  if (!carry) return null;
+  let currentUrl: URL | undefined;
+  if (href) {
+    try {
+      currentUrl = new URL(href);
+      if (carry.destinationPath !== undefined && (
+        normalizeRedirectPath(currentUrl.pathname) !== normalizeRedirectPath(carry.destinationPath)
+      )) return null;
+    } catch {
+      return null;
+    }
+  }
+  const experiment = experiments.find((candidate) =>
+    candidate.id === carry.experimentId &&
+    candidate.experimentType === "redirect" &&
+    candidate.variations.some((variation) => variation.id === carry.variationId));
+  if (!experiment || normalizedEpoch(experiment.assignmentEpoch) !== carry.assignmentEpoch) return null;
+  if (currentUrl) {
+    const variation = experiment.variations.find((candidate) => candidate.id === carry.variationId);
+    if (!variation?.redirectUrl) return null;
+    try {
+      const destination = new URL(variation.redirectUrl, currentUrl);
+      const redirectIsAbsolute = (() => {
+        try {
+          new URL(variation.redirectUrl!);
+          return true;
+        } catch {
+          return false;
+        }
+      })();
+      if (
+        normalizeRedirectPath(destination.pathname) !== normalizeRedirectPath(currentUrl.pathname) ||
+        (redirectIsAbsolute && destination.host !== currentUrl.host)
+      ) return null;
+    } catch {
+      return null;
+    }
+  }
+  return {
+    experiment,
+    variationId: carry.variationId,
+    visitorId: carry.visitorId,
+    exposureSent: carry.exposureSent,
+    attributionToken: carry.attributionToken,
+    attributionDestinationUrl: carry.attributionDestinationUrl,
+    attributionIssuedAt: carry.attributionIssuedAt,
+  };
+}
+
+export async function readRedirectAssignmentCarry(
+  experiments: Experiment[],
+  href: string,
+  shopId: string,
+  verifyToken: (token: string) => Promise<unknown>,
+): Promise<ImportedRedirectCarry | null> {
+  const verifiedCarry = await verifyRedirectAssignmentCarry(
+    parseRedirectAssignmentCarry(href),
+    shopId,
+    verifyToken,
+  );
+  return validateRedirectAssignmentCarry(experiments, verifiedCarry, href);
+}
+
+export function importRedirectAssignmentCarry(
+  carry: ImportedRedirectCarry,
+  href: string,
+  persistAttribution = true,
+): void {
+  persistAssignmentForExperiment(carry.experiment, carry.variationId);
+  try {
+    if (!persistAttribution) return;
+    if (!carry.attributionToken || !carry.attributionDestinationUrl || !carry.attributionIssuedAt) return;
+    if (
+      canonicalRedirectAttributionDestination(href)
+      !== canonicalRedirectAttributionDestination(carry.attributionDestinationUrl)
+    ) return;
+    const remainingSeconds = Math.floor(
+      (carry.attributionIssuedAt + REDIRECT_ATTRIBUTION_TTL_MS - Date.now()) / 1000,
+    );
+    if (remainingSeconds <= 0) return;
+    globalThis.document.cookie = `${REDIRECT_ATTRIBUTION_COOKIE}=${encodeURIComponent(carry.attributionToken)}; Max-Age=${remainingSeconds}; Path=/; SameSite=Lax`;
+  } catch {}
+}
+
+export function stripRedirectAssignmentCarry(href: string): void {
+  try {
+    const cleaned = new URL(href);
+    cleaned.searchParams.delete(REDIRECT_ASSIGNMENT_PARAM);
+    try { globalThis.history?.replaceState(globalThis.history.state, "", cleaned.href); } catch {}
+  } catch {}
+}

package/src/replay-recorder-entry.ts

@@ -0,0 +1,115 @@
+import { record } from "rrweb";
+import { deflate, deflateSync } from "fflate";
+import type { ReplayRecorderApi, ReplayRecorderEmission } from "./replay";
+import { createReplaySignalDeriver } from "./replay-signals";
+
+const RRWEB_VERSION = "2.1.1";
+const BLOCK_SELECTOR = [
+  "[data-drip-replay-block]",
+  "iframe[src*='payment' i]",
+  "iframe[name*='payment' i]",
+  "iframe[src*='checkout' i]",
+  ".StripeElement",
+  "[data-stripe]",
+].join(",");
+const MASK_TEXT_SELECTOR = [
+  "[data-drip-replay-mask]",
+  "[data-email]",
+  "[data-phone]",
+  "[data-address]",
+  ".customer-email",
+  ".customer-phone",
+  ".customer-address",
+  "[class*='personal-info' i]",
+].join(",");
+
+function targetForEvent(event: Record<string, unknown>): Element | null {
+  const data = event.data;
+  if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+  const id = (data as Record<string, unknown>).id;
+  if (typeof id !== "number") return null;
+  const node = record.mirror.getNode(id);
+  return node instanceof Element ? node : node?.parentElement ?? null;
+}
+
+function errorMessage(value: unknown): string {
+  if (value instanceof Error) return value.message || value.name;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) || "Unhandled rejection";
+  } catch {
+    return "Unhandled rejection";
+  }
+}
+
+let replaySignals = createReplaySignalDeriver();
+
+const api: ReplayRecorderApi = {
+  version: RRWEB_VERSION,
+  takeSignals() {
+    return replaySignals.snapshot();
+  },
+  compressSync(bytes) {
+    return deflateSync(bytes);
+  },
+  async compress(bytes) {
+    try {
+      return await new Promise<Uint8Array>((resolve, reject) => {
+        try {
+          deflate(bytes, (error, compressed) => {
+            if (error) reject(error);
+            else resolve(compressed);
+          });
+        } catch (error) {
+          reject(error);
+        }
+      });
+    } catch {
+      return deflateSync(bytes);
+    }
+  },
+  start({ emit, signalState }) {
+    replaySignals = createReplaySignalDeriver(signalState);
+    const stop = record({
+      emit(event) {
+        const rawEvent = event as unknown as Record<string, unknown>;
+        replaySignals.accept(rawEvent, targetForEvent(rawEvent));
+        const emission: ReplayRecorderEmission = { event: rawEvent };
+        emit(emission);
+      },
+      maskAllInputs: true,
+      slimDOMOptions: "all",
+      blockSelector: BLOCK_SELECTOR,
+      maskTextSelector: MASK_TEXT_SELECTOR,
+      sampling: {
+        mousemove: 50,
+        scroll: 150,
+        media: 800,
+        input: "last",
+      },
+      recordCanvas: false,
+      collectFonts: false,
+      inlineStylesheet: true,
+    });
+    const onError = (event: ErrorEvent) => {
+      replaySignals.error(event.message || "Window error");
+    };
+    const onUnhandledRejection = (event: PromiseRejectionEvent) => {
+      replaySignals.error(errorMessage(event.reason));
+    };
+    const onSubmit = (event: SubmitEvent) => {
+      replaySignals.submit(event.target instanceof Element ? event.target : null);
+    };
+    window.addEventListener("error", onError);
+    window.addEventListener("unhandledrejection", onUnhandledRejection);
+    window.addEventListener("submit", onSubmit, { capture: true, passive: true });
+    return () => {
+      window.removeEventListener("error", onError);
+      window.removeEventListener("unhandledrejection", onUnhandledRejection);
+      window.removeEventListener("submit", onSubmit, { capture: true });
+      stop?.();
+    };
+  },
+};
+
+(globalThis as typeof globalThis & { __dripReplayRecorder?: ReplayRecorderApi }).__dripReplayRecorder = api;