@drip-apex/sdk 0.1.0

package/src/assignment-store.ts

@@ -0,0 +1,208 @@
+import type { Experiment, Variation } from "./types";
+
+const STORAGE_KEY = "drip_assignments_v1"; // gitleaks:allow — public storage key name, not a credential
+const COOKIE_NAME = "drip_assignments_v1";
+const MAX_ENTRIES = 80;
+const MAX_COOKIE_ENTRIES = 20;
+const COOKIE_MAX_AGE_SECONDS = 365 * 24 * 60 * 60;
+
+export type PersistedAssignmentRecord = {
+  variationId: string;
+  epoch: number;
+  assignedAt: number;
+};
+
+type CompactRecord = [string, number, number];
+type CompactStore = Record<string, CompactRecord>;
+
+function assignmentEpoch(experiment: Experiment): number {
+  return Number.isFinite(experiment.assignmentEpoch)
+    ? Math.max(1, Math.floor(experiment.assignmentEpoch as number))
+    : 1;
+}
+
+function readLocalStorage(): string | null {
+  try {
+    return globalThis.localStorage?.getItem(STORAGE_KEY) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function writeLocalStorage(value: string): void {
+  try {
+    globalThis.localStorage?.setItem(STORAGE_KEY, value);
+  } catch {
+    // Ignore storage failures; cookie fallback is best effort.
+  }
+}
+
+function readCookie(): string | null {
+  try {
+    const cookie = globalThis.document?.cookie ?? "";
+    const match = cookie.match(new RegExp("(^| )" + COOKIE_NAME + "=([^;]+)"));
+    return match ? decodeURIComponent(match[2]) : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeCookie(value: string): void {
+  try {
+    if (!globalThis.document) return;
+    globalThis.document.cookie =
+      COOKIE_NAME +
+      "=" +
+      encodeURIComponent(value) +
+      "; Max-Age=" +
+      COOKIE_MAX_AGE_SECONDS +
+      "; Path=/; SameSite=Lax";
+  } catch {
+    // Ignore cookie failures.
+  }
+}
+
+function clearCookie(): void {
+  try {
+    if (!globalThis.document) return;
+    globalThis.document.cookie =
+      COOKIE_NAME + "=; Max-Age=0; Path=/; SameSite=Lax";
+  } catch {
+    // Ignore cookie failures.
+  }
+}
+
+function parseStore(raw: string | null): CompactStore {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const out: CompactStore = {};
+    for (const [experimentId, value] of Object.entries(parsed)) {
+      if (
+        typeof experimentId !== "string" ||
+        !Array.isArray(value) ||
+        typeof value[0] !== "string" ||
+        typeof value[1] !== "number" ||
+        typeof value[2] !== "number"
+      ) {
+        continue;
+      }
+      out[experimentId] = [value[0], value[1], value[2]];
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
+function serializeStore(store: CompactStore, maxEntries = MAX_ENTRIES): string {
+  const entries = Object.entries(store)
+    .sort(([, a], [, b]) => b[2] - a[2])
+    .slice(0, maxEntries);
+  // Object.fromEntries is ES2019; the SDK lib target predates it.
+  const trimmed: CompactStore = {};
+  for (const [experimentId, record] of entries) {
+    trimmed[experimentId] = record;
+  }
+  return JSON.stringify(trimmed);
+}
+
+export function readPersistedAssignments(): Record<string, PersistedAssignmentRecord> {
+  const compact = {
+    ...parseStore(readCookie()),
+    ...parseStore(readLocalStorage()),
+  };
+  const out: Record<string, PersistedAssignmentRecord> = {};
+  for (const [experimentId, [variationId, epoch, assignedAt]] of Object.entries(compact)) {
+    out[experimentId] = { variationId, epoch, assignedAt };
+  }
+  return out;
+}
+
+export function writePersistedAssignments(
+  records: Record<string, PersistedAssignmentRecord>,
+): void {
+  const compact: CompactStore = {};
+  for (const [experimentId, record] of Object.entries(records)) {
+    compact[experimentId] = [record.variationId, record.epoch, record.assignedAt];
+  }
+  writeLocalStorage(serializeStore(compact, MAX_ENTRIES));
+  writeCookie(serializeStore(compact, MAX_COOKIE_ENTRIES));
+}
+
+export function clearPersistedAssignments(): void {
+  try {
+    globalThis.localStorage?.removeItem(STORAGE_KEY);
+  } catch {
+    // Ignore storage failures.
+  }
+  clearCookie();
+}
+
+export function prunePersistedAssignments(
+  experiments: Experiment[],
+  records = readPersistedAssignments(),
+): Record<string, PersistedAssignmentRecord> {
+  const allowed = new Set(experiments.map((experiment) => experiment.id));
+  let changed = false;
+  for (const experimentId of Object.keys(records)) {
+    if (!allowed.has(experimentId)) {
+      delete records[experimentId];
+      changed = true;
+    }
+  }
+  if (changed) writePersistedAssignments(records);
+  return records;
+}
+
+export function findPersistedVariation(
+  experiment: Experiment,
+  records = readPersistedAssignments(),
+): { variation: Variation; index: number; record: PersistedAssignmentRecord } | null {
+  const record = records[experiment.id];
+  if (!record) return null;
+  if (record.epoch !== assignmentEpoch(experiment)) return null;
+  const index = experiment.variations.findIndex(
+    (variation) => variation.id === record.variationId,
+  );
+  if (index < 0) return null;
+  return { variation: experiment.variations[index], index, record };
+}
+
+export function persistAssignmentForExperiment(
+  experiment: Experiment,
+  variationId: string,
+  assignedAt = Date.now(),
+): PersistedAssignmentRecord {
+  const records = readPersistedAssignments();
+  const record = {
+    variationId,
+    epoch: assignmentEpoch(experiment),
+    assignedAt,
+  };
+  records[experiment.id] = record;
+  writePersistedAssignments(records);
+  return record;
+}
+
+export function removePersistedAssignmentsForExperiments(
+  experimentIds: Iterable<string>,
+): void {
+  const records = readPersistedAssignments();
+  let changed = false;
+  for (const experimentId of experimentIds) {
+    if (!(experimentId in records)) continue;
+    delete records[experimentId];
+    changed = true;
+  }
+  if (changed) writePersistedAssignments(records);
+}
+
+export const __assignmentStoreInternals = {
+  STORAGE_KEY,
+  COOKIE_NAME,
+  assignmentEpoch,
+  parseStore,
+  serializeStore,
+};

package/src/audit.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { isApexScriptSrc } from "./audit";
+
+describe("isApexScriptSrc", () => {
+  it("matches Apex SDK script URLs", () => {
+    expect(isApexScriptSrc("https://sdk.drip-apex.com/drip.js")).toBe(true);
+    // Keep recognizing the retired Pages hostname so audits can detect legacy installs.
+    expect(isApexScriptSrc("https://drip-sdk.pages.dev/drip.js")).toBe(true);
+    expect(isApexScriptSrc("https://app.drip-apex.com/drip.js")).toBe(true);
+    expect(isApexScriptSrc("https://cdn.example.com/apex-sdk.min.js")).toBe(true);
+  });
+
+  it("does not treat ordinary same-site scripts on drip domains as Apex installs", () => {
+    expect(isApexScriptSrc("https://dripagency.de/_next/static/chunks/app.js")).toBe(false);
+    expect(isApexScriptSrc("https://dripagency.de/assets/navigation.js")).toBe(false);
+  });
+});

package/src/audit.ts

@@ -0,0 +1,362 @@
+import type { InitConfig } from "./types";
+
+const DEFAULT_AUDIT_ENDPOINT = "https://app.drip-apex.com/api/shop-audits/collect";
+const MAX_TEXT_SAMPLE = 3000;
+const MAX_ITEMS = 80;
+
+type RuntimeAuditContext = {
+  configSource: string;
+  trackerStarted: boolean;
+  platform: string;
+};
+
+type ResourceError = {
+  url: string;
+  tag: string;
+  type: string;
+};
+
+const resourceErrors: ResourceError[] = [];
+let listenersInstalled = false;
+let inMemorySentToken = "";
+
+function installAuditListeners(): void {
+  if (listenersInstalled || typeof window === "undefined") return;
+  listenersInstalled = true;
+
+  window.addEventListener("error", (event) => {
+    const target = event.target;
+    if (!(target instanceof HTMLElement)) return;
+    const url =
+      target instanceof HTMLScriptElement ||
+      target instanceof HTMLImageElement
+        ? target.src
+        : target instanceof HTMLLinkElement
+          ? target.href
+          : "";
+    if (!url) return;
+    resourceErrors.push({
+      url: redactUrl(url),
+      tag: target.tagName.toLowerCase(),
+      type: "resource_error",
+    });
+    if (resourceErrors.length > 30) resourceErrors.shift();
+  }, true);
+
+  window.addEventListener("unhandledrejection", () => {
+    resourceErrors.push({
+      url: redactUrl(location.href),
+      tag: "window",
+      type: "unhandled_rejection",
+    });
+    if (resourceErrors.length > 30) resourceErrors.shift();
+  });
+}
+
+installAuditListeners();
+
+function queryToken(): string | null {
+  try {
+    return new URLSearchParams(location.search).get("apex_audit");
+  } catch {
+    return null;
+  }
+}
+
+function oncePerPage(token: string): boolean {
+  const key = `drip_audit_sent:${token}:${location.origin}${location.pathname}`;
+  if (inMemorySentToken === key) return false;
+  inMemorySentToken = key;
+  try {
+    if (sessionStorage.getItem(key) === "1") return false;
+    sessionStorage.setItem(key, "1");
+  } catch {
+    // Storage may be blocked; the in-memory guard still prevents immediate duplicates.
+  }
+  return true;
+}
+
+function schedule(callback: () => void): void {
+  const win = window as Window & {
+    requestIdleCallback?: (cb: () => void, opts?: { timeout: number }) => number;
+  };
+  if (typeof win.requestIdleCallback === "function") {
+    win.requestIdleCallback(callback, { timeout: 1500 });
+    return;
+  }
+  window.setTimeout(callback, document.readyState === "complete" ? 400 : 1200);
+}
+
+function textOf(el: Element | null): string {
+  return (el?.textContent || "").replace(/\s+/g, " ").trim();
+}
+
+function collectText(selector: string, limit: number): string[] {
+  return Array.from(document.querySelectorAll(selector))
+    .map(textOf)
+    .filter(Boolean)
+    .slice(0, limit);
+}
+
+function redactUrl(raw: string): string {
+  try {
+    const url = new URL(raw, location.href);
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    return raw.split("?")[0]?.slice(0, 180) || "";
+  }
+}
+
+function rgbToHex(value: string): string | null {
+  const match = value.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/i);
+  if (!match) return null;
+  const parts = match.slice(1, 4).map((part) => {
+    const n = Math.max(0, Math.min(255, Number.parseInt(part, 10) || 0));
+    return n.toString(16).padStart(2, "0");
+  });
+  const hex = `#${parts.join("")}`;
+  return hex === "#000000" || hex === "#ffffff" ? null : hex;
+}
+
+function unique(values: string[], limit: number): string[] {
+  return Array.from(new Set(values.filter(Boolean))).slice(0, limit);
+}
+
+function collectStyles() {
+  const colors: string[] = [];
+  const fonts: string[] = [];
+  const buttonStyles: string[] = [];
+  const elements = Array.from(document.querySelectorAll("body *")).slice(0, 220);
+
+  for (const el of elements) {
+    const style = getComputedStyle(el);
+    const color = rgbToHex(style.color);
+    const bg = rgbToHex(style.backgroundColor);
+    const border = rgbToHex(style.borderColor);
+    if (color) colors.push(color);
+    if (bg) colors.push(bg);
+    if (border) colors.push(border);
+    if (style.fontFamily) fonts.push(style.fontFamily.split(",")[0]?.replace(/"/g, "").trim() || "");
+
+    const isButton =
+      el.tagName === "BUTTON" ||
+      el.getAttribute("role") === "button" ||
+      (el instanceof HTMLAnchorElement && /button|btn|cta/i.test(el.className));
+    if (isButton) {
+      buttonStyles.push([
+        `color ${color || style.color}`,
+        `background ${bg || style.backgroundColor}`,
+        `radius ${style.borderRadius}`,
+      ].join(", "));
+    }
+  }
+
+  return {
+    colors: unique(colors, 12),
+    fonts: unique(fonts, 8),
+    buttons: unique(buttonStyles, 8),
+  };
+}
+
+function hasStorage(storage: Storage | undefined): boolean {
+  if (!storage) return false;
+  const key = "__drip_audit_test__";
+  try {
+    storage.setItem(key, "1");
+    storage.removeItem(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function storageAvailable(kind: "localStorage" | "sessionStorage"): boolean {
+  try {
+    return hasStorage(window[kind]);
+  } catch {
+    return false;
+  }
+}
+
+function detectPlatform(): string {
+  const win = window as Window & { Shopify?: unknown; WooCommerce?: unknown };
+  const html = document.documentElement.innerHTML.slice(0, 120000);
+  if (win.Shopify || /cdn\.shopify\.com|Shopify\.theme/i.test(html)) return "shopify";
+  if (win.WooCommerce || /wp-content|woocommerce/i.test(html)) return "woocommerce";
+  if (/__NEXT_DATA__|next\/static/i.test(html)) return "nextjs";
+  return "unknown";
+}
+
+function detectConsentBanner(): boolean {
+  const selectors = [
+    "[id*='consent' i]",
+    "[class*='consent' i]",
+    "[id*='cookie' i]",
+    "[class*='cookie' i]",
+    "[aria-label*='cookie' i]",
+  ];
+  if (selectors.some((selector) => document.querySelector(selector))) return true;
+  return /cookie|consent|gdpr|privacy preferences/i.test(document.body.innerText.slice(0, 6000));
+}
+
+function collectSchemaTypes(): string[] {
+  const types: string[] = [];
+  const scripts = Array.from(document.querySelectorAll("script[type='application/ld+json']"));
+  scripts.forEach((script) => {
+    try {
+      const parsed = JSON.parse(script.textContent || "{}");
+      const items = Array.isArray(parsed) ? parsed : [parsed];
+      items.forEach((item) => {
+        const record = item && typeof item === "object" ? item as Record<string, unknown> : {};
+        const type = String(record["@type"] || "");
+        if (type) types.push(type);
+      });
+    } catch {
+      // Ignore malformed schema blocks.
+    }
+  });
+  return unique(types, 12);
+}
+
+export function isApexScriptSrc(raw: string): boolean {
+  if (!raw) return false;
+  try {
+    const url = new URL(raw, location.href);
+    const host = url.hostname.toLowerCase();
+    const path = url.pathname.toLowerCase();
+    return (
+      host.includes("drip-sdk") ||
+      host.includes("drip-apex") ||
+      /(^|\/)(?:drip|apex)(?:[-.]sdk)?(?:\.min)?\.js$/.test(path) ||
+      /\/(?:drip|apex)-sdk(?:\.min)?\.js$/.test(path)
+    );
+  } catch {
+    return /(?:^|\/)(?:drip|apex)(?:[-.]sdk)?(?:\.min)?\.js(?:$|\?)/i.test(raw);
+  }
+}
+
+function collectNetwork(config: InitConfig) {
+  const entries = typeof performance !== "undefined"
+    ? performance.getEntriesByType("resource") as PerformanceResourceTiming[]
+    : [];
+  const resources = entries.slice(0, MAX_ITEMS).map((entry) => ({
+    url: redactUrl(entry.name),
+    type: entry.initiatorType,
+    durationMs: Math.round(entry.duration),
+    transferSize: Math.max(0, Math.round(entry.transferSize || 0)),
+  }));
+  const currentHost = location.hostname;
+  const thirdParties: string[] = [];
+  resources.forEach((resource) => {
+    try {
+      const host = new URL(resource.url).hostname;
+      if (host && host !== currentHost) thirdParties.push(host);
+    } catch {
+      // Ignore invalid resource URLs.
+    }
+  });
+  const notableThirdParties = unique(thirdParties, 18);
+  const apexRequests = resources.filter((resource) =>
+    /drip-apex|drip-sdk|drip\.js|\/events$|\/config$/i.test(resource.url),
+  ).slice(0, 20);
+  const configuredEndpoint = config.endpoint ? redactUrl(config.endpoint) : "";
+
+  return {
+    configuredEndpoint,
+    apexRequests,
+    notableThirdParties,
+    resources,
+    failedResources: resourceErrors.slice(0, 20),
+  };
+}
+
+function collectSnapshot(config: InitConfig, runtime: RuntimeAuditContext) {
+  const headings = collectText("h1,h2,h3", 16);
+  const buttons = collectText("button,a[role='button'],input[type='submit'],a[href*='/cart']", 16);
+  const imageAlts = unique(Array.from(document.images)
+    .map((img) => img.alt.trim())
+    .filter(Boolean), 12);
+  const schemaTypes = collectSchemaTypes();
+  const textSample = document.body.innerText.replace(/\s+/g, " ").trim().slice(0, MAX_TEXT_SAMPLE);
+  const offerPhrases = unique(
+    (textSample.match(/\b(?:free shipping|discount|sale|guarantee|subscribe|bundle|save \d+%|limited time)\b/gi) || [])
+      .map((item) => item.toLowerCase()),
+    10,
+  );
+  const apexScriptCount = Array.from(document.scripts)
+    .filter((script) => isApexScriptSrc(script.src || ""))
+    .length;
+
+  return {
+    page: {
+      url: redactUrl(location.href),
+      title: document.title,
+      referrer: document.referrer ? redactUrl(document.referrer) : "",
+      language: document.documentElement.lang || navigator.language || "",
+      viewport: {
+        width: window.innerWidth,
+        height: window.innerHeight,
+        devicePixelRatio: window.devicePixelRatio,
+      },
+    },
+    sdk: {
+      installed: true,
+      version: "0.1.0",
+      shopId: config.shopId || "",
+      configSource: runtime.configSource,
+      trackerStarted: runtime.trackerStarted,
+      eventsEndpointReachable: runtime.trackerStarted || Boolean(config.endpoint),
+      duplicateInstalls: apexScriptCount > 1,
+      scriptCount: apexScriptCount,
+    },
+    site: {
+      platform: runtime.platform || detectPlatform(),
+      spaDetected: Boolean(document.querySelector("[data-reactroot], [ng-version], [data-v-app], [data-sveltekit], #__next")),
+      consentBannerDetected: detectConsentBanner(),
+      cartDetected: Boolean(document.querySelector("a[href*='/cart'], form[action*='/cart']")),
+      productJsonLdDetected: schemaTypes.some((type) => /product/i.test(type)),
+      schemaTypes,
+    },
+    dom: {
+      headings,
+      buttons,
+      imageAlts,
+      sections: collectText("nav,header,main,footer,section", 10),
+      offerPhrases,
+      textSample,
+    },
+    styles: collectStyles(),
+    browserCapabilities: {
+      cookiesAvailable: navigator.cookieEnabled,
+      localStorageAvailable: storageAvailable("localStorage"),
+      sessionStorageAvailable: storageAvailable("sessionStorage"),
+      cspWarnings: [],
+      blockedRequests: resourceErrors.map((item) => `${item.type}: ${item.url}`).slice(0, 12),
+    },
+    network: collectNetwork(config),
+    capturedAt: new Date().toISOString(),
+  };
+}
+
+export function runAuditIfRequested(config: InitConfig, runtime: RuntimeAuditContext): void {
+  if (typeof window === "undefined" || typeof document === "undefined") return;
+  const token = queryToken();
+  if (!token || !oncePerPage(token)) return;
+
+  schedule(() => {
+    const endpoint = config.auditEndpoint || DEFAULT_AUDIT_ENDPOINT;
+    const body = JSON.stringify({
+      token,
+      snapshot: collectSnapshot(config, runtime),
+    });
+
+    fetch(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body,
+      keepalive: body.length < 60000,
+    }).catch(() => {
+      // The audit should never affect storefront behavior.
+    });
+  });
+}

package/src/bucket.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { chooseVariation, inTrafficAllocation } from "./bucket";
+
+describe("bucket", () => {
+  it("respects traffic allocation bounds", () => {
+    expect(inTrafficAllocation(0.2, 0)).toBe(false);
+    expect(inTrafficAllocation(0.2, 1)).toBe(true);
+    expect(inTrafficAllocation(0.2, 0.5)).toBe(true);
+    expect(inTrafficAllocation(0.7, 0.5)).toBe(false);
+  });
+
+  it("chooses weighted variations deterministically for the same hash value", () => {
+    expect(chooseVariation(0.1, [0.5, 0.5])).toBe(0);
+    expect(chooseVariation(0.9, [0.5, 0.5])).toBe(1);
+  });
+
+  it("ignores non-positive weights", () => {
+    expect(chooseVariation(0.2, [0, 1])).toBe(1);
+    expect(chooseVariation(0.2, [-1, 1])).toBe(1);
+  });
+
+  it("chooses from 3 variations with different weights", () => {
+    expect(chooseVariation(0.1, [0.33, 0.33, 0.34])).toBe(0);
+    expect(chooseVariation(0.5, [0.33, 0.33, 0.34])).toBe(1);
+    expect(chooseVariation(0.9, [0.33, 0.33, 0.34])).toBe(2);
+  });
+
+  it("returns -1 for empty weights array", () => {
+    expect(chooseVariation(0.5, [])).toBe(-1);
+  });
+
+  it("handles boundary at exact cumulative weight", () => {
+    // hashValue exactly at 0.5 boundary with [0.5, 0.5]
+    // n = 0.5 * 1.0 = 0.5, acc after first = 0.5 → 0.5 < 0.5 is false
+    // acc after second = 1.0 → 0.5 < 1.0 is true → index 1
+    expect(chooseVariation(0.5, [0.5, 0.5])).toBe(1);
+  });
+
+  it("always rejects when allocation is 0", () => {
+    expect(inTrafficAllocation(0.0, 0)).toBe(false);
+    expect(inTrafficAllocation(0.5, 0)).toBe(false);
+    expect(inTrafficAllocation(0.99, 0)).toBe(false);
+  });
+
+  it("always accepts when allocation is 1", () => {
+    expect(inTrafficAllocation(0.0, 1)).toBe(true);
+    expect(inTrafficAllocation(0.5, 1)).toBe(true);
+    expect(inTrafficAllocation(0.99, 1)).toBe(true);
+  });
+
+  it("handles boundary allocations", () => {
+    expect(inTrafficAllocation(0.998, 0.999)).toBe(true);
+    expect(inTrafficAllocation(0.002, 0.001)).toBe(false);
+  });
+
+  it("handles mixed positive/zero/negative weights", () => {
+    // [0, 0.5, -1, 0.5] → effective positives: [0, 0.5, 0, 0.5], total = 1.0
+    // hashValue 0.1: n = 0.1, skip w[0]=0, acc += 0.5 = 0.5, 0.1 < 0.5 → index 1
+    expect(chooseVariation(0.1, [0, 0.5, -1, 0.5])).toBe(1);
+    // hashValue 0.8: n = 0.8, skip w[0]=0, acc += 0.5 = 0.5 (0.8 < 0.5 no),
+    //   skip w[2]=-1, acc += 0.5 = 1.0 (0.8 < 1.0 yes) → index 3
+    expect(chooseVariation(0.8, [0, 0.5, -1, 0.5])).toBe(3);
+  });
+});
+

package/src/bucket.ts

@@ -0,0 +1,18 @@
+export function inTrafficAllocation(hashValue: number, allocation = 1): boolean {
+  if (allocation <= 0) return false;
+  if (allocation >= 1) return true;
+  return hashValue < allocation;
+}
+
+export function chooseVariation(hashValue: number, weights: number[]): number {
+  if (!weights.length) return -1;
+  const total = weights.reduce((sum, w) => sum + (w > 0 ? w : 0), 0);
+  if (total <= 0) return 0;
+  const n = hashValue * total;
+  let acc = 0;
+  for (let i = 0; i < weights.length; i++) {
+    acc += weights[i] > 0 ? weights[i] : 0;
+    if (n < acc) return i;
+  }
+  return weights.length - 1;
+}

package/src/bucketing-cleanup.test.ts

@@ -0,0 +1,30 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { cleanupBucketingStorage } from "./bucketing-cleanup";
+
+describe("bucketing cleanup", () => {
+  const originalLocalStorage = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+
+  afterEach(() => {
+    if (originalLocalStorage) {
+      Object.defineProperty(globalThis, "localStorage", originalLocalStorage);
+    } else {
+      delete (globalThis as Record<string, unknown>).localStorage;
+    }
+  });
+
+  it("ignores browsers that expose blocked localStorage accessors", () => {
+    Object.defineProperty(globalThis, "localStorage", {
+      configurable: true,
+      get() {
+        throw new DOMException("blocked", "SecurityError");
+      },
+    });
+
+    expect(() => {
+      cleanupBucketingStorage([], {
+        shopId: "shop_blocked_storage",
+        retentionDays: 180,
+      });
+    }).not.toThrow();
+  });
+});