begeniux 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,52 +1,79 @@
 // src/BeGenProvider.tsx
 import * as React from "react";
-import { jsx } from "react/jsx-runtime";
-var BeGenContext = React.createContext(null);
-function BeGenProvider({ children }) {
-  const [variant, setVariant] = React.useState("neutral");
-  const [directive, setDirective] = React.useState(null);
-  const [summary, setSummary] = React.useState(null);
-  const value = React.useMemo(
-    () => ({ variant, directive, summary, setVariant, setDirective, setSummary }),
-    [variant, directive, summary]
-  );
-  return /* @__PURE__ */ jsx(BeGenContext.Provider, { value, children });
-}
-
-// src/BeGenSurface.tsx
-import * as React2 from "react";
 
 // src/useBehaviorTracker.ts
-import { useEffect, useRef, useState as useState2 } from "react";
-var RECENT_EVENTS_CAP = 5;
+import { useEffect, useRef, useState } from "react";
+var RECENT_EVENTS_CAP = 10;
 var HOVER_MIN_MS = 200;
+var RAGE_CLICK_WINDOW_MS = 1e3;
+var RAGE_CLICK_THRESHOLD = 3;
+var INPUT_THROTTLE_MS = 1e3;
 function targetLabel(el) {
   if (!(el instanceof HTMLElement)) return "unknown";
-  return el.dataset.begenId || el.getAttribute("data-product-id") || el.getAttribute("aria-label") || el.tagName.toLowerCase();
+  const begenId = el.getAttribute("data-begen-id");
+  if (begenId) return `[data-begen-id="${begenId}"]`;
+  if (el.id) return `#${el.id}`;
+  const testId = el.getAttribute("data-testid");
+  if (testId) return `[data-testid="${testId}"]`;
+  return el.tagName.toLowerCase();
 }
