sitepong 0.2.7 → 0.2.9

package/dist/entries/rn.js

@@ -9,12 +9,15 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var React2__default = /*#__PURE__*/_interopDefault(React2);
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/platforms/rn/environment.ts
 function createRNEnvironment(options = {}) {
@@ -42,8 +45,8 @@ function createRNEnvironment(options = {}) {
       return `SitePong-RN/${[osPart, devicePart].filter(Boolean).join("; ")}`;
     },
     onUncaughtError(handler) {
-      const g = globalThis;
-      const ErrorUtils2 = g.ErrorUtils;
+      const g2 = globalThis;
+      const ErrorUtils2 = g2.ErrorUtils;
       if (!ErrorUtils2 || !ErrorUtils2.setGlobalHandler || !ErrorUtils2.getGlobalHandler) {
         return () => {
         };
@@ -95,10 +98,10 @@ function getEnvironment() {
 }
 function detectPlatform() {
   if (currentEnv) return currentEnv.platform;
-  const g = globalThis;
-  if (g.navigator && g.navigator.product === "ReactNative") return "react-native";
-  if (g.process && g.process.versions && g.process.versions.node) return "node";
-  if (g.window && g.document) return "browser";
+  const g2 = globalThis;
+  if (g2.navigator && g2.navigator.product === "ReactNative") return "react-native";
+  if (g2.process && g2.process.versions && g2.process.versions.node) return "node";
+  if (g2.window && g2.document) return "browser";
   return "unknown";
 }
 function isReactNative() {
@@ -2138,98 +2141,98 @@ function extractIdentityMetadata(url) {
 // src/index.ts
 function installFallbackEnvironment() {
   if (getEnvironment()) return;
-  const g = globalThis;
-  const hasBrowser = typeof g.window !== "undefined" && typeof g.document !== "undefined";
-  const hasNode = !hasBrowser && !!g.process?.versions?.node;
+  const g2 = globalThis;
+  const hasBrowser = typeof g2.window !== "undefined" && typeof g2.document !== "undefined";
+  const hasNode = !hasBrowser && !!g2.process?.versions?.node;
   const platform2 = hasBrowser ? "browser" : "node";
   const env2 = {
     platform: platform2,
     storage: null,
     getDeviceInfo() {
       const info = { platform: platform2 };
-      if (g.navigator?.userAgent) info.userAgent = g.navigator.userAgent;
-      if (hasBrowser && g.window?.screen) {
-        info.screenWidth = g.window.screen.width;
-        info.screenHeight = g.window.screen.height;
+      if (g2.navigator?.userAgent) info.userAgent = g2.navigator.userAgent;
+      if (hasBrowser && g2.window?.screen) {
+        info.screenWidth = g2.window.screen.width;
+        info.screenHeight = g2.window.screen.height;
       }
-      if (hasNode && g.process) {
-        info.osName = g.process.platform;
-        info.osVersion = g.process.versions?.node;
+      if (hasNode && g2.process) {
+        info.osName = g2.process.platform;
+        info.osVersion = g2.process.versions?.node;
       }
       return info;
     },
     getCurrentUrl() {
-      return g.window?.location?.href ?? void 0;
+      return g2.window?.location?.href ?? void 0;
     },
     getReferrer() {
-      return g.document?.referrer || void 0;
+      return g2.document?.referrer || void 0;
     },
     getUserAgent() {
-      if (g.navigator?.userAgent) return g.navigator.userAgent;
-      if (hasNode && g.process) return `SitePong-Node/${g.process.versions?.node} (${g.process.platform})`;
+      if (g2.navigator?.userAgent) return g2.navigator.userAgent;
+      if (hasNode && g2.process) return `SitePong-Node/${g2.process.versions?.node} (${g2.process.platform})`;
       return void 0;
     },
     onUncaughtError(handler) {
-      if (hasBrowser && g.window?.addEventListener) {
+      if (hasBrowser && g2.window?.addEventListener) {
         const listener = (event) => handler(event.error || event.message);
-        g.window.addEventListener("error", listener);
-        return () => g.window?.removeEventListener?.("error", listener);
+        g2.window.addEventListener("error", listener);
+        return () => g2.window?.removeEventListener?.("error", listener);
       }
-      if (hasNode && g.process?.on && g.process.off) {
+      if (hasNode && g2.process?.on && g2.process.off) {
         const listener = (err) => handler(err);
-        g.process.on("uncaughtException", listener);
-        return () => g.process?.off?.("uncaughtException", listener);
+        g2.process.on("uncaughtException", listener);
+        return () => g2.process?.off?.("uncaughtException", listener);
       }
       return () => {
       };
     },
     onUnhandledRejection(handler) {
-      if (hasBrowser && g.window?.addEventListener) {
+      if (hasBrowser && g2.window?.addEventListener) {
         const listener = (event) => handler(event.reason);
-        g.window.addEventListener("unhandledrejection", listener);
-        return () => g.window?.removeEventListener?.("unhandledrejection", listener);
+        g2.window.addEventListener("unhandledrejection", listener);
+        return () => g2.window?.removeEventListener?.("unhandledrejection", listener);
       }
-      if (hasNode && g.process?.on && g.process.off) {
+      if (hasNode && g2.process?.on && g2.process.off) {
         const listener = (reason) => handler(reason);
-        g.process.on("unhandledRejection", listener);
-        return () => g.process?.off?.("unhandledRejection", listener);
+        g2.process.on("unhandledRejection", listener);
+        return () => g2.process?.off?.("unhandledRejection", listener);
       }
       return () => {
       };
     },
     onBeforeTerminate(handler) {
-      if (hasBrowser && g.window?.addEventListener) {
-        g.window.addEventListener("beforeunload", handler);
-        return () => g.window?.removeEventListener?.("beforeunload", handler);
+      if (hasBrowser && g2.window?.addEventListener) {
+        g2.window.addEventListener("beforeunload", handler);
+        return () => g2.window?.removeEventListener?.("beforeunload", handler);
       }
-      if (hasNode && g.process?.on && g.process.off) {
-        g.process.on("beforeExit", handler);
-        g.process.on("SIGINT", handler);
-        g.process.on("SIGTERM", handler);
+      if (hasNode && g2.process?.on && g2.process.off) {
+        g2.process.on("beforeExit", handler);
+        g2.process.on("SIGINT", handler);
+        g2.process.on("SIGTERM", handler);
         return () => {
-          g.process?.off?.("beforeExit", handler);
-          g.process?.off?.("SIGINT", handler);
-          g.process?.off?.("SIGTERM", handler);
+          g2.process?.off?.("beforeExit", handler);
+          g2.process?.off?.("SIGINT", handler);
+          g2.process?.off?.("SIGTERM", handler);
         };
       }
       return () => {
       };
     },
     onVisibilityHidden(handler) {
-      if (g.document?.addEventListener) {
+      if (g2.document?.addEventListener) {
         const listener = () => {
-          if (g.document?.visibilityState === "hidden") handler();
+          if (g2.document?.visibilityState === "hidden") handler();
         };
-        g.document.addEventListener("visibilitychange", listener);
-        return () => g.document?.removeEventListener?.("visibilitychange", listener);
+        g2.document.addEventListener("visibilitychange", listener);
+        return () => g2.document?.removeEventListener?.("visibilitychange", listener);
       }
       return () => {
       };
     },
     sendBeacon(url, body) {
-      if (typeof g.navigator?.sendBeacon !== "function") return false;
+      if (typeof g2.navigator?.sendBeacon !== "function") return false;
       try {
-        return g.navigator.sendBeacon(url, new Blob([body], { type: "application/json" }));
+        return g2.navigator.sendBeacon(url, new Blob([body], { type: "application/json" }));
       } catch {
         return false;
       }
@@ -3312,6 +3315,824 @@ function SensitiveView(props) {
   );
 }
 
+// ../watchtower-recorder/dist/index.mjs
+var CreateElementNode = (id, parentID, index, tag) => [8, id, parentID, index, tag];
+var CreateTextNode = (id, parentID, index) => [
+  9,
+  id,
+  parentID,
+  index
+];
+var MoveNode = (id, parentID, index) => [
+  10,
+  id,
+  parentID,
+  index
+];
+var RemoveNode = (id) => [11, id];
+var SetNodeAttribute = (id, name, value) => [
+  12,
+  id,
+  name,
+  value
+];
+var RemoveNodeAttribute = (id, name) => [
+  13,
+  id,
+  name
+];
+var SetNodeData = (id, data) => [14, id, data];
+var SetNodeScroll = (id, x, y) => [
+  16,
+  id,
+  x,
+  y
+];
+var MobileTap = (id, hesitationMs, label, selector, normX, normY) => [68, id, hesitationMs, label, selector, normX, normY];
+var ScreenView = (name, prevName) => [
+  200,
+  name,
+  prevName
+];
+var Frustration = (kind, nodeId, selector, count) => [201, kind, nodeId, selector, count];
+var TapOutcome = (tapNodeId, kind, label, mutationCount) => [202, tapNodeId, kind, label, mutationCount];
+function walk(root, visit) {
+  const rec = (node, parent, index) => {
+    visit(node, parent, index);
+    node.children.forEach((child, i) => rec(child, node, i));
+  };
+  if (root) rec(root, null, 0);
+}
+var Mirror = class {
+  constructor() {
+    __publicField(this, "ids", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "byId", /* @__PURE__ */ new Map());
+    __publicField(this, "next", 1);
+  }
+  // 0 is reserved for "no/root parent"
+  /** Existing id for a node, or undefined if never registered. */
+  peek(key) {
+    return this.ids.get(key);
+  }
+  /** Id for a node, assigning a fresh one on first sight. Second tuple element
+   *  is true when the id was just created (→ emit a Create* message). */
+  getId(key) {
+    const existing = this.ids.get(key);
+    if (existing !== void 0) return [existing, false];
+    const id = this.next++;
+    this.ids.set(key, id);
+    this.byId.set(id, key);
+    return [id, true];
+  }
+  getKey(id) {
+    return this.byId.get(id);
+  }
+  /** Drop a node's id (on unmount). Idempotent. */
+  release(key) {
+    const id = this.ids.get(key);
+    if (id === void 0) return void 0;
+    this.ids.delete(key);
+    this.byId.delete(id);
+    return id;
+  }
+  get size() {
+    return this.byId.size;
+  }
+};
+var emptyIndex = () => /* @__PURE__ */ new Map();
+function indexTree(tree, mirror, prev) {
+  const next = /* @__PURE__ */ new Map();
+  const order = [];
+  walk(tree, (node, parent, idx) => {
+    const [id] = mirror.getId(node.key);
+    const parentId = parent ? mirror.getId(parent.key)[0] : 0;
+    next.set(id, {
+      id,
+      parentId,
+      index: idx,
+      tag: node.tag,
+      attrs: node.attrs,
+      text: node.text
+    });
+    order.push(id);
+  });
+  return { next, order };
+}
+function attrDiff(id, prev, next) {
+  const out = [];
+  for (const k of Object.keys(next)) {
+    if (prev[k] !== next[k]) out.push(SetNodeAttribute(id, k, next[k]));
+  }
+  for (const k of Object.keys(prev)) {
+    if (!(k in next)) out.push(RemoveNodeAttribute(id, k));
+  }
+  return out;
+}
+function diff(prev, next, mirror) {
+  const { next: nextIndex, order } = indexTree(next, mirror);
+  const messages = [];
+  const removed = /* @__PURE__ */ new Set();
+  for (const id of prev.keys()) if (!nextIndex.has(id)) removed.add(id);
+  for (const id of removed) {
+    const rec = prev.get(id);
+    if (!removed.has(rec.parentId)) messages.push(RemoveNode(id));
+  }
+  for (const id of order) {
+    const rec = nextIndex.get(id);
+    const before = prev.get(id);
+    if (!before) {
+      if (rec.tag === "#text") {
+        messages.push(CreateTextNode(id, rec.parentId, rec.index));
+      } else {
+        messages.push(CreateElementNode(id, rec.parentId, rec.index, rec.tag));
+      }
+      for (const k of Object.keys(rec.attrs)) messages.push(SetNodeAttribute(id, k, rec.attrs[k]));
+      if (rec.text !== void 0 && rec.text !== "") messages.push(SetNodeData(id, rec.text));
+    } else {
+      if (before.parentId !== rec.parentId || before.index !== rec.index) {
+        messages.push(MoveNode(id, rec.parentId, rec.index));
+      }
+      messages.push(...attrDiff(id, before.attrs, rec.attrs));
+      if ((before.text ?? "") !== (rec.text ?? "")) messages.push(SetNodeData(id, rec.text ?? ""));
+    }
+  }
+  return { messages, index: nextIndex };
+}
+function stableAnchor(step) {
+  if (step.attrs.testID) return `@${step.attrs.testID}`;
+  if (step.attrs.nativeID) return `#${step.attrs.nativeID}`;
+  return null;
+}
+function computeSelector(path) {
+  if (path.length === 0) return "";
+  const self = path[path.length - 1];
+  const own = stableAnchor(self);
+  if (own) return own;
+  const parts = [];
+  for (let i = path.length - 1; i >= 0; i--) {
+    const step = path[i];
+    const anchor = stableAnchor(step);
+    if (anchor && i !== path.length - 1) {
+      parts.unshift(anchor);
+      return parts.join(" > ");
+    }
+    const a11y = step.attrs.accessibilityLabel;
+    const comp = step.attrs.rnComponent;
+    if (i === path.length - 1 && a11y) {
+      parts.unshift(`${step.tag}[a11y="${truncate(a11y)}"]`);
+    } else if (comp && comp !== step.tag) {
+      parts.unshift(`${comp}`);
+    } else {
+      parts.unshift(`${step.tag}:nth-of-type(${step.nthOfType})`);
+    }
+  }
+  return parts.join(" > ");
+}
+function truncate(s, n = 40) {
+  return s.length > n ? s.slice(0, n) : s;
+}
+function computeLabel(attrs, text) {
+  if (attrs.accessibilityLabel) return truncate(attrs.accessibilityLabel, 100);
+  if (attrs.testID) return attrs.testID;
+  if (text && text.trim()) return truncate(text.trim(), 100);
+  if (attrs.rnComponent) return attrs.rnComponent;
+  return "";
+}
+var RAGE_WINDOW_MS = 800;
+var RAGE_MIN_COUNT = 3;
+var OUTCOME_WINDOW_MS = 1e3;
+var TOGGLE_ATTR_MAX = 4;
+var OUTCOME_LABELS = {
+  navigated: "Navigated to a new screen",
+  opened_overlay: "Opened a modal / overlay",
+  closed_overlay: "Dismissed a modal / overlay",
+  toggled: "Toggled UI state",
+  content_changed: "Updated on-screen content",
+  no_effect: "Nothing changed (dead tap)"
+};
+var InteractionAnalyzer = class {
+  constructor() {
+    __publicField(this, "activity", []);
+    __publicField(this, "screenViews", []);
+    __publicField(this, "taps", []);
+  }
+  recordActivity(a) {
+    this.activity.push(a);
+  }
+  recordScreenView(t) {
+    this.screenViews.push(t);
+  }
+  /** Register a tap; returns whether it is (so far) a rage tap and the count. */
+  recordTap(tap) {
+    this.taps.push(tap);
+    const from = tap.t - RAGE_WINDOW_MS;
+    const sameSel = this.taps.filter((x) => x.selector === tap.selector && x.t >= from && x.t <= tap.t);
+    return { rage: sameSel.length >= RAGE_MIN_COUNT, count: sameSel.length };
+  }
+  /**
+   * Evaluate a tap once its outcome window has closed. Classifies the post-tap
+   * mutation diff into a semantic outcome and flags dead/rage.
+   */
+  evaluate(tap) {
+    const end = tap.t + OUTCOME_WINDOW_MS;
+    const win = this.activity.filter((a) => a.t > tap.t && a.t <= end);
+    const navigated = this.screenViews.some((t) => t > tap.t && t <= end);
+    const sum = (f) => win.reduce((n, a) => n + f(a), 0);
+    const structural = sum((a) => a.create) + sum((a) => a.remove) + sum((a) => a.move);
+    const attrs = sum((a) => a.attr) + sum((a) => a.text);
+    const mutationCount = structural + attrs;
+    const overlayAdd = win.some((a) => a.overlayAdd);
+    const overlayRemove = win.some((a) => a.overlayRemove);
+    let kind;
+    if (navigated) kind = "navigated";
+    else if (overlayAdd) kind = "opened_overlay";
+    else if (overlayRemove) kind = "closed_overlay";
+    else if (mutationCount === 0) kind = "no_effect";
+    else if (structural === 0 && attrs <= TOGGLE_ATTR_MAX) kind = "toggled";
+    else kind = "content_changed";
+    const from = tap.t - RAGE_WINDOW_MS;
+    const rageCount = this.taps.filter(
+      (x) => x.selector === tap.selector && x.t >= from && x.t <= tap.t
+    ).length;
+    let frustration = null;
+    if (kind === "no_effect") frustration = { kind: "dead", count: 1 };
+    if (rageCount >= RAGE_MIN_COUNT) frustration = { kind: "rage", count: rageCount };
+    return { frustration, outcome: { kind, label: OUTCOME_LABELS[kind], mutationCount } };
+  }
+};
+var OVERLAY_TAGS = /* @__PURE__ */ new Set(["Modal"]);
+function isOverlayRecord(tag, attrs) {
+  if (tag && OVERLAY_TAGS.has(tag)) return true;
+  if (attrs && (attrs.wtOverlay === "true" || attrs.role === "dialog")) return true;
+  return false;
+}
+var Recorder = class {
+  constructor() {
+    __publicField(this, "mirror", new Mirror());
+    __publicField(this, "index", emptyIndex());
+    __publicField(this, "analyzer", new InteractionAnalyzer());
+    __publicField(this, "stream", []);
+    __publicField(this, "pending", []);
+    __publicField(this, "viewport", { w: 0, h: 0 });
+  }
+  emit(t, m) {
+    this.stream.push({ t, m });
+  }
+  setViewport(w, h, t) {
+    this.viewport = { w, h };
+    this.emit(t, [5, w, h]);
+  }
+  /** Feed a fresh tree snapshot; diffs against the last and streams mutations. */
+  commit(tree, t) {
+    const prev = this.index;
+    const { messages, index } = diff(prev, tree, this.mirror);
+    for (const m of messages) this.emit(t, m);
+    const newIds = /* @__PURE__ */ new Set();
+    for (const m of messages) {
+      if (m[0] === 8 || m[0] === 9) newIds.add(m[1]);
+    }
+    let create = 0, remove = 0, move = 0, attr = 0, text = 0;
+    let overlayAdd = false, overlayRemove = false;
+    for (const m of messages) {
+      switch (m[0]) {
+        case 8:
+          create++;
+          if (isOverlayRecord(index.get(m[1])?.tag, index.get(m[1])?.attrs)) overlayAdd = true;
+          break;
+        case 9:
+          create++;
+          break;
+        case 11:
+          remove++;
+          if (isOverlayRecord(prev.get(m[1])?.tag, prev.get(m[1])?.attrs)) overlayRemove = true;
+          break;
+        case 10:
+          move++;
+          break;
+        case 12:
+        case 13:
+          if (!newIds.has(m[1])) attr++;
+          break;
+        case 14:
+          if (!newIds.has(m[1])) text++;
+          break;
+      }
+    }
+    const activity = { t, create, remove, move, attr, text, overlayAdd, overlayRemove };
+    this.analyzer.recordActivity(activity);
+    this.index = index;
+    this.drainPending(t);
+  }
+  tap(input, t) {
+    const [id] = this.mirror.getId(input.key);
+    const selector = computeSelector(input.path);
+    const label = computeLabel(input.attrs, input.text);
+    const nx = Math.round(input.normX * 1e4);
+    const ny = Math.round(input.normY * 1e4);
+    this.emit(t, MobileTap(id, input.hesitationMs ?? 0, label, selector, nx, ny));
+    this.analyzer.recordTap({ t, nodeId: id, selector });
+    this.pending.push({ t, nodeId: id, selector });
+    this.drainPending(t);
+  }
+  screenView(name, prevName, t) {
+    this.emit(t, ScreenView(name, prevName));
+    this.analyzer.recordScreenView(t);
+    this.drainPending(t);
+  }
+  /** Record a scroll offset for a node (absolute content offset, px). The player
+   *  translates the node's children by (-x,-y), reproducing the scroll/drag —
+   *  the RN fiber walk can't see native-driven scroll, so it's fed from gestures. */
+  scroll(key, x, y, t) {
+    const [id] = this.mirror.getId(key);
+    this.emit(t, SetNodeScroll(id, Math.round(x), Math.round(y)));
+  }
+  /** Record a node scroll/offset change (from a drag/scroll gesture). */
+  setNodeScroll(nodeId, scrollX, scrollY, t) {
+    this.emit(t, [16, nodeId, scrollX, scrollY]);
+  }
+  /** Evaluate any pending taps whose outcome window has closed by time `t`. */
+  drainPending(t) {
+    const ready = this.pending.filter((p) => t >= p.t + OUTCOME_WINDOW_MS);
+    if (!ready.length) return;
+    this.pending = this.pending.filter((p) => t < p.t + OUTCOME_WINDOW_MS);
+    for (const p of ready) this.evaluateTap(p);
+  }
+  evaluateTap(p) {
+    const at = p.t + OUTCOME_WINDOW_MS;
+    const v = this.analyzer.evaluate(p);
+    if (v.frustration) {
+      this.emit(at, Frustration(v.frustration.kind, p.nodeId, p.selector, v.frustration.count));
+    }
+    this.emit(at, TapOutcome(p.nodeId, v.outcome.kind, v.outcome.label, v.outcome.mutationCount));
+  }
+  /** Explicit clock advance (adapter ticker) to close outcome windows even when
+   *  no commit/tap arrives. */
+  advance(t) {
+    this.drainPending(t);
+  }
+  /** Flush all remaining pending taps (session end). `_t` is the session-end
+   *  clock, accepted for API symmetry with advance(); evaluation uses each tap's
+   *  own outcome window. */
+  finalize(_t) {
+    const ready = this.pending;
+    this.pending = [];
+    for (const p of ready) this.evaluateTap(p);
+    this.stream.sort((a, b) => a.t - b.t);
+  }
+  getStream() {
+    return [...this.stream].sort((a, b) => a.t - b.t);
+  }
+  /** Total messages emitted so far (insertion order). Adapters use this as the
+   *  cursor for incremental delta flushing — see `sliceStream`. */
+  get emittedCount() {
+    return this.stream.length;
+  }
+  /** Messages emitted since insertion index `from`, in EMISSION order (not
+   *  sorted by time). This is the delta an adapter ships each flush; the cursor
+   *  is the count it last confirmed stored. Late-drained outcome messages (whose
+   *  `t` is earlier than emission time) appear here at their emission position,
+   *  so the server appends verbatim and the reader sorts by `t`. */
+  sliceStream(from) {
+    return this.stream.slice(Math.max(0, from));
+  }
+  get viewportSize() {
+    return this.viewport;
+  }
+};
+
+// src/react-native/structural/install-hook.ts
+var g = globalThis;
+var hookState = g.__SITEPONG_STRUCTURAL_HOOK_STATE__ ?? (g.__SITEPONG_STRUCTURAL_HOOK_STATE__ = {
+  latestRoot: null,
+  dirty: false
+});
+function record(root) {
+  hookState.latestRoot = root;
+  hookState.dirty = true;
+}
+function installStructuralHook() {
+  if (g.__SITEPONG_STRUCTURAL_HOOK_INSTALLED__) return;
+  const existing = g.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (existing) {
+    const prevRaw = existing.onCommitFiberRoot;
+    const prev = typeof prevRaw === "function" ? prevRaw.bind(existing) : null;
+    existing.onCommitFiberRoot = (id, root, ...rest) => {
+      record(root);
+      return prev ? prev(id, root, ...rest) : void 0;
+    };
+  } else {
+    const renderers = /* @__PURE__ */ new Map();
+    g.__REACT_DEVTOOLS_GLOBAL_HOOK__ = {
+      renderers,
+      supportsFiber: true,
+      inject(renderer) {
+        const id = renderers.size + 1;
+        renderers.set(id, renderer);
+        return id;
+      },
+      onCommitFiberRoot(_id, root) {
+        record(root);
+      },
+      onCommitFiberUnmount() {
+      },
+      onScheduleFiberRoot() {
+      },
+      on() {
+      },
+      off() {
+      },
+      sub() {
+        return () => {
+        };
+      },
+      checkDCE() {
+      }
+    };
+  }
+  g.__SITEPONG_STRUCTURAL_HOOK_INSTALLED__ = true;
+}
+var HostComponent = 5;
+var HostText = 6;
+function mapTag(type) {
+  if (typeof type !== "string") return "View";
+  const t = type;
+  if (/TextInput|TextField/i.test(t)) return "TextInput";
+  if (/Image/i.test(t)) return "Image";
+  if (/ScrollView/i.test(t)) return "ScrollView";
+  if (/Modal/i.test(t)) return "Modal";
+  if (/Text|RawText/i.test(t)) return "Text";
+  if (/Pressable|Button|Touchable/i.test(t)) return "Pressable";
+  return "View";
+}
+function nativeTagOf(stateNode) {
+  if (!stateNode) return void 0;
+  return stateNode.__nativeTag ?? stateNode._nativeTag ?? stateNode.canonical?.nativeTag ?? stateNode.canonical?._nativeTag ?? (typeof stateNode === "number" ? stateNode : void 0);
+}
+var STYLE_KEYS = /* @__PURE__ */ new Set([
+  "flex",
+  "flexDirection",
+  "flexGrow",
+  "flexShrink",
+  "flexWrap",
+  "alignItems",
+  "alignSelf",
+  "justifyContent",
+  "width",
+  "height",
+  "minWidth",
+  "minHeight",
+  "maxWidth",
+  "maxHeight",
+  "margin",
+  "marginTop",
+  "marginBottom",
+  "marginLeft",
+  "marginRight",
+  "marginHorizontal",
+  "marginVertical",
+  "padding",
+  "paddingTop",
+  "paddingBottom",
+  "paddingLeft",
+  "paddingRight",
+  "paddingHorizontal",
+  "paddingVertical",
+  "backgroundColor",
+  "borderRadius",
+  "borderWidth",
+  "borderColor",
+  "opacity",
+  "position",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  "color",
+  "fontSize",
+  "fontWeight",
+  "textAlign",
+  "lineHeight",
+  "gap",
+  "overflow",
+  "shadowColor",
+  "shadowOpacity",
+  "shadowRadius",
+  "elevation",
+  "transform",
+  "zIndex",
+  "aspectRatio"
+]);
+function extractStyle(style) {
+  try {
+    const flat = reactNative.StyleSheet.flatten(style);
+    if (!flat) return void 0;
+    const out = {};
+    for (const k of Object.keys(flat)) if (STYLE_KEYS.has(k)) out[k] = flat[k];
+    return Object.keys(out).length ? JSON.stringify(out) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function extractAttrs(tag, props, componentName2) {
+  const attrs = {};
+  if (!props) return attrs;
+  if (props.testID) attrs.testID = String(props.testID);
+  if (props.nativeID) attrs.nativeID = String(props.nativeID);
+  if (props.accessibilityLabel) attrs.accessibilityLabel = String(props.accessibilityLabel);
+  if (props.accessibilityRole) attrs.role = String(props.accessibilityRole);
+  if (props["aria-label"]) attrs.accessibilityLabel = String(props["aria-label"]);
+  const style = extractStyle(props.style);
+  if (style) attrs.style = style;
+  if (tag === "Image") {
+    const uri = props.source?.uri ?? (typeof props.source === "string" ? props.source : void 0);
+    if (uri) attrs.src = String(uri);
+  }
+  if (componentName2) attrs.rnComponent = componentName2;
+  if (props.wtOverlay || props.accessibilityViewIsModal) attrs.wtOverlay = "true";
+  if (props.wtSensitive || props.secureTextEntry) attrs.wtSensitive = "true";
+  return attrs;
+}
+function collectText(fiber) {
+  let out = "";
+  const visit = (f) => {
+    if (!f) return;
+    if (f.tag === HostText) {
+      const p = f.memoizedProps;
+      if (typeof p === "string") out += p;
+      else if (p && typeof p.text === "string") out += p.text;
+    } else if (f.tag === HostComponent && typeof f.type === "string" && /RawText|VirtualText/i.test(f.type)) {
+      const p = f.memoizedProps;
+      if (p && typeof p.text === "string") out += p.text;
+    }
+    visit(f.child);
+    visit(f.sibling);
+  };
+  visit(fiber.child);
+  return out;
+}
+function buildHostChildren(fiber, inheritedName, index, path, scrollTag) {
+  const out = [];
+  let f = fiber;
+  while (f) {
+    collectFrom(f, inheritedName, out, index, path, scrollTag);
+    f = f.sibling;
+  }
+  return out;
+}
+function componentName(fiber) {
+  const t = fiber?.type;
+  if (typeof t === "function") return t.displayName || t.name || void 0;
+  if (t && typeof t === "object") return t.displayName || void 0;
+  return void 0;
+}
+function collectFrom(fiber, inheritedName, out, index, parentPath, scrollTag) {
+  if (!fiber) return;
+  if (fiber.tag === HostComponent) {
+    const tag = mapTag(fiber.type);
+    const attrs = extractAttrs(tag, fiber.memoizedProps, inheritedName);
+    const stateNode = fiber.stateNode;
+    const key = stateNode && typeof stateNode === "object" ? stateNode : fiber;
+    const isTextLeaf = tag === "Text";
+    const text = isTextLeaf ? collectText(fiber) : void 0;
+    const nthOfType = out.filter((n) => n.tag === tag).length + 1;
+    const myPath = [...parentPath, { tag, attrs, nthOfType }];
+    const nt = nativeTagOf(stateNode);
+    const childScrollTag = tag === "ScrollView" && nt !== void 0 ? nt : scrollTag;
+    const children = isTextLeaf ? [] : buildHostChildren(fiber.child, void 0, index, myPath, childScrollTag);
+    const vnode = { key, tag, attrs, children, ...text ? { text } : {} };
+    out.push(vnode);
+    if (nt !== void 0) index.set(nt, { node: vnode, path: myPath, scrollAncestorTag: scrollTag });
+    return;
+  }
+  const name = componentName(fiber) ?? inheritedName;
+  let child = fiber.child;
+  while (child) {
+    collectFrom(child, name, out, index, parentPath, scrollTag);
+    child = child.sibling;
+  }
+}
+function walkFiberRoot(root) {
+  const index = /* @__PURE__ */ new Map();
+  const current = root?.current;
+  if (!current) return { tree: null, index };
+  const rootKey = root ?? current;
+  const children = buildHostChildren(current.child, void 0, index, [], void 0);
+  const tree = { key: rootKey, tag: "View", attrs: { style: JSON.stringify({ flex: 1 }) }, children };
+  return { tree, index };
+}
+
+// src/react-native/structural/capture.ts
+var WALK_BUDGET_MS = 24;
+var MAX_OVERLOAD_SKIP = 8;
+function genSessionId() {
+  const rand = Math.floor(Math.random() * 16777215).toString(36);
+  return `wt-${Date.now().toString(36)}-${rand}`;
+}
+var StructuralCapture = class {
+  constructor() {
+    this.recorder = new Recorder();
+    this.currentIndex = /* @__PURE__ */ new Map();
+    this.started = 0;
+    this.sampleTimer = null;
+    this.flushTimer = null;
+    this.screen = "";
+    this.prevScreen = "";
+    this.cfg = null;
+    this.sessionId = "";
+    this.running = false;
+    // Incremental delivery: cursor into the recorder's emission stream that has
+    // been CONFIRMED stored. Everything at index >= sentCount is unsent (the
+    // offline buffer). Advances only on a 2xx.
+    this.sentCount = 0;
+    this.flushing = false;
+    // Persistent per-ScrollView content offset (keyed by native tag), so scroll
+    // continues from where it was rather than resetting each gesture.
+    this.scrollOffsets = /* @__PURE__ */ new Map();
+    // Adaptive sampling: skip this many upcoming ticks after a heavy walk.
+    this.overloadSkip = 0;
+    this.appStateSub = null;
+    this.teardowns = [];
+  }
+  now() {
+    return Date.now() - this.started;
+  }
+  isRunning() {
+    return this.running;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  start(cfg) {
+    if (this.running) return;
+    installStructuralHook();
+    this.cfg = cfg;
+    this.sessionId = cfg.sessionId || genSessionId();
+    this.started = Date.now();
+    this.running = true;
+    this.sentCount = 0;
+    this.scrollOffsets.clear();
+    this.overloadSkip = 0;
+    const { width, height } = reactNative.Dimensions.get("window");
+    this.recorder.setViewport(Math.round(width), Math.round(height), 0);
+    this.sampleTimer = setInterval(() => this.sample(), cfg.sampleIntervalMs ?? 120);
+    this.flushTimer = setInterval(() => void this.flush(), cfg.flushIntervalMs ?? 4e3);
+    this.installCrashFlush();
+    this.installBackgroundFlush();
+    if (cfg.debug) console.log("[structural] started", this.sessionId);
+    setTimeout(() => this.sample(true), 0);
+  }
+  /** Best-effort flush the pre-crash tail before the app tears down. */
+  installCrashFlush() {
+    if (typeof ErrorUtils === "undefined" || typeof ErrorUtils.setGlobalHandler !== "function") return;
+    const prev = ErrorUtils.getGlobalHandler?.();
+    ErrorUtils.setGlobalHandler((error, isFatal) => {
+      void this.flush();
+      if (typeof prev === "function") prev(error, isFatal);
+    });
+    this.teardowns.push(() => {
+      if (typeof prev === "function") ErrorUtils.setGlobalHandler(prev);
+    });
+  }
+  /** Flush on background/inactive so timer suspension doesn't strand the tail. */
+  installBackgroundFlush() {
+    const onChange = (state) => {
+      if (state === "background" || state === "inactive") void this.flush();
+    };
+    this.appStateSub = reactNative.AppState.addEventListener("change", onChange);
+    this.teardowns.push(() => {
+      this.appStateSub?.remove();
+      this.appStateSub = null;
+    });
+  }
+  sample(force = false) {
+    if (!this.running) return;
+    if (!force && this.overloadSkip > 0) {
+      this.overloadSkip--;
+      return;
+    }
+    if (!force && !hookState.dirty) return;
+    hookState.dirty = false;
+    const root = hookState.latestRoot;
+    if (!root) return;
+    const t0 = Date.now();
+    try {
+      const { tree, index } = walkFiberRoot(root);
+      this.currentIndex = index;
+      this.recorder.commit(tree, this.now());
+    } catch (e) {
+      if (this.cfg?.debug) console.log("[structural] sample error", String(e));
+    }
+    const cost = Date.now() - t0;
+    if (cost > WALK_BUDGET_MS) {
+      this.overloadSkip = Math.min(MAX_OVERLOAD_SKIP, Math.ceil(cost / WALK_BUDGET_MS));
+    }
+  }
+  setScreen(name) {
+    if (!this.running || name === this.screen) return;
+    this.prevScreen = this.screen;
+    this.screen = name;
+    this.sample(true);
+    this.recorder.screenView(name, this.prevScreen, this.now());
+  }
+  /** Resolve a native touch to a node + emit a tap. `target` is the RN
+   *  nativeTag from `nativeEvent.target`. */
+  handleTap(target, pageX, pageY) {
+    if (!this.running) return;
+    const entry = this.currentIndex.get(target);
+    if (!entry) return;
+    const { width, height } = reactNative.Dimensions.get("window");
+    this.recorder.tap(
+      {
+        key: entry.node.key,
+        path: entry.path,
+        attrs: entry.node.attrs,
+        text: entry.node.text,
+        normX: pageX / (width || 1),
+        normY: pageY / (height || 1)
+      },
+      this.now()
+    );
+  }
+  /** Feed a scroll/drag delta from a touch onto the nearest scrollable ancestor
+   *  of the touched node. `target` is the RN nativeTag under the finger; `dx`/`dy`
+   *  are content-offset deltas (px, sign = content motion). Native-driven scroll
+   *  never reaches the fiber walk, so this is the only way the replay can ride the
+   *  scroll instead of freezing on a stale frame. */
+  handleScroll(target, dx, dy) {
+    if (!this.running) return;
+    const leaf = this.currentIndex.get(target);
+    const scrollTag = leaf?.scrollAncestorTag;
+    if (scrollTag === void 0) return;
+    const scrollable = this.currentIndex.get(scrollTag);
+    if (!scrollable) return;
+    const cur = this.scrollOffsets.get(scrollTag) ?? { x: 0, y: 0 };
+    const next = { x: Math.max(0, cur.x + dx), y: Math.max(0, cur.y + dy) };
+    if (Math.abs(next.x - cur.x) < 1 && Math.abs(next.y - cur.y) < 1) return;
+    this.scrollOffsets.set(scrollTag, next);
+    this.recorder.scroll(scrollable.node.key, next.x, next.y, this.now());
+  }
+  /** Public best-effort flush — used by the shared RN error handler to push the
+   *  pre-crash tail (the in-class ErrorUtils hook covers apps that don't call
+   *  setupRNErrorHandler; both are idempotent via the `flushing` guard). */
+  async flushNow() {
+    await this.flush();
+  }
+  async flush() {
+    if (!this.cfg || this.flushing) return;
+    this.recorder.advance(this.now());
+    const from = this.sentCount;
+    const batch = this.recorder.sliceStream(from);
+    if (batch.length === 0) return;
+    this.flushing = true;
+    const vp = this.recorder.viewportSize;
+    try {
+      const headers = {
+        "content-type": "application/json",
+        "X-API-Key": this.cfg.apiKey
+      };
+      if (this.cfg.projectId) headers["X-Project-ID"] = this.cfg.projectId;
+      const res = await fetch(`${this.cfg.endpoint.replace(/\/$/, "")}/api/replay-stream`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          session_id: this.sessionId,
+          platform: this.cfg.platform,
+          viewport: { w: vp.w, h: vp.h },
+          seq_start: from,
+          messages: batch
+        })
+      });
+      if (res.ok) {
+        this.sentCount = from + batch.length;
+        if (this.cfg.debug) console.log("[structural] flushed", batch.length, "msgs @", from);
+      } else if (this.cfg.debug) {
+        console.log("[structural] flush rejected", res.status, "\u2014 will retry");
+      }
+    } catch (e) {
+      if (this.cfg.debug) console.log("[structural] flush failed", String(e), "\u2014 buffered");
+    } finally {
+      this.flushing = false;
+    }
+  }
+  async stop() {
+    if (!this.running) return;
+    this.recorder.finalize(this.now());
+    if (this.sampleTimer) clearInterval(this.sampleTimer);
+    if (this.flushTimer) clearInterval(this.flushTimer);
+    this.sampleTimer = null;
+    this.flushTimer = null;
+    this.running = false;
+    for (const t of this.teardowns.splice(0)) {
+      try {
+        t();
+      } catch {
+      }
+    }
+    await this.flush();
+  }
+};
+var structuralCapture = new StructuralCapture();
+
 // src/react-native/error-handler.ts
 function setupRNErrorHandler(options = {}) {
   const {
@@ -3332,6 +4153,10 @@ function setupRNErrorHandler(options = {}) {
         });
         flushScreenRecording().catch(() => {
         });
+        if (structuralCapture.isRunning()) {
+          void structuralCapture.flushNow().catch(() => {
+          });
+        }
       }
       if (previousHandler) {
         previousHandler(error, isFatal);
@@ -3352,6 +4177,10 @@ function setupRNErrorHandler(options = {}) {
         });
         flushScreenRecording().catch(() => {
         });
+        if (structuralCapture.isRunning()) {
+          void structuralCapture.flushNow().catch(() => {
+          });
+        }
       };
       if (typeof globalThis.addEventListener === "function") {
         globalThis.addEventListener("unhandledrejection", rejectionHandler);
@@ -3905,6 +4734,60 @@ function WatchtowerProvider(props) {
   }, []);
   return React2__default.default.createElement(React2__default.default.Fragment, null, children);
 }
+var TAP_MOVE_THRESHOLD_PX = 12;
+function StructuralCaptureProvider({ children, ...cfg }) {
+  const cfgRef = React2.useRef(cfg);
+  cfgRef.current = cfg;
+  React2.useEffect(() => {
+    structuralCapture.start(cfgRef.current);
+    return () => {
+      void structuralCapture.stop();
+    };
+  }, []);
+  const gesture = React2.useRef(null);
+  const onTouchStart = (e) => {
+    const ne = e.nativeEvent;
+    gesture.current = {
+      startX: ne.pageX,
+      startY: ne.pageY,
+      lastX: ne.pageX,
+      lastY: ne.pageY,
+      target: Number(ne.target),
+      scrolling: false
+    };
+  };
+  const onTouchMove = (e) => {
+    const g2 = gesture.current;
+    if (!g2) return;
+    const ne = e.nativeEvent;
+    const movedFar = Math.abs(ne.pageX - g2.startX) > TAP_MOVE_THRESHOLD_PX || Math.abs(ne.pageY - g2.startY) > TAP_MOVE_THRESHOLD_PX;
+    if (movedFar) g2.scrolling = true;
+    if (g2.scrolling) {
+      const dx = g2.lastX - ne.pageX;
+      const dy = g2.lastY - ne.pageY;
+      structuralCapture.handleScroll(g2.target, dx, dy);
+    }
+    g2.lastX = ne.pageX;
+    g2.lastY = ne.pageY;
+  };
+  const onTouchEnd = (e) => {
+    const g2 = gesture.current;
+    gesture.current = null;
+    if (!g2) return;
+    if (g2.scrolling) return;
+    const ne = e.nativeEvent;
+    if (Math.abs(ne.pageX - g2.startX) > TAP_MOVE_THRESHOLD_PX || Math.abs(ne.pageY - g2.startY) > TAP_MOVE_THRESHOLD_PX) {
+      return;
+    }
+    structuralCapture.handleTap(g2.target, ne.pageX, ne.pageY);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { flex: 1 }, onTouchStart, onTouchMove, onTouchEnd, children });
+}
+function useStructuralScreen(name) {
+  React2.useEffect(() => {
+    structuralCapture.setScreen(name);
+  }, [name]);
+}
 
 // src/react-native/sqlite-tracker.ts
 function now() {
@@ -4326,6 +5209,8 @@ exports.RNAutocaptureModule = RNAutocaptureModule;
 exports.RNPerformanceManager = RNPerformanceManager;
 exports.SensitiveView = SensitiveView;
 exports.SitePongRNProvider = SitePongRNProvider;
+exports.StructuralCapture = StructuralCapture;
+exports.StructuralCaptureProvider = StructuralCaptureProvider;
 exports.WatchtowerProvider = WatchtowerProvider;
 exports.addBreadcrumb = addBreadcrumb;
 exports.addSensitiveView = addSensitiveView;
@@ -4360,6 +5245,7 @@ exports.handleUniversalLink = handleUniversalLink;
 exports.identify = identify2;
 exports.initRN = initRN;
 exports.initSuperLinkRN = initSuperLinkRN;
+exports.installStructuralHook = installStructuralHook;
 exports.isInitialized = isInitialized;
 exports.isRemoteConfigFeatureEnabled = isRemoteConfigFeatureEnabled;
 exports.isScreenRecording = isScreenRecording;
@@ -4391,6 +5277,7 @@ exports.startWatchtower = startWatchtower;
 exports.stopScreenRecording = stopScreenRecording;
 exports.stopWatchtower = stopWatchtower;
 exports.stopWidgetSync = stopWidgetSync;
+exports.structuralCapture = structuralCapture;
 exports.subscribeNavigationToWatchtower = subscribeNavigationToWatchtower;
 exports.superlinkIdentify = identify3;
 exports.syncWidgets = syncWidgets;
@@ -4403,6 +5290,7 @@ exports.useRNPerformance = useRNPerformance;
 exports.useRemoteConfig = useRemoteConfig;
 exports.useScreenTrack = useScreenTrack;
 exports.useSitePongRNContext = useSitePongRNContext;
+exports.useStructuralScreen = useStructuralScreen;
 exports.waitForFlags = waitForFlags;
 //# sourceMappingURL=rn.js.map
 //# sourceMappingURL=rn.js.map