-function computeSummary(buffer, bufferSize, pageContext) {
+function computeSummary(buffer, bufferSize, pageContext, custom) {
   const now = Date.now();
   const windowStart = now - 6e4;
   let clicksLastMin = 0;
+  let rageClicks = 0;
   let dwellSum = 0;
   let dwellCount = 0;
   let maxScroll = 0;
+  let formInteractions = 0;
+  let errorsSeen = 0;
   const hoverTargets = /* @__PURE__ */ new Set();
+  let viewportW = typeof window !== "undefined" ? window.innerWidth || 0 : 0;
+  let viewportH = typeof window !== "undefined" ? window.innerHeight || 0 : 0;
   for (const ev of buffer) {
-    if (ev.kind === "click" && ev.t >= windowStart) clicksLastMin += 1;
-    if (ev.kind === "dwell") {
-      dwellSum += ev.durationMs;
-      dwellCount += 1;
+    switch (ev.kind) {
+      case "click":
+        if (ev.t >= windowStart) clicksLastMin += 1;
+        break;
+      case "rage-click":
+        rageClicks += 1;
+        break;
+      case "dwell":
+        dwellSum += ev.durationMs;
+        dwellCount += 1;
+        break;
+      case "scroll":
+        if (ev.depth > maxScroll) maxScroll = ev.depth;
+        break;
+      case "hover":
+        hoverTargets.add(ev.target);
+        break;
+      case "input":
+      case "submit":
+        formInteractions += 1;
+        break;
+      case "error":
+        errorsSeen += 1;
+        break;
+      case "viewport-change":
+        viewportW = ev.width;
+        viewportH = ev.height;
+        break;
+      default:
+        break;
     }
-    if (ev.kind === "scroll" && ev.depth > maxScroll) maxScroll = ev.depth;
-    if (ev.kind === "hover") hoverTargets.add(ev.target);
   }
   return {
     clicks_per_min: clicksLastMin,
+    rage_clicks: rageClicks,
     avg_dwell_ms: dwellCount === 0 ? 0 : Math.round(dwellSum / dwellCount),
     scroll_depth: Math.max(0, Math.min(1, maxScroll)),
     hover_count: hoverTargets.size,
+    form_interactions: formInteractions,
+    errors_seen: errorsSeen,
     events_seen: Math.min(buffer.length, bufferSize),
+    viewport: { width: viewportW, height: viewportH },
+    custom,
     page_context: pageContext
   };
 }
@@ -58,13 +85,19 @@ function useBehaviorTracker(opts) {
     bufferSize = 50,
     onFlush,
     pageContext,
-    seedTrace
+    seedTrace,
+    customListeners
   } = opts;
   const bufferRef = useRef([]);
   const sinceFlushRef = useRef(0);
   const lastFlushAtRef = useRef(Date.now());
   const hoverStartRef = useRef(/* @__PURE__ */ new Map());
+  const focusStartRef = useRef(/* @__PURE__ */ new Map());
+  const lastInputAtRef = useRef(/* @__PURE__ */ new Map());
+  const recentClicksRef = useRef(/* @__PURE__ */ new Map());
   const scrollRafRef = useRef(null);
+  const resizeRafRef = useRef(null);
+  const customSlotRef = useRef({});
   const onFlushRef = useRef(onFlush);
   const pageContextRef = useRef(pageContext);
   useEffect(() => {
@@ -73,7 +106,7 @@ function useBehaviorTracker(opts) {
   useEffect(() => {
     pageContextRef.current = pageContext;
   }, [pageContext]);
-  const [recentEvents, setRecentEvents] = useState2([]);
+  const [recentEvents, setRecentEvents] = useState([]);
   const pushEvent = (ev) => {
     const buf = bufferRef.current;
     buf.push(ev);
@@ -81,7 +114,9 @@ function useBehaviorTracker(opts) {
     sinceFlushRef.current += 1;
     setRecentEvents((prev) => {
       const next = [...prev, ev];
-      if (next.length > RECENT_EVENTS_CAP) next.splice(0, next.length - RECENT_EVENTS_CAP);
+      if (next.length > RECENT_EVENTS_CAP) {
+        next.splice(0, next.length - RECENT_EVENTS_CAP);
+      }
       return next;
     });
     if (sinceFlushRef.current >= flushEveryEvents) {
@@ -89,31 +124,58 @@ function useBehaviorTracker(opts) {
     }
   };
   const flush = () => {
-    const summary = computeSummary(bufferRef.current, bufferSize, pageContextRef.current);
+    const summary = computeSummary(
+      bufferRef.current,
+      bufferSize,
+      pageContextRef.current,
+      customSlotRef.current
+    );
     sinceFlushRef.current = 0;
     lastFlushAtRef.current = Date.now();
     onFlushRef.current(summary);
   };
   useEffect(() => {
-    if (seedTrace && seedTrace.length > 0) {
-      const buf = bufferRef.current;
-      const maxT = seedTrace.reduce((m, e) => e.t > m ? e.t : m, -Infinity);
-      const now = Date.now();
-      const offset = Number.isFinite(maxT) ? now - maxT : 0;
-      const rebased = seedTrace.map((e) => ({ ...e, t: e.t + offset }));
-      buf.push(...rebased);
-      if (buf.length > bufferSize) buf.splice(0, buf.length - bufferSize);
-      const summary = computeSummary(buf, bufferSize, pageContextRef.current);
-      sinceFlushRef.current = 0;
-      lastFlushAtRef.current = Date.now();
-      onFlushRef.current(summary);
-    }
+    if (!seedTrace || seedTrace.length === 0) return;
+    const buf = bufferRef.current;
+    const maxT = seedTrace.reduce((m, e) => e.t > m ? e.t : m, -Infinity);
+    const now = Date.now();
+    const offset = Number.isFinite(maxT) ? now - maxT : 0;
+    const rebased = seedTrace.map((e) => ({ ...e, t: e.t + offset }));
+    buf.push(...rebased);
+    if (buf.length > bufferSize) buf.splice(0, buf.length - bufferSize);
+    const summary = computeSummary(
+      buf,
+      bufferSize,
+      pageContextRef.current,
+      customSlotRef.current
+    );
+    sinceFlushRef.current = 0;
+    lastFlushAtRef.current = Date.now();
+    onFlushRef.current(summary);
   }, []);
   useEffect(() => {
-    const el = containerRef.current;
+    if (typeof window === "undefined" || typeof document === "undefined") return;
+    const el = containerRef?.current ?? (typeof document !== "undefined" ? document.body : null);
     if (!el) return;
     const onClick = (e) => {
-      pushEvent({ kind: "click", target: targetLabel(e.target), t: Date.now() });
+      const label = targetLabel(e.target);
+      const t = Date.now();
+      pushEvent({ kind: "click", target: label, t });
+      const recent = recentClicksRef.current.get(label) ?? [];
+      const filtered = recent.filter(
+        (then) => t - then < RAGE_CLICK_WINDOW_MS
+      );
+      filtered.push(t);
+      recentClicksRef.current.set(label, filtered);
+      if (filtered.length >= RAGE_CLICK_THRESHOLD) {
+        pushEvent({
+          kind: "rage-click",
+          target: label,
+          count: filtered.length,
+          t
+        });
+        recentClicksRef.current.set(label, []);
+      }
     };
     const onMouseOver = (e) => {
       const label = targetLabel(e.target);
@@ -132,11 +194,46 @@ function useBehaviorTracker(opts) {
       pushEvent({ kind: "hover", target: label, durationMs, t });
       pushEvent({ kind: "dwell", target: label, durationMs, t });
     };
+    const onFocusIn = (e) => {
+      const label = targetLabel(e.target);
+      focusStartRef.current.set(label, Date.now());
+      pushEvent({ kind: "focus", target: label, t: Date.now() });
+    };
+    const onFocusOut = (e) => {
+      const label = targetLabel(e.target);
+      const started = focusStartRef.current.get(label);
+      if (started == null) return;
+      focusStartRef.current.delete(label);
+      const durationMs = Date.now() - started;
+      if (durationMs < HOVER_MIN_MS) return;
+      pushEvent({
+        kind: "blur",
+        target: label,
+        durationMs,
+        t: Date.now()
+      });
+    };
+    const onInput = (e) => {
+      const target = e.target;
+      if (!(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement || target instanceof HTMLElement && target.isContentEditable)) {
+        return;
+      }
+      const label = targetLabel(target);
+      const now = Date.now();
+      const last = lastInputAtRef.current.get(label) ?? 0;
+      if (now - last < INPUT_THROTTLE_MS) return;
+      lastInputAtRef.current.set(label, now);
+      pushEvent({ kind: "input", target: label, t: now });
+    };
+    const onSubmit = (e) => {
+      const label = targetLabel(e.target);
+      pushEvent({ kind: "submit", target: label, t: Date.now() });
+    };
     const computeScrollDepth = () => {
       const rect = el.getBoundingClientRect();
-      const viewportH = window.innerHeight || 1;
+      const viewportHCalc = window.innerHeight || 1;
       const elementH = el.scrollHeight || rect.height || 1;
-      const visibleBottom = Math.min(rect.bottom, viewportH);
+      const visibleBottom = Math.min(rect.bottom, viewportHCalc);
       const scrolledPast = Math.max(0, visibleBottom - rect.top);
       return Math.max(0, Math.min(1, scrolledPast / elementH));
     };
@@ -144,13 +241,60 @@ function useBehaviorTracker(opts) {
       if (scrollRafRef.current != null) return;
       scrollRafRef.current = requestAnimationFrame(() => {
         scrollRafRef.current = null;
-        pushEvent({ kind: "scroll", depth: computeScrollDepth(), t: Date.now() });
+        pushEvent({
+          kind: "scroll",
+          depth: computeScrollDepth(),
+          t: Date.now()
+        });
+      });
+    };
+    const onResize = () => {
+      if (resizeRafRef.current != null) return;
+      resizeRafRef.current = requestAnimationFrame(() => {
+        resizeRafRef.current = null;
+        pushEvent({
+          kind: "viewport-change",
+          width: window.innerWidth,
+          height: window.innerHeight,
+          t: Date.now()
+        });
+      });
+    };
+    const onError = (e) => {
+      pushEvent({
+        kind: "error",
+        message: String(e.message ?? "unknown"),
+        t: Date.now()
+      });
+    };
+    const onUnhandledRejection = (e) => {
+      pushEvent({
+        kind: "error",
+        message: `unhandled-rejection: ${String(e.reason ?? "unknown")}`,
+        t: Date.now()
       });
     };
     el.addEventListener("click", onClick);
     el.addEventListener("mouseover", onMouseOver);
     el.addEventListener("mouseout", onMouseOut);
+    el.addEventListener("focusin", onFocusIn);
+    el.addEventListener("focusout", onFocusOut);
+    el.addEventListener("input", onInput);
+    el.addEventListener("submit", onSubmit);
     window.addEventListener("scroll", onScroll, { passive: true });
+    window.addEventListener("resize", onResize);
+    window.addEventListener("error", onError);
+    window.addEventListener("unhandledrejection", onUnhandledRejection);
+    const cleanups = [];
+    if (customListeners) {
+      for (const listener of customListeners) {
+        try {
+          const cleanup = listener.attach(el, pushEvent);
+          cleanups.push(cleanup);
+        } catch {
+        }
+      }
+    }
     const interval = window.setInterval(() => {
       if (Date.now() - lastFlushAtRef.current >= flushAfterMs) {
         flush();
@@ -160,320 +304,513 @@ function useBehaviorTracker(opts) {
       el.removeEventListener("click", onClick);
       el.removeEventListener("mouseover", onMouseOver);
       el.removeEventListener("mouseout", onMouseOut);
+      el.removeEventListener("focusin", onFocusIn);
+      el.removeEventListener("focusout", onFocusOut);
+      el.removeEventListener("input", onInput);
+      el.removeEventListener("submit", onSubmit);
       window.removeEventListener("scroll", onScroll);
+      window.removeEventListener("resize", onResize);
+      window.removeEventListener("error", onError);
+      window.removeEventListener("unhandledrejection", onUnhandledRejection);
       window.clearInterval(interval);
-      if (scrollRafRef.current != null) cancelAnimationFrame(scrollRafRef.current);
+      if (scrollRafRef.current != null) {
+        cancelAnimationFrame(scrollRafRef.current);
+      }
+      if (resizeRafRef.current != null) {
+        cancelAnimationFrame(resizeRafRef.current);
+      }
+      for (const cleanup of cleanups) {
+        try {
+          cleanup();
+        } catch {
+        }
+      }
     };
   }, [containerRef, flushAfterMs, flushEveryEvents, bufferSize]);
   return { recentEvents };
 }
 
-// src/personas.ts
-function buildDecisive() {
-  const events = [];
-  const productIds = ["p-101", "p-102", "p-103", "p-104", "p-105", "p-106"];
-  let t = 0;
-  for (let i = 0; i < 12; i++) {
-    t += 1500;
-    events.push({ kind: "click", target: productIds[i % productIds.length], t });
+// src/AdaptationEngine.ts
+var STRUCTURAL_PROPERTY_DENY = /* @__PURE__ */ new Set([
+  "display",
+  "position",
+  "visibility",
+  "float",
+  "clear",
+  "z-index",
+  "overflow",
+  "overflow-x",
+  "overflow-y",
+  "transform-origin"
+]);
+var AdaptationEngine = class {
+  constructor(opts) {
+    this.revertLog = [];
+    this.appliedSnapshot = [];
+    this.root = opts.root;
+    this.scope = opts.scope ?? {};
+    this.onEvent = opts.onEvent;
   }
-  for (let i = 0; i < 6; i++) {
-    t += 800;
-    events.push({
-      kind: "dwell",
-      target: productIds[i % productIds.length],
-      durationMs: 600 + i * 80,
-      t
-    });
+  /** Apply a plan. Reverts the previous plan first so mutations don't accumulate. */
+  apply(plan) {
+    this.revertAll();
+    for (const adaptation of plan.adaptations) {
+      this.applyOne(adaptation);
+    }
   }
-  for (let i = 0; i < 6; i++) {
-    t += 1200;
-    events.push({
-      kind: "scroll",
-      depth: Math.min(0.95, 0.4 + i * 0.1),
-      t
-    });
+  /** Roll back every adaptation applied since the last revertAll. */
+  revertAll() {
+    if (this.revertLog.length === 0) return;
+    const count = this.revertLog.length;
+    for (let i = this.revertLog.length - 1; i >= 0; i--) {
+      try {
+        this.revertLog[i]();
+      } catch {
+      }
+    }
+    this.revertLog = [];
+    this.appliedSnapshot = [];
+    this.onEvent?.({ kind: "reverted", count });
+  }
+  /** Read-only view of currently applied adaptations (for telemetry). */
+  getApplied() {
+    return this.appliedSnapshot;
   }
-  for (let i = 0; i < 2; i++) {
-    t += 600;
-    events.push({
-      kind: "hover",
-      target: productIds[i],
-      durationMs: 250,
-      t
+  // ── Internals ──────────────────────────────────────────────────────
+  applyOne(adaptation) {
+    const elements = this.resolveTargets(adaptation);
+    if (elements === null) return;
+    if (elements.length === 0) {
+      this.onEvent?.({ kind: "skipped", adaptation, reason: "no-match" });
+      return;
+    }
+    if (adaptation.kind === "set-style" && STRUCTURAL_PROPERTY_DENY.has(adaptation.property.toLowerCase())) {
+      this.onEvent?.({
+        kind: "skipped",
+        adaptation,
+        reason: `structural-property-denied:${adaptation.property}`
+      });
+      return;
+    }
+    for (const el of elements) {
+      const revert = this.applyToElement(el, adaptation);
+      if (revert) this.revertLog.push(revert);
+    }
+    this.appliedSnapshot.push(adaptation);
+    this.onEvent?.({
+      kind: "applied",
+      adaptation,
+      matched: elements.length
     });
   }
-  return events;
+  resolveTargets(adaptation) {
+    const sel = adaptation.selector;
+    if (!sel || typeof sel !== "string") {
+      this.onEvent?.({
+        kind: "skipped",
+        adaptation,
+        reason: "invalid-selector"
+      });
+      return null;
+    }
+    if (this.scope.deny?.some((d) => this.selectorMatchesPattern(sel, d))) {
+      this.onEvent?.({ kind: "skipped", adaptation, reason: "scope-deny" });
+      return null;
+    }
+    if (this.scope.allow && !this.scope.allow.some((a) => this.selectorMatchesPattern(sel, a))) {
+      this.onEvent?.({
+        kind: "skipped",
+        adaptation,
+        reason: "scope-not-in-allow"
+      });
+      return null;
+    }
+    let nodes;
+    try {
+      if (sel === ":root" || sel === "html") {
+        return [document.documentElement];
+      }
+      nodes = this.root.querySelectorAll(sel);
+    } catch {
+      this.onEvent?.({
+        kind: "skipped",
+        adaptation,
+        reason: "selector-syntax-error"
+      });
+      return null;
+    }
+    return Array.from(nodes).filter(
+      (n) => n instanceof HTMLElement
+    );
+  }
+  selectorMatchesPattern(selector, pattern) {
+    if (selector === pattern) return true;
+    return selector.includes(pattern);
+  }
+  applyToElement(el, adaptation) {
+    switch (adaptation.kind) {
+      case "set-css-var": {
+        const prev = el.style.getPropertyValue(adaptation.name);
+        const prevPriority = el.style.getPropertyPriority(adaptation.name);
+        el.style.setProperty(adaptation.name, adaptation.value);
+        return () => {
+          if (prev) el.style.setProperty(adaptation.name, prev, prevPriority);
+          else el.style.removeProperty(adaptation.name);
+        };
+      }
+      case "add-class": {
+        if (el.classList.contains(adaptation.className)) return null;
+        el.classList.add(adaptation.className);
+        return () => el.classList.remove(adaptation.className);
+      }
+      case "remove-class": {
+        if (!el.classList.contains(adaptation.className)) return null;
+        el.classList.remove(adaptation.className);
+        return () => el.classList.add(adaptation.className);
+      }
+      case "set-style": {
+        const prop = adaptation.property;
+        const prev = el.style.getPropertyValue(prop);
+        const prevPriority = el.style.getPropertyPriority(prop);
+        el.style.setProperty(prop, adaptation.value);
+        return () => {
+          if (prev) el.style.setProperty(prop, prev, prevPriority);
+          else el.style.removeProperty(prop);
+        };
+      }
+      case "set-attribute": {
+        const had = el.hasAttribute(adaptation.name);
+        const prev = el.getAttribute(adaptation.name);
+        el.setAttribute(adaptation.name, adaptation.value);
+        return () => {
+          if (had && prev !== null) el.setAttribute(adaptation.name, prev);
+          else el.removeAttribute(adaptation.name);
+        };
+      }
+      case "set-aria-label": {
+        const had = el.hasAttribute("aria-label");
+        const prev = el.getAttribute("aria-label");
+        el.setAttribute("aria-label", adaptation.value);
+        return () => {
+          if (had && prev !== null) el.setAttribute("aria-label", prev);
+          else el.removeAttribute("aria-label");
+        };
+      }
+      default: {
+        const _exhaustive = adaptation;
+        void _exhaustive;
+        return null;
+      }
+    }
+  }
+};
+
+// src/domSnapshot.ts
+function snapshotVisibleSelectors(root, opts = {}) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return [];
+  }
+  const max = opts.maxSelectors ?? 50;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  const viewportH = window.innerHeight || 1;
+  const viewportW = window.innerWidth || 1;
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: (node2) => {
+      if (!(node2 instanceof HTMLElement)) return NodeFilter.FILTER_SKIP;
+      const rect = node2.getBoundingClientRect();
+      if (rect.width === 0 || rect.height === 0) return NodeFilter.FILTER_SKIP;
+      if (rect.bottom < 0 || rect.top > viewportH) return NodeFilter.FILTER_SKIP;
+      if (rect.right < 0 || rect.left > viewportW) return NodeFilter.FILTER_SKIP;
+      return NodeFilter.FILTER_ACCEPT;
+    }
+  });
+  let node = walker.nextNode();
+  while (node && out.length < max) {
+    if (node instanceof HTMLElement) {
+      const sel = pickSelector(node);
+      if (sel && !seen.has(sel) && passesScope(sel, opts.scope)) {
+        seen.add(sel);
+        out.push(sel);
+      }
+    }
+    node = walker.nextNode();
+  }
+  return out;
 }
-function buildDeliberate() {
-  const events = [];
-  const productIds = ["p-201", "p-202", "p-203", "p-204", "p-205", "p-206"];
-  let t = 0;
-  for (let i = 0; i < 6; i++) {
-    t += 5500;
-    const target = productIds[i];
-    events.push({ kind: "hover", target, durationMs: 1800 + i * 200, t });
-    t += 200;
-    events.push({
-      kind: "dwell",
-      target,
-      durationMs: 5e3 + i * 400,
-      t
-    });
+function pickSelector(el) {
+  if (el.id) return `#${cssEscape(el.id)}`;
+  const begenId = el.getAttribute("data-begen-id");
+  if (begenId) return `[data-begen-id="${attrEscape(begenId)}"]`;
+  const testId = el.getAttribute("data-testid");
+  if (testId) return `[data-testid="${attrEscape(testId)}"]`;
+  const role = el.getAttribute("role");
+  if (role) return `${el.tagName.toLowerCase()}[role="${attrEscape(role)}"]`;
+  const semantic = SEMANTIC_TAGS.has(el.tagName.toLowerCase());
+  if (semantic) {
+    const aria = el.getAttribute("aria-label");
+    if (aria) {
+      return `${el.tagName.toLowerCase()}[aria-label="${attrEscape(aria)}"]`;
+    }
+    return el.tagName.toLowerCase();
   }
-  for (let i = 0; i < 3; i++) {
-    t += 4e3;
-    events.push({ kind: "click", target: productIds[i], t });
+  const cls = pickStableClass(el);
+  if (cls) return `.${cssEscape(cls)}`;
+  return null;
+}
+var SEMANTIC_TAGS = /* @__PURE__ */ new Set([
+  "header",
+  "main",
+  "nav",
+  "footer",
+  "aside",
+  "article",
+  "section",
+  "form",
+  "dialog"
+]);
+function pickStableClass(el) {
+  for (const cls of el.classList) {
+    if (cls.includes(":")) continue;
+    if (/^[a-z]+-[a-z0-9-]+$/.test(cls)) continue;
+    if (cls.length < 3) continue;
+    return cls;
   }
-  for (let i = 0; i < 5; i++) {
-    t += 1500;
-    events.push({
-      kind: "scroll",
-      depth: Math.min(0.6, 0.2 + i * 0.08),
-      t
-    });
+  return null;
+}
+function passesScope(selector, scope) {
+  if (!scope) return true;
+  if (scope.deny?.some((d) => selector === d || selector.includes(d))) {
+    return false;
   }
-  return events;
+  if (scope.allow && !scope.allow.some((a) => selector === a || selector.includes(a))) {
+    return false;
+  }
+  return true;
 }
-var PERSONAS = {
-  get decisive() {
-    return buildDecisive();
-  },
-  get deliberate() {
-    return buildDeliberate();
+function cssEscape(s) {
+  if (typeof CSS !== "undefined" && typeof CSS.escape === "function") {
+    return CSS.escape(s);
   }
-};
+  return s.replace(/[^a-zA-Z0-9_-]/g, "\\$&");
+}
+function attrEscape(s) {
+  return s.replace(/"/g, '\\"');
+}
 
-// src/BeGenSurface.tsx
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
-function BeGenSurface(props) {
+// src/BeGenProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var BeGenContext = React.createContext(null);
+function useBeGenContext() {
+  const ctx = React.useContext(BeGenContext);
+  if (!ctx) {
+    throw new Error("useBeGenContext must be used inside <BeGenProvider>");
+  }
+  return ctx;
+}
+function BeGenProvider(props) {
   const {
-    variants,
-    classify,
-    variantProps,
+    designSystem,
     pageContext,
-    seedPersona,
-    rateLimitMs = 4e3,
-    className,
-    style
+    classify,
+    scope,
+    rateLimitMs = 5e3,
+    triggerEveryEvents = 5,
+    flushAfterMs = 5e3,
+    flushEveryEvents = 10,
+    bufferSize = 50,
+    customListeners,
+    containerRef,
+    seedTrace,
+    children
   } = props;
-  const containerRef = React2.useRef(null);
-  const ctx = React2.useContext(BeGenContext);
-  const [currentVariant, setCurrentVariant] = React2.useState("neutral");
-  const [lastDirective, setLastDirective] = React2.useState(null);
-  const [lastSummary, setLastSummary] = React2.useState(null);
-  const lastClassifyAtRef = React2.useRef(0);
-  const inFlightRef = React2.useRef(false);
-  const classifyRef = React2.useRef(classify);
-  React2.useEffect(() => {
+  const engineRef = React.useRef(null);
+  const [summary, setSummary] = React.useState(null);
+  const [lastPlan, setLastPlan] = React.useState(null);
+  const [appliedAdaptations, setAppliedAdaptations] = React.useState([]);
+  const lastClassifyAtRef = React.useRef(0);
+  const inFlightRef = React.useRef(false);
+  const eventsSinceClassifyRef = React.useRef(0);
+  const lastPlanHashRef = React.useRef(null);
+  const classifyRef = React.useRef(classify);
+  React.useEffect(() => {
     classifyRef.current = classify;
   }, [classify]);
-  const ctxRef = React2.useRef(ctx);
-  React2.useEffect(() => {
-    ctxRef.current = ctx;
-  }, [ctx]);
-  const handleFlush = React2.useCallback(async (summary) => {
-    setLastSummary(summary);
-    ctxRef.current?.setSummary(summary);
-    const now = Date.now();
-    if (inFlightRef.current) return;
-    if (now - lastClassifyAtRef.current < rateLimitMs) return;
-    lastClassifyAtRef.current = now;
-    inFlightRef.current = true;
-    try {
-      const directive = await classifyRef.current(summary);
-      setLastDirective(directive);
-      setCurrentVariant(directive.variant);
-      ctxRef.current?.setDirective(directive);
-      ctxRef.current?.setVariant(directive.variant);
-    } catch {
-    } finally {
-      inFlightRef.current = false;
-    }
-  }, [rateLimitMs]);
-  const seedTrace = seedPersona ? PERSONAS[seedPersona] : void 0;
+  const designSystemRef = React.useRef(designSystem);
+  React.useEffect(() => {
+    designSystemRef.current = designSystem;
+  }, [designSystem]);
+  const pageContextRef = React.useRef(pageContext);
+  React.useEffect(() => {
+    pageContextRef.current = pageContext;
+  }, [pageContext]);
+  const scopeRef = React.useRef(scope);
+  React.useEffect(() => {
+    scopeRef.current = scope;
+  }, [scope]);
+  React.useEffect(() => {
+    if (typeof document === "undefined") return;
+    const root = containerRef?.current ?? document.body;
+    if (!root) return;
+    engineRef.current = new AdaptationEngine({
+      root,
+      scope: scopeRef.current,
+      onEvent: () => {
+        if (engineRef.current) {
+          setAppliedAdaptations(engineRef.current.getApplied().slice());
+        }
+      }
+    });
+    return () => {
+      engineRef.current?.revertAll();
+      engineRef.current = null;
+    };
+  }, []);
+  const handleFlush = React.useCallback(
+    async (s) => {
+      setSummary(s);
+      eventsSinceClassifyRef.current += 1;
+      const fn = classifyRef.current;
+      if (!fn) return;
+      if (inFlightRef.current) return;
+      const now = Date.now();
+      if (now - lastClassifyAtRef.current < rateLimitMs) return;
+      if (eventsSinceClassifyRef.current < triggerEveryEvents) return;
+      lastClassifyAtRef.current = now;
+      eventsSinceClassifyRef.current = 0;
+      inFlightRef.current = true;
+      try {
+        const root = containerRef?.current ?? (typeof document !== "undefined" ? document.body : null) ?? null;
+        const visibleSelectors = root ? snapshotVisibleSelectors(root, { scope: scopeRef.current }) : [];
+        const route = s.page_context?.route ?? "/";
+        const input = {
+          summary: s,
+          designSystem: designSystemRef.current,
+          dom: { visibleSelectors, route }
+        };
+        const plan = await fn(input);
+        if (!plan || !Array.isArray(plan.adaptations)) return;
+        const hash = hashPlan(plan);
+        if (hash === lastPlanHashRef.current) return;
+        lastPlanHashRef.current = hash;
+        setLastPlan(plan);
+        engineRef.current?.apply(plan);
+      } catch {
+      } finally {
+        inFlightRef.current = false;
+      }
+    },
+    [rateLimitMs, triggerEveryEvents, containerRef]
+  );
   useBehaviorTracker({
     containerRef,
     onFlush: handleFlush,
     pageContext,
-    seedTrace
+    seedTrace,
+    customListeners,
+    flushAfterMs,
+    flushEveryEvents,
+    bufferSize
   });
-  const ActiveComponent = variants[currentVariant] ?? variants.neutral;
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      ref: containerRef,
-      className,
-      style,
-      "data-begen-surface": true,
-      "data-begen-variant": currentVariant,
-      children: [
-        /* @__PURE__ */ jsx2(
-          "div",
-          {
-            style: {
-              opacity: 1,
-              transition: "opacity 200ms ease",
-              animation: "begen-fade-in 200ms ease"
-            },
-            children: ActiveComponent ? /* @__PURE__ */ jsx2(ActiveComponent, { ...variantProps ?? {} }) : null
-          },
-          currentVariant
-        ),
-        /* @__PURE__ */ jsx2(BeGenSurfaceStyles, {}),
-        lastDirective && /* @__PURE__ */ jsx2(
-          "span",
-          {
-            style: { display: "none" },
-            "data-begen-confidence": lastDirective.confidence,
-            "data-begen-reasoning": lastDirective.reasoning,
-            "data-begen-events": lastSummary?.events_seen ?? 0
-          }
-        )
-      ]
-    }
-  );
-}
-var STYLE_INJECTED = "__begen_styles__";
-function BeGenSurfaceStyles() {
-  React2.useEffect(() => {
-    if (typeof document === "undefined") return;
-    if (document[STYLE_INJECTED]) return;
-    const tag = document.createElement("style");
-    tag.setAttribute("data-begen-styles", "");
-    tag.textContent = `@keyframes begen-fade-in { from { opacity: 0 } to { opacity: 1 } }`;
-    document.head.appendChild(tag);
-    document[STYLE_INJECTED] = true;
+  const recentEventsRef = React.useRef([]);
+  const applyPlan = React.useCallback((plan) => {
+    if (!plan || !Array.isArray(plan.adaptations)) return;
+    const hash = hashPlan(plan);
+    if (hash === lastPlanHashRef.current) return;
+    lastPlanHashRef.current = hash;
+    setLastPlan(plan);
+    engineRef.current?.apply(plan);
   }, []);
-  return null;
+  const getDesignSystem = React.useCallback(
+    () => designSystemRef.current,
+    []
+  );
+  const value = React.useMemo(
+    () => ({
+      summary,
+      lastPlan,
+      appliedAdaptations,
+      recentEvents: recentEventsRef.current,
+      applyPlan,
+      getDesignSystem
+    }),
+    [summary, lastPlan, appliedAdaptations, applyPlan, getDesignSystem]
+  );
+  return /* @__PURE__ */ jsx(BeGenContext.Provider, { value, children });
 }
-
-// src/useBeGenContext.ts
-import * as React3 from "react";
-function useBeGenContext() {
-  const ctx = React3.useContext(BeGenContext);
-  if (!ctx) {
-    throw new Error("useBeGenContext must be used inside <BeGenProvider>");
-  }
-  return ctx;
+function hashPlan(plan) {
+  const parts = plan.adaptations.map((a) => {
+    switch (a.kind) {
+      case "set-css-var":
+        return `v|${a.selector}|${a.name}|${a.value}`;
+      case "add-class":
+        return `+|${a.selector}|${a.className}`;
+      case "remove-class":
+        return `-|${a.selector}|${a.className}`;
+      case "set-style":
+        return `s|${a.selector}|${a.property}|${a.value}`;
+      case "set-attribute":
+        return `a|${a.selector}|${a.name}|${a.value}`;
+      case "set-aria-label":
+        return `l|${a.selector}|${a.value}`;
+    }
+  });
+  return parts.join("\n");
 }
 
-// src/classifier/gemini.ts
-var CLASSIFIER_SYSTEM_PROMPT = `
-You classify e-commerce shopper behavior into UI variants.
-
-You receive a JSON object describing a user's recent interaction pattern on
-a product listing page. Decide which UI variant best serves them right now.
-
-Variants:
-- "decisive": user knows what they want; minimize friction. Dense grid,
-  prominent prices, fast paths to cart, no recommendations.
-  Signals: high clicks/min, low dwell, high scroll depth, few hovers.
-- "deliberate": user is researching; help them compare. Larger cards,
-  reviews surfaced inline, "people also viewed", expandable detail.
-  Signals: low clicks/min, high dwell, hovers across multiple products.
-- "neutral": insufficient signal yet, or pattern is mixed. Baseline grid.
-  Default for first ~10 events.
-
-Examples:
-Input: {"clicks_per_min":14,"avg_dwell_ms":820,"scroll_depth":0.91,"hover_count":2,"events_seen":18}
-Output: {"variant":"decisive","confidence":0.86,"reasoning":"Fast clicks, low dwell, deep scroll \u2014 purposeful navigation."}
-
-Input: {"clicks_per_min":3,"avg_dwell_ms":7400,"scroll_depth":0.42,"hover_count":4,"events_seen":22}
-Output: {"variant":"deliberate","confidence":0.81,"reasoning":"Slow pace, long dwell, multi-product hover \u2014 comparing options."}
-
-Input: {"clicks_per_min":5,"avg_dwell_ms":2100,"scroll_depth":0.55,"hover_count":2,"events_seen":7}
-Output: {"variant":"neutral","confidence":0.6,"reasoning":"Not enough events yet to commit to a mode."}
-
-Return ONLY a JSON object. No prose, no markdown.
-`.trim();
-var VALID_VARIANTS = /* @__PURE__ */ new Set(["decisive", "deliberate", "neutral"]);
-var FALLBACK = {
-  variant: "neutral",
+// src/adapters/http.ts
+var FALLBACK_PLAN = {
+  adaptations: [],
   confidence: 0,
-  reasoning: "Classifier error."
+  reasoning: "HTTP adapter error."
 };
-function createGeminiClassifier(opts) {
-  const { apiKey, model = "gemini-2.0-flash", endpoint, fetchImpl } = opts;
-  const url = endpoint ?? `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`;
+function createHttpAdapter(opts) {
+  const {
+    url,
+    headers,
+    fetchImpl,
+    timeoutMs = 8e3,
+    bodyTransform,
+    responseTransform
+  } = opts;
   const fetcher = fetchImpl ?? (typeof fetch !== "undefined" ? fetch.bind(globalThis) : null);
-  return async (summary) => {
-    if (!fetcher) return FALLBACK;
+  return async (input) => {
+    if (!fetcher) return FALLBACK_PLAN;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), timeoutMs);
     try {
-      const res = await fetcher(`${url}?key=${encodeURIComponent(apiKey)}`, {
+      const body = bodyTransform ? bodyTransform(input) : input;
+      const res = await fetcher(url, {
         method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          systemInstruction: { parts: [{ text: CLASSIFIER_SYSTEM_PROMPT }] },
-          contents: [
-            {
-              role: "user",
-              parts: [{ text: JSON.stringify(summary) }]
-            }
-          ],
-          generationConfig: {
-            responseMimeType: "application/json",
-            temperature: 0.2
-          }
-        })
+        headers: { "content-type": "application/json", ...headers },
+        body: JSON.stringify(body),
+        signal: ac.signal
       });
-      if (!res.ok) return FALLBACK;
-      const data = await res.json();
-      const text = data.candidates?.[0]?.content?.parts?.[0]?.text;
-      if (!text) return FALLBACK;
-      const parsed = JSON.parse(text);
-      if (!parsed || typeof parsed !== "object" || typeof parsed.variant !== "string" || !VALID_VARIANTS.has(parsed.variant) || typeof parsed.reasoning !== "string") {
-        return FALLBACK;
-      }
-      const confidence = typeof parsed.confidence === "number" && Number.isFinite(parsed.confidence) ? Math.max(0, Math.min(1, parsed.confidence)) : 0.5;
-      return {
-        variant: parsed.variant,
-        confidence,
-        reasoning: parsed.reasoning
-      };
+      if (!res.ok) return FALLBACK_PLAN;
+      const raw = await res.json();
+      const plan = responseTransform ? responseTransform(raw) : raw;
+      if (!isValidPlan(plan)) return FALLBACK_PLAN;
+      return plan;
     } catch {
-      return FALLBACK;
+      return FALLBACK_PLAN;
+    } finally {
+      clearTimeout(timer);
     }
   };
 }
-
-// src/classifier/heuristic.ts
-function createHeuristicClassifier() {
-  return async (summary) => {
-    if (summary.events_seen < 10) {
-      return {
-        variant: "neutral",
-        confidence: 0.5,
-        reasoning: "Insufficient events."
-      };
-    }
-    if (summary.clicks_per_min > 8 && summary.avg_dwell_ms < 2e3) {
-      return {
-        variant: "decisive",
-        confidence: 0.8,
-        reasoning: "Fast pace, low dwell."
-      };
-    }
-    if (summary.avg_dwell_ms > 4e3 && summary.hover_count > 2) {
-      return {
-        variant: "deliberate",
-        confidence: 0.8,
-        reasoning: "Slow pace, multi-hover."
-      };
-    }
-    return {
-      variant: "neutral",
-      confidence: 0.6,
-      reasoning: "Mixed signals."
-    };
-  };
+function isValidPlan(p) {
+  if (!p || typeof p !== "object") return false;
+  const plan = p;
+  if (!Array.isArray(plan.adaptations)) return false;
+  if (typeof plan.confidence !== "number") return false;
+  if (typeof plan.reasoning !== "string") return false;
+  return true;
 }
 export {
+  AdaptationEngine,
   BeGenProvider,
-  BeGenSurface,
-  PERSONAS,
-  createGeminiClassifier,
-  createHeuristicClassifier,
+  createHttpAdapter,
+  snapshotVisibleSelectors,
   useBeGenContext,
   useBehaviorTracker
 };