@appilots/sdk 0.2.0

package/dist/chunk-SIBKF7AA.js

@@ -0,0 +1,2395 @@
+'use strict';
+
+var React2 = require('react');
+var reactNative = require('react-native');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React2__default = /*#__PURE__*/_interopDefault(React2);
+
+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');
+});
+
+// src/version.ts
+var SDK_VERSION = "0.1.0";
+
+// src/services/AppilotsClient.ts
+var StreamTransportError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StreamTransportError";
+  }
+};
+var StreamAbortError = class extends Error {
+  partialContent;
+  constructor(partialContent) {
+    super("Stream aborted by caller");
+    this.name = "AbortError";
+    this.partialContent = partialContent;
+  }
+};
+var CONTINUATION_TIMEOUT_MS = 15e4;
+var AppilotsClient = class {
+  baseUrl;
+  projectId;
+  headers;
+  timeout;
+  debug;
+  mcpVersion;
+  user;
+  sessionId = null;
+  /** Guard so identify fires at most once per client instance. */
+  identified = false;
+  constructor(options) {
+    this.projectId = options.projectId;
+    this.baseUrl = (options.apiBaseUrl ?? "https://api.appilots.com").replace(/\/$/, "");
+    this.timeout = options.timeout ?? 6e4;
+    this.debug = options.debug ?? false;
+    this.mcpVersion = options.mcpVersion;
+    this.user = options.user;
+    this.headers = {
+      "Content-Type": "application/json",
+      // Version telemetry: lets the server correlate behavior per SDK
+      // release and pick the MCP doc matching this app build (B.4).
+      "X-Appilots-Sdk-Version": SDK_VERSION,
+      ...options.appVersion ? { "X-App-Version": options.appVersion } : {},
+      ...options.mcpVersion ? { "X-Appilots-Mcp-Version": options.mcpVersion } : {},
+      ...options.apiKey ? { Authorization: `Bearer ${options.apiKey}` } : {},
+      ...options.headers
+    };
+  }
+  log(...args) {
+    if (this.debug) console.log("[AppilotsClient]", ...args);
+  }
+  describeNonJsonResponse(url, response, body) {
+    const contentType = response.headers?.get?.("content-type") ?? "unknown content-type";
+    const snippet = body.replace(/\s+/g, " ").trim().slice(0, 120);
+    const looksHtml = /^\s*</.test(body) || contentType.includes("text/html");
+    const hint = looksHtml && this.baseUrl.includes("localhost:3000") ? " This looks like the web dashboard/dev server. For local Docker, use http://localhost:4000/api/v1 as apiBaseUrl." : "";
+    return `Appilots API returned non-JSON response for ${url} (status=${response.status}, content-type=${contentType}).${hint}` + (snippet ? ` Body starts with: ${JSON.stringify(snippet)}` : "");
+  }
+  async request(path, options = {}, timeoutMs = this.timeout) {
+    const url = `${this.baseUrl}${path}`;
+    this.log(`${options.method ?? "GET"} ${url}`);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: { ...this.headers, ...options.headers },
+        signal: controller.signal
+      });
+      const body = await response.text();
+      let json = null;
+      if (body.length > 0) {
+        try {
+          json = JSON.parse(body);
+        } catch {
+          throw new Error(this.describeNonJsonResponse(url, response, body));
+        }
+      }
+      if (!response.ok) {
+        const errorMsg = json?.error?.message ?? json?.error ?? `HTTP ${response.status}`;
+        throw new Error(errorMsg);
+      }
+      return json.data ?? json;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  // ── Session ───────────────────────────────────────────────────
+  async createSession(userId, deviceInfo) {
+    const data = await this.request("/agent/session", {
+      method: "POST",
+      // Fall back to the configured user's id so sessions carry the
+      // externalUserId even when callers don't thread it through
+      // (useAppilotsChat auto-creates sessions with no args).
+      body: JSON.stringify({ userId: userId ?? this.user?.id, deviceInfo })
+    });
+    this.sessionId = data.sessionId;
+    this.log("Session created:", this.sessionId);
+    void this.identifyConfiguredUser();
+    return this.sessionId;
+  }
+  /**
+   * Upsert the configured user into the end-users registry. Fires once
+   * per client, after the first session opens; fire-and-forget — a
+   * failed identify must never break the chat.
+   */
+  async identifyConfiguredUser() {
+    if (this.identified) return;
+    const user = this.user;
+    if (!user?.id || !user.name && !user.identifiers) return;
+    this.identified = true;
+    try {
+      await this.request("/agent/identify", {
+        method: "POST",
+        body: JSON.stringify({
+          userId: user.id,
+          ...user.name ? { name: user.name } : {},
+          ...user.identifiers ? { identifiers: user.identifiers } : {}
+        })
+      });
+      this.log("User identified:", user.id);
+    } catch (err) {
+      this.identified = false;
+      this.log("identify failed (suppressed):", err);
+    }
+  }
+  async destroySession() {
+    if (!this.sessionId) return;
+    try {
+      await this.request(`/agent/session/${this.sessionId}`, { method: "DELETE" });
+      this.log("Session destroyed:", this.sessionId);
+    } finally {
+      this.sessionId = null;
+    }
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  // ── Messages ──────────────────────────────────────────────────
+  async sendMessage(content, context) {
+    if (!this.sessionId) {
+      await this.createSession();
+    }
+    const data = await this.request("/agent/message", {
+      method: "POST",
+      body: JSON.stringify({
+        content,
+        sessionId: this.sessionId,
+        context,
+        // Optional MCP version bundled with this app build. Server
+        // compares vs the active MCP doc to detect stale uploads.
+        ...this.mcpVersion ? { mcpVersion: this.mcpVersion } : {}
+      })
+    });
+    if (data.sessionId) {
+      this.sessionId = data.sessionId;
+    }
+    const message = {
+      id: data.message.id,
+      role: "assistant",
+      content: data.message.content,
+      timestamp: Date.now()
+    };
+    const actions = data.message.actions?.map((a) => {
+      const rewritten = this.rewriteActionTypeIfNeeded(a.type, a.payload);
+      return {
+        id: a.id,
+        type: rewritten.type,
+        payload: this.normalizePayload(rewritten.type, rewritten.payload),
+        status: "pending"
+      };
+    });
+    const summaryMessage = data.message.summary ? {
+      id: `${data.message.id}_summary`,
+      role: "assistant",
+      content: data.message.summary,
+      timestamp: Date.now()
+    } : void 0;
+    this.log("Response received:", { messageId: message.id, actions: actions?.length ?? 0, hasSummary: !!summaryMessage });
+    return {
+      sessionId: this.sessionId,
+      message,
+      summaryMessage,
+      actions,
+      usage: data.usage
+    };
+  }
+  /**
+   * Streaming variant of `sendMessage` — consumes the server's SSE
+   * endpoint (`/agent/message/stream`) and fires `onTextDelta` per chunk
+   * so the UI can render tokens as they arrive (OKR-008 KR1). Resolves
+   * with the same `SendMessageResponse` shape once the `done` event lands.
+   *
+   * Uses XMLHttpRequest because React Native's fetch does not expose
+   * `response.body` for incremental reads; RN's XHR delivers progressive
+   * `responseText`, which is the standard SSE transport on RN.
+   *
+   * Errors:
+   * - `StreamTransportError` — transport failed before ANY event; safe
+   *   for the caller to fall back to the non-streaming endpoint.
+   * - `StreamAbortError` (name='AbortError') — options.signal fired;
+   *   carries `partialContent` so the UI can keep what streamed.
+   */
+  async sendMessageStream(content, context, options = {}) {
+    if (!this.sessionId) {
+      await this.createSession();
+    }
+    const url = `${this.baseUrl}/agent/message/stream`;
+    this.log(`POST ${url} (stream)`);
+    const XhrCtor = globalThis.XMLHttpRequest;
+    if (!XhrCtor) {
+      throw new StreamTransportError("XMLHttpRequest is not available in this environment");
+    }
+    return new Promise((resolve, reject) => {
+      const xhr = new XhrCtor();
+      let parsedIndex = 0;
+      let fullText = "";
+      let sawAnyEvent = false;
+      let settled = false;
+      let doneEvent = null;
+      const rawActions = [];
+      let idleTimer;
+      const cleanup = () => {
+        if (idleTimer) clearTimeout(idleTimer);
+        if (options.signal) options.signal.removeEventListener("abort", onAbort);
+      };
+      const fail = (err) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(err);
+      };
+      const onAbort = () => {
+        try {
+          xhr.abort();
+        } catch {
+        }
+        fail(new StreamAbortError(fullText));
+      };
+      const armIdleTimer = () => {
+        if (idleTimer) clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+          try {
+            xhr.abort();
+          } catch {
+          }
+          fail(
+            sawAnyEvent ? new Error(`Stream went silent for ${this.timeout}ms`) : new StreamTransportError(`Stream connection timed out after ${this.timeout}ms`)
+          );
+        }, this.timeout);
+      };
+      const handleEvent = (event) => {
+        sawAnyEvent = true;
+        switch (event.type) {
+          case "session": {
+            const sid = event.sessionId;
+            if (typeof sid === "string" && sid) {
+              this.sessionId = sid;
+              options.onSession?.(sid);
+            }
+            break;
+          }
+          case "text-delta": {
+            const chunk = typeof event.content === "string" ? event.content : "";
+            if (chunk) {
+              fullText += chunk;
+              options.onTextDelta?.(chunk, fullText);
+            }
+            break;
+          }
+          case "tool-call": {
+            const action = event.action;
+            if (action?.id && action.type) rawActions.push(action);
+            break;
+          }
+          case "done": {
+            doneEvent = {
+              messageId: typeof event.messageId === "string" ? event.messageId : `msg_${Date.now()}`,
+              usage: event.usage
+            };
+            break;
+          }
+        }
+      };
+      const consumeBuffer = (isFinal) => {
+        const text = xhr.responseText ?? "";
+        let boundary = text.lastIndexOf("\n\n");
+        if (isFinal) boundary = text.length;
+        if (boundary <= parsedIndex) return;
+        const slice = text.slice(parsedIndex, boundary);
+        parsedIndex = boundary;
+        for (const frame of slice.split("\n\n")) {
+          for (const line of frame.split("\n")) {
+            if (!line.startsWith("data: ")) continue;
+            try {
+              handleEvent(JSON.parse(line.slice(6)));
+            } catch {
+              this.log("Skipping unparseable SSE line:", line.slice(0, 120));
+            }
+          }
+        }
+      };
+      const finish = () => {
+        if (settled) return;
+        consumeBuffer(true);
+        const contentType = String(xhr.getResponseHeader?.("content-type") ?? "");
+        if (xhr.status !== 200 || !contentType.includes("text/event-stream")) {
+          let message2 = `HTTP ${xhr.status || 0}`;
+          try {
+            const json = JSON.parse(xhr.responseText || "{}");
+            message2 = json?.error?.message ?? json?.error ?? message2;
+          } catch {
+          }
+          fail(
+            sawAnyEvent ? new Error(message2) : new StreamTransportError(message2)
+          );
+          return;
+        }
+        if (!doneEvent) {
+          fail(
+            sawAnyEvent ? new Error("Stream ended before the done event") : new StreamTransportError("Stream ended without any event")
+          );
+          return;
+        }
+        settled = true;
+        cleanup();
+        const message = {
+          id: doneEvent.messageId,
+          role: "assistant",
+          content: fullText,
+          timestamp: Date.now()
+        };
+        const actions = rawActions.length > 0 ? rawActions.map((a) => {
+          const rewritten = this.rewriteActionTypeIfNeeded(a.type, a.payload);
+          return {
+            id: a.id,
+            type: rewritten.type,
+            payload: this.normalizePayload(rewritten.type, rewritten.payload),
+            status: "pending"
+          };
+        }) : void 0;
+        this.log("Stream complete:", { messageId: message.id, actions: actions?.length ?? 0 });
+        resolve({
+          sessionId: this.sessionId,
+          message,
+          actions,
+          usage: doneEvent.usage ? { tokensUsed: doneEvent.usage.tokensUsed, modelUsed: "", latencyMs: 0 } : void 0
+        });
+      };
+      if (options.signal) {
+        if (options.signal.aborted) {
+          fail(new StreamAbortError(""));
+          return;
+        }
+        options.signal.addEventListener("abort", onAbort);
+      }
+      xhr.open("POST", url);
+      for (const [key, value] of Object.entries(this.headers)) {
+        xhr.setRequestHeader(key, value);
+      }
+      xhr.setRequestHeader("Accept", "text/event-stream");
+      xhr.onprogress = () => {
+        armIdleTimer();
+        consumeBuffer(false);
+      };
+      xhr.onload = finish;
+      xhr.onerror = () => fail(
+        sawAnyEvent ? new Error("Stream connection lost") : new StreamTransportError("Network error opening stream")
+      );
+      xhr.onabort = () => {
+        fail(new StreamAbortError(fullText));
+      };
+      armIdleTimer();
+      xhr.send(
+        JSON.stringify({
+          content,
+          sessionId: this.sessionId,
+          context,
+          ...this.mcpVersion ? { mcpVersion: this.mcpVersion } : {}
+        })
+      );
+    });
+  }
+  // ── Agent loop continuation ──────────────────────────────────
+  async continueAgent(results, context, hop) {
+    if (!this.sessionId) {
+      throw new Error("continueAgent called without an active session");
+    }
+    const data = await this.request(
+      "/agent/continue",
+      {
+        method: "POST",
+        body: JSON.stringify({
+          sessionId: this.sessionId,
+          results,
+          context,
+          hop
+        })
+      },
+      // A continuation hop rides the provider's retry budget: on a TPM/429
+      // storm the server only recovers after its exponential backoff
+      // (2+4+8+16+32s ≈ 62s) and answers at ~66s — measured repeatedly on
+      // the Detox destructive-mission runs. Aborting at the default 60s
+      // kills the automation one hop before the answer arrives ("Perdi o
+      // fio (Aborted)") while the server-side turn completes and orphans
+      // its actions. Give continuations room to outlive one full backoff
+      // cycle; an explicitly larger user-configured timeout still wins.
+      Math.max(this.timeout, CONTINUATION_TIMEOUT_MS)
+    );
+    const message = {
+      id: data.message.id,
+      role: "assistant",
+      content: data.message.content,
+      timestamp: Date.now()
+    };
+    const actions = data.message.actions?.map((a) => {
+      const rewritten = this.rewriteActionTypeIfNeeded(a.type, a.payload);
+      return {
+        id: a.id,
+        type: rewritten.type,
+        payload: this.normalizePayload(rewritten.type, rewritten.payload),
+        status: "pending"
+      };
+    });
+    return {
+      sessionId: this.sessionId,
+      message,
+      actions,
+      usage: data.usage,
+      isDone: data.isDone,
+      hop: data.hop
+    };
+  }
+  // ── Actions ───────────────────────────────────────────────────
+  async executeAction(actionId) {
+    const data = await this.request(`/agent/action/${actionId}/execute`, {
+      method: "POST"
+    });
+    return {
+      id: data.actionId,
+      type: data.type,
+      payload: data.payload,
+      status: "executing"
+    };
+  }
+  /**
+   * Rewrite an action's type when the AI used a semantically-misclassified
+   * action type. The most common case: the LLM emits
+   *   { type: 'ui_interaction', payload: { action: 'select', targetId, value } }
+   * to mean "set this field's value", which is really a form_fill. We detect
+   * that here and convert it before normalization, so the executor sees the
+   * right action shape and the field's setValue() is called instead of a
+   * meaningless press on a non-pressable component.
+   */
+  rewriteActionTypeIfNeeded(type, payload) {
+    if (type === "ui_interaction" && payload && String(payload.action ?? "").toLowerCase() === "select" && payload.value !== void 0) {
+      const targetId = payload.targetId ?? payload.componentId ?? "";
+      return {
+        type: "form_fill",
+        payload: {
+          screenName: "",
+          fields: [
+            {
+              fieldId: targetId,
+              fieldType: "select",
+              value: payload.value
+            }
+          ]
+        }
+      };
+    }
+    return { type, payload };
+  }
+  /**
+   * Normalize API tool call payloads to match SDK's expected payload types.
+   * The AI model may return slightly different field names than what the
+   * SDK executor expects, and may use vocabulary (e.g. "select", "scroll_to",
+   * "open") that the SDK doesn't natively support — we remap those to the
+   * nearest equivalent here so the executor never sees an "unknown action".
+   */
+  normalizePayload(type, payload) {
+    if (!payload) return payload;
+    switch (type) {
+      case "form_fill":
+        return {
+          screenName: payload.screenName ?? "",
+          fields: (payload.fields ?? []).map((f) => ({
+            fieldId: f.fieldId,
+            fieldType: f.fieldType ?? "text",
+            value: f.value,
+            label: f.label
+          })),
+          submitAfterFill: payload.submitAfterFill === true ? true : void 0
+        };
+      case "navigate":
+        return {
+          screenName: payload.screenName ?? "",
+          params: payload.params,
+          navigationAction: payload.navigationAction ?? "navigate",
+          path: Array.isArray(payload.path) ? payload.path : void 0
+        };
+      case "ui_interaction": {
+        const rawAction = payload.action ?? "press";
+        const actionMap = {
+          press: "press",
+          tap: "press",
+          click: "press",
+          toggle: "press",
+          // toggle handled via toggle registry inside handler
+          open: "press",
+          close: "press",
+          refresh: "press",
+          long_press: "longPress",
+          longpress: "longPress",
+          longPress: "longPress",
+          scroll: "scroll",
+          scroll_to: "scroll",
+          scrollto: "scroll",
+          focus: "focus",
+          // Slider verb (set_value capability). MUST be in this map: the
+          // `?? 'press'` default below swallows unknown verbs, and a
+          // swallowed set_value becomes a press that can fuzzy-match a
+          // completely unrelated control. Every new ui_interaction verb
+          // has to be added here — see docs/adding-component-capabilities.md.
+          set_value: "set_value",
+          setvalue: "set_value",
+          setValue: "set_value",
+          slide: "set_value",
+          adjust: "set_value"
+        };
+        const mapped = actionMap[rawAction] ?? actionMap[rawAction.toLowerCase()] ?? "press";
+        return {
+          ...payload,
+          componentId: payload.targetId ?? payload.componentId ?? "",
+          targetId: payload.targetId ?? payload.componentId ?? "",
+          action: mapped,
+          params: payload.params ?? (payload.value !== void 0 ? { value: payload.value } : void 0)
+        };
+      }
+      case "scroll_list": {
+        const rawIndex = payload.toIndex ?? payload.index ?? payload.itemIndex;
+        const toIndex = typeof rawIndex === "number" && Number.isFinite(rawIndex) ? Math.trunc(rawIndex) : void 0;
+        const rawDirection = String(payload.direction ?? "").toLowerCase();
+        const direction = rawDirection === "up" || rawDirection === "down" ? rawDirection : void 0;
+        return {
+          listId: typeof payload.listId === "string" && payload.listId.length > 0 ? payload.listId : typeof payload.targetId === "string" && payload.targetId.length > 0 ? payload.targetId : void 0,
+          toIndex,
+          direction
+        };
+      }
+      case "confirm": {
+        const destructive = payload.destructive === true || payload.severity === "danger";
+        return {
+          ...payload,
+          title: payload.title ?? (destructive ? "A\xE7\xE3o destrutiva" : "Confirmation"),
+          message: payload.message ?? payload.actionDescription ?? "",
+          destructive,
+          severity: payload.severity ?? (destructive ? "danger" : void 0)
+        };
+      }
+      default:
+        return payload;
+    }
+  }
+  /**
+   * Legacy per-action status report. The agentic chat loop reports via
+   * `continueAgent` (which carries diagnose + a fresh snapshot); this
+   * endpoint remains for apps driving actions manually through
+   * `useAppilotsActions`. `diagnose` is forwarded when provided so even
+   * the legacy path gives the server a failure category.
+   */
+  async completeAction(actionId, success, error, diagnose) {
+    await this.request(`/agent/action/${actionId}/complete`, {
+      method: "POST",
+      body: JSON.stringify({ success, error, ...diagnose ? { diagnose } : {} })
+    });
+  }
+  /**
+   * Fetch actions the server has persisted but that haven't been
+   * completed yet. Use after an SSE drop or a hard error to recover
+   * the batch without losing the actions the model already decided.
+   *
+   * Returns an empty array if there are no pending actions or if the
+   * call fails — never throws.
+   */
+  async recoverPendingActions(sessionId) {
+    const sid = sessionId ?? this.sessionId;
+    if (!sid) return [];
+    try {
+      const data = await this.request(`/agent/session/${sid}/pending-actions`);
+      return data.actions.map(
+        (a) => ({
+          id: a.id,
+          type: a.type,
+          payload: a.payload,
+          status: "pending"
+        })
+      );
+    } catch (err) {
+      this.log("recoverPendingActions failed (suppressed):", err);
+      return [];
+    }
+  }
+  // ── Suggested Prompts ─────────────────────────────────────────
+  /**
+   * Fetch dev-defined and empirically-popular prompts to seed the chat
+   * empty-state with one-tap chips. Cheap (cached server-side for 1h) but
+   * still a network hit, so callers should debounce around chat-open.
+   *
+   * @param screen Optional — when provided, response includes screen-scoped
+   *               popular prompts in addition to globals.
+   */
+  async getPopularPrompts(screen, limit) {
+    const queryParts = [];
+    if (screen) queryParts.push(`screen=${encodeURIComponent(screen)}`);
+    if (limit) queryParts.push(`limit=${encodeURIComponent(String(limit))}`);
+    const qs = queryParts.length > 0 ? `?${queryParts.join("&")}` : "";
+    const path = `/agent/popular-prompts${qs}`;
+    return this.request(path, { method: "GET" });
+  }
+  // ── Personalization (runtime config) ──────────────────────────
+  /**
+   * Fetch the project's dashboard-configured personalization (theme,
+   * branding, FAB color/image, locale...). Called by `AppilotsProvider`
+   * once on mount — cheap (cached server-side for 1h) and applied by
+   * `AppilotsChat` as a fallback for props not set explicitly in code.
+   *
+   * Throws on network/HTTP failure — the provider treats any failure as
+   * "no remote config" and stays on props/defaults.
+   */
+  async getPersonalization() {
+    return this.request("/agent/personalization", { method: "GET" });
+  }
+  // ── Human escalation (docs/human-escalation.md) ───────────────
+  /**
+   * Ask for a human operator. Idempotent: if the session already has
+   * an open escalation the server returns it instead of creating a
+   * duplicate. Creates the session first when the chat had none yet
+   * (the server sends it back and we adopt it, so the whole
+   * conversation stays under one sessionId).
+   */
+  async requestEscalation(reason, note) {
+    if (!this.sessionId) {
+      await this.createSession();
+    }
+    const data = await this.request("/agent/escalation", {
+      method: "POST",
+      body: JSON.stringify({
+        ...this.sessionId ? { sessionId: this.sessionId } : {},
+        reason,
+        ...note ? { note } : {}
+      })
+    });
+    if (data.sessionId) this.sessionId = data.sessionId;
+    return {
+      escalationId: data.escalationId,
+      status: data.status === "active" ? "active" : "pending"
+    };
+  }
+  /**
+   * Tell the server the user walked away from the conversation (chat
+   * cleared) so the escalation is closed instead of leaving the
+   * operator talking to nobody. Fire-and-forget: never throws — the
+   * local cleanup must proceed even if the network is gone.
+   */
+  async abandonEscalation(escalationId) {
+    try {
+      await this.request(`/agent/escalation/${escalationId}/abandon`, { method: "POST" });
+    } catch (err) {
+      this.log("abandonEscalation failed (suppressed):", err);
+    }
+  }
+  /** User message routed to the human operator (no LLM involved). */
+  async sendEscalationMessage(escalationId, content) {
+    await this.request(`/agent/escalation/${escalationId}/message`, {
+      method: "POST",
+      body: JSON.stringify({ content })
+    });
+  }
+  /**
+   * Poll fallback / reconnect catch-up: status + operator messages
+   * created after `since` (ISO timestamp of the last one we have).
+   */
+  async getEscalationUpdates(escalationId, since) {
+    const qs = since ? `?since=${encodeURIComponent(since)}` : "";
+    return this.request(`/agent/escalation/${escalationId}${qs}`);
+  }
+  /**
+   * Open the escalation SSE channel — operator replies + status
+   * changes pushed live. Same XHR transport as `sendMessageStream`
+   * (RN's fetch can't read a body incrementally).
+   *
+   * Long-lived by design: no idle watchdog — the server pings every
+   * 25s, and a genuinely dead connection surfaces as `onClose`, which
+   * the hook answers with a backoff reconnect + `since` catch-up.
+   * Returns a close function; closing never fires `onClose`.
+   */
+  openEscalationStream(escalationId, handlers) {
+    const XhrCtor = globalThis.XMLHttpRequest;
+    if (!XhrCtor) {
+      handlers.onClose();
+      return () => {
+      };
+    }
+    const qs = handlers.since ? `?since=${encodeURIComponent(handlers.since)}` : "";
+    const url = `${this.baseUrl}/agent/escalation/${escalationId}/stream${qs}`;
+    this.log(`GET ${url} (escalation stream)`);
+    const xhr = new XhrCtor();
+    let parsedIndex = 0;
+    let closedByCaller = false;
+    let ended = false;
+    const end = () => {
+      if (ended || closedByCaller) return;
+      ended = true;
+      handlers.onClose();
+    };
+    const handleEvent = (event) => {
+      if (event.type === "human-message") {
+        const m = event.message;
+        if (m?.id && typeof m.content === "string") {
+          handlers.onHumanMessage({ id: m.id, content: m.content, createdAt: m.createdAt });
+        }
+      } else if (event.type === "status") {
+        const status = event.status;
+        if (status === "pending" || status === "active" || status === "resolved") {
+          handlers.onStatus(
+            status,
+            typeof event.operatorName === "string" ? event.operatorName : void 0
+          );
+        }
+      }
+    };
+    const consumeBuffer = () => {
+      const text = xhr.responseText ?? "";
+      const boundary = text.lastIndexOf("\n\n");
+      if (boundary <= parsedIndex) return;
+      const slice = text.slice(parsedIndex, boundary);
+      parsedIndex = boundary;
+      for (const frame of slice.split("\n\n")) {
+        for (const line of frame.split("\n")) {
+          if (!line.startsWith("data: ")) continue;
+          try {
+            handleEvent(JSON.parse(line.slice(6)));
+          } catch {
+            this.log("Skipping unparseable escalation SSE line:", line.slice(0, 120));
+          }
+        }
+      }
+    };
+    xhr.open("GET", url);
+    for (const [key, value] of Object.entries(this.headers)) {
+      xhr.setRequestHeader(key, value);
+    }
+    xhr.setRequestHeader("Accept", "text/event-stream");
+    xhr.onprogress = consumeBuffer;
+    xhr.onload = () => {
+      consumeBuffer();
+      end();
+    };
+    xhr.onerror = end;
+    xhr.onabort = end;
+    xhr.send();
+    return () => {
+      closedByCaller = true;
+      try {
+        xhr.abort();
+      } catch {
+      }
+    };
+  }
+};
+
+// src/registry/ComponentRegistry.ts
+var ComponentRegistryImpl = class {
+  components = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * Register a component. If an entry with the same ID already exists,
+   * it is replaced (this handles re-renders / hot-reload).
+   */
+  register(id, entry) {
+    this.components.set(id, entry);
+    console.log(`[Appilots] ComponentRegistry.register: id="${id}" kind="${entry.kind}" \u2014 total count: ${this.components.size}`);
+    this.notify(id, entry);
+  }
+  /**
+   * Unregister a component (typically on unmount).
+   */
+  unregister(id) {
+    this.components.delete(id);
+    console.log(`[Appilots] ComponentRegistry.unregister: id="${id}" \u2014 total count: ${this.components.size}`);
+    this.notify(id, null);
+  }
+  /**
+   * Look up a component by its ID.
+   */
+  get(id) {
+    return this.components.get(id);
+  }
+  /**
+   * Get a typed entry or undefined.
+   */
+  getField(id) {
+    const entry = this.components.get(id);
+    return entry?.kind === "field" ? entry : void 0;
+  }
+  getTarget(id) {
+    const entry = this.components.get(id);
+    return entry?.kind === "target" ? entry : void 0;
+  }
+  getToggle(id) {
+    const entry = this.components.get(id);
+    return entry?.kind === "toggle" ? entry : void 0;
+  }
+  getSlider(id) {
+    const entry = this.components.get(id);
+    return entry?.kind === "slider" ? entry : void 0;
+  }
+  /**
+   * Get all components on a given screen.
+   */
+  getByScreen(screen) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [id, entry] of this.components) {
+      if (entry.screen === screen) {
+        result.set(id, entry);
+      }
+    }
+    return result;
+  }
+  /**
+   * Get all components of a given kind.
+   */
+  getByKind(kind) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [id, entry] of this.components) {
+      if (entry.kind === kind) {
+        result.set(id, entry);
+      }
+    }
+    return result;
+  }
+  /**
+   * List all registered component IDs with their kind and screen.
+   * Useful for debugging and for the AI to know what's available.
+   */
+  snapshot() {
+    return Array.from(this.components.entries()).map(([id, entry]) => ({
+      id,
+      kind: entry.kind,
+      screen: entry.screen,
+      label: entry.label
+    }));
+  }
+  /**
+   * Subscribe to registry changes.
+   * Returns an unsubscribe function.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Clear all entries (useful for testing or full reset).
+   */
+  clear() {
+    this.components.clear();
+  }
+  /** Number of registered components */
+  get size() {
+    return this.components.size;
+  }
+  notify(id, entry) {
+    for (const listener of this.listeners) {
+      try {
+        listener(id, entry);
+      } catch {
+      }
+    }
+  }
+};
+var componentRegistry = new ComponentRegistryImpl();
+function createComponentRegistry() {
+  return new ComponentRegistryImpl();
+}
+
+// src/registry/ListRegistry.ts
+var ListRegistryImpl = class {
+  lists = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  register(id, entry) {
+    this.lists.set(id, entry);
+    console.log(
+      `[Appilots] ListRegistry.register: id="${id}" component="${entry.component}" items=${entry.itemCount ?? "unknown"} \u2014 total count: ${this.lists.size}`
+    );
+    this.notify(id, entry);
+  }
+  unregister(id) {
+    this.lists.delete(id);
+    console.log(`[Appilots] ListRegistry.unregister: id="${id}" \u2014 total count: ${this.lists.size}`);
+    this.notify(id, null);
+  }
+  get(id) {
+    return this.lists.get(id);
+  }
+  snapshot() {
+    return Array.from(this.lists.values());
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  clear() {
+    this.lists.clear();
+  }
+  get size() {
+    return this.lists.size;
+  }
+  notify(id, entry) {
+    for (const listener of this.listeners) {
+      try {
+        listener(id, entry);
+      } catch {
+      }
+    }
+  }
+};
+var listRegistry = new ListRegistryImpl();
+function createListRegistry() {
+  return new ListRegistryImpl();
+}
+
+// src/registry/ElementRegistry.ts
+var ElementRegistryImpl = class {
+  elements = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  replaceAll(elements) {
+    const next = /* @__PURE__ */ new Map();
+    for (const element of elements) {
+      if (!element.id) continue;
+      next.set(element.id, element);
+    }
+    this.elements = next;
+    console.log(`[Appilots] ElementRegistry.replaceAll: elements=${this.elements.size}`);
+  }
+  register(id, entry) {
+    this.elements.set(id, entry);
+    this.notify(id, entry);
+  }
+  unregister(id) {
+    this.elements.delete(id);
+    this.notify(id, null);
+  }
+  get(id) {
+    return this.elements.get(id);
+  }
+  snapshot() {
+    return Array.from(this.elements.values());
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  clear() {
+    this.elements.clear();
+  }
+  get size() {
+    return this.elements.size;
+  }
+  notify(id, entry) {
+    for (const listener of this.listeners) {
+      try {
+        listener(id, entry);
+      } catch {
+      }
+    }
+  }
+};
+var elementRegistry = new ElementRegistryImpl();
+function createElementRegistry() {
+  return new ElementRegistryImpl();
+}
+var ComponentRegistryContext = React2__default.default.createContext(null);
+function AppilotsRegistryProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ React2__default.default.createElement(ComponentRegistryContext.Provider, { value }, children);
+}
+function useResolvedRegistry() {
+  const ctx = React2__default.default.useContext(ComponentRegistryContext);
+  return ctx ?? componentRegistry;
+}
+function getDefaultRegistry() {
+  return componentRegistry;
+}
+
+// src/auto/idExtraction.ts
+function normalizeId(raw) {
+  return raw.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/^(input-|btn-|toggle-|switch-)/, "").replace(/[^a-z0-9\s-_]/g, "").trim().replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase()).replace(/[-_\s]+$/, "");
+}
+function deriveSemanticInputId(props) {
+  if (!props || typeof props !== "object") return null;
+  if (props.secureTextEntry === true) return "password";
+  const km = props.keyboardType ?? props.inputMode;
+  if (typeof km === "string" && km.length > 0) {
+    switch (km) {
+      case "email-address":
+      case "email":
+        return "email";
+      case "numeric":
+      case "number-pad":
+      case "decimal-pad":
+      case "numeric-pad":
+        return "numericInput";
+      case "phone-pad":
+      case "tel":
+        return "phoneInput";
+      case "url":
+        return "urlInput";
+      case "search":
+        return "searchInput";
+      default:
+        return `${km.replace(/[^a-z0-9]/gi, "")}Input` || null;
+    }
+  }
+  return null;
+}
+
+// src/auto/sectionListIndex.ts
+function sectionListFlatIndex(sections, section, localIndex) {
+  if (!Array.isArray(sections)) return localIndex;
+  const sectionIndex = sections.indexOf(section);
+  if (sectionIndex < 0) return localIndex;
+  let base = 0;
+  for (let i = 0; i < sectionIndex; i++) {
+    const data = sections[i]?.data;
+    base += Array.isArray(data) ? data.length : 0;
+  }
+  return base + localIndex;
+}
+
+// src/auto/enableAutoTracking.tsx
+function extractId(props) {
+  const raw = props?.testID ?? props?.nativeID ?? props?.id ?? props?.accessibilityLabel ?? props?.name ?? props?.placeholder ?? (typeof props?.autoComplete === "string" && props.autoComplete !== "off" ? props.autoComplete : void 0);
+  if (raw && typeof raw === "string") {
+    const normalized = normalizeId(raw);
+    if (normalized && normalized.length > 0) {
+      console.log(`[Appilots] extractId: raw="${raw}" \u2192 normalized="${normalized}"`);
+      return normalized;
+    }
+    console.log(`[Appilots] extractId: raw="${raw}" normalized to empty string, falling back`);
+  }
+  const hint = deriveSemanticInputId(props);
+  if (hint) {
+    console.warn(
+      `[Appilots] extractId: no testID/nativeID/accessibilityLabel/name/placeholder/autoComplete on input \u2014 falling back to semantic hint "${hint}". Add testID to make this field reliably addressable.`
+    );
+    return hint;
+  }
+  console.log(
+    "[Appilots] extractId: no identifiable prop found (testID/nativeID/accessibilityLabel/name/placeholder/autoComplete missing); skipping registration"
+  );
+  return null;
+}
+function extractLabel(props) {
+  return props?.accessibilityLabel ?? props?.placeholder ?? props?.name ?? props?.testID ?? props?.nativeID;
+}
+var _originalCreateElement = React2__default.default.createElement;
+var TrackedTextInput = React2__default.default.forwardRef(function TrackedTextInput2(props, forwardedRef) {
+  const registry = useResolvedRegistry();
+  const id = extractId(props);
+  const valueRef = React2__default.default.useRef(props.value ?? props.defaultValue ?? "");
+  const onChangeRef = React2__default.default.useRef(props.onChangeText);
+  const inputRef = React2__default.default.useRef(null);
+  valueRef.current = props.value ?? props.defaultValue ?? "";
+  onChangeRef.current = props.onChangeText;
+  React2__default.default.useEffect(() => {
+    if (!id) {
+      console.log("[Appilots] TrackedTextInput useEffect: no id extracted, skipping registration");
+      return;
+    }
+    console.log(`[Appilots] TrackedTextInput useEffect: registering field id="${id}" label="${extractLabel(props)}"`);
+    const entry = {
+      kind: "field",
+      getValue: () => valueRef.current,
+      setValue: (v) => {
+        console.log(`[Appilots] TrackedTextInput setValue called: id="${id}" value="${v}"`);
+        onChangeRef.current?.(v);
+        inputRef.current?.setNativeProps?.({ text: v });
+      },
+      focus: () => inputRef.current?.focus?.(),
+      fieldType: props.secureTextEntry ? "text" : props.keyboardType === "numeric" ? "number" : "text",
+      label: extractLabel(props)
+    };
+    registry.register(id, entry);
+    return () => {
+      console.log(`[Appilots] TrackedTextInput useEffect cleanup: unregistering field id="${id}"`);
+      registry.unregister(id);
+    };
+  }, [id]);
+  const mergedRef = React2__default.default.useCallback((instance) => {
+    inputRef.current = instance;
+    if (typeof forwardedRef === "function") forwardedRef(instance);
+    else if (forwardedRef && typeof forwardedRef === "object") forwardedRef.current = instance;
+  }, [forwardedRef]);
+  return _originalCreateElement(reactNative.TextInput, { ...props, ref: mergedRef });
+});
+var TrackedSwitch = React2__default.default.forwardRef(function TrackedSwitch2(props, forwardedRef) {
+  const registry = useResolvedRegistry();
+  const id = extractId(props);
+  const valueRef = React2__default.default.useRef(props.value ?? false);
+  const onChangeRef = React2__default.default.useRef(props.onValueChange);
+  valueRef.current = props.value ?? false;
+  onChangeRef.current = props.onValueChange;
+  React2__default.default.useEffect(() => {
+    if (!id) {
+      console.log("[Appilots] TrackedSwitch useEffect: no id extracted, skipping registration");
+      return;
+    }
+    console.log(`[Appilots] TrackedSwitch useEffect: registering toggle id="${id}" label="${extractLabel(props)}"`);
+    const entry = {
+      kind: "toggle",
+      getValue: () => valueRef.current,
+      setValue: (v) => {
+        console.log(`[Appilots] TrackedSwitch setValue called: id="${id}" value=${v}`);
+        onChangeRef.current?.(v);
+      },
+      label: extractLabel(props)
+    };
+    registry.register(id, entry);
+    return () => {
+      console.log(`[Appilots] TrackedSwitch useEffect cleanup: unregistering toggle id="${id}"`);
+      registry.unregister(id);
+    };
+  }, [id]);
+  return _originalCreateElement(reactNative.Switch, { ...props, ref: forwardedRef });
+});
+var _pressableWrapperCache = /* @__PURE__ */ new Map();
+function getTrackedPressable(OriginalComponent) {
+  let cached = _pressableWrapperCache.get(OriginalComponent);
+  if (cached) return cached;
+  cached = React2__default.default.forwardRef(function TrackedPressable(props, forwardedRef) {
+    const registry = useResolvedRegistry();
+    const id = extractId(props);
+    const onPressRef = React2__default.default.useRef(props.onPress);
+    onPressRef.current = props.onPress;
+    React2__default.default.useEffect(() => {
+      if (props.__appilotsSkip === true || props.__appilotsInternal === true || props.appilotsSkip === true) {
+        return;
+      }
+      if (!id || !props.onPress) {
+        console.log(`[Appilots] TrackedPressable useEffect: skipping registration (id=${id}, hasOnPress=${!!props.onPress})`);
+        return;
+      }
+      console.log(`[Appilots] TrackedPressable useEffect: registering target id="${id}" label="${extractLabel(props)}"`);
+      const entry = {
+        kind: "target",
+        press: () => {
+          console.log(`[Appilots] TrackedPressable press called: id="${id}"`);
+          onPressRef.current?.();
+        },
+        label: extractLabel(props)
+      };
+      registry.register(id, entry);
+      return () => {
+        console.log(`[Appilots] TrackedPressable useEffect cleanup: unregistering target id="${id}"`);
+        registry.unregister(id);
+      };
+    }, [id, !!props.onPress]);
+    return _originalCreateElement(OriginalComponent, { ...props, ref: forwardedRef });
+  });
+  _pressableWrapperCache.set(OriginalComponent, cached);
+  return cached;
+}
+var LIST_COMPONENT_NAMES = /* @__PURE__ */ new Set([
+  "FlatList",
+  "SectionList",
+  "VirtualizedList",
+  "FlashList"
+]);
+var _listWrapperCache = /* @__PURE__ */ new Map();
+var _generatedListIdCounter = 0;
+function componentDisplayName(type) {
+  if (!type) return "";
+  if (typeof type === "string") return type;
+  if (typeof type === "function") return type.displayName ?? type.name ?? "";
+  if (typeof type === "object") {
+    if (typeof type.displayName === "string") return type.displayName;
+    if (type.render) return componentDisplayName(type.render);
+    if (type.type) return componentDisplayName(type.type);
+  }
+  return "";
+}
+function extractListId(props, componentName) {
+  const raw = props?.appilotsListId ?? props?.testID ?? props?.nativeID ?? props?.id ?? props?.accessibilityLabel ?? props?.name;
+  if (typeof raw === "string" && raw.trim().length > 0) {
+    const normalized = normalizeId(raw);
+    if (normalized) return normalized;
+  }
+  _generatedListIdCounter += 1;
+  return `appilots-${componentName.toLowerCase()}-${_generatedListIdCounter}`;
+}
+function listLabel(props) {
+  return props?.accessibilityLabel ?? props?.testID ?? props?.nativeID ?? props?.id ?? props?.name;
+}
+function resolveItemCount(props) {
+  if (Array.isArray(props?.data)) return props.data.length;
+  if (props?.data && typeof props.getItemCount === "function") {
+    try {
+      const count = props.getItemCount(props.data);
+      return typeof count === "number" && Number.isFinite(count) ? count : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  if (Array.isArray(props?.sections)) {
+    return props.sections.reduce((acc, section) => {
+      const data = Array.isArray(section?.data) ? section.data : [];
+      return acc + data.length;
+    }, 0);
+  }
+  return void 0;
+}
+var MAX_DATA_PREVIEW_ITEMS = 60;
+var MAX_DATA_PREVIEW_TEXT = 80;
+var PREVIEW_TEXT_KEYS = [
+  "name",
+  "nome",
+  "title",
+  "titulo",
+  "label",
+  "description",
+  "descricao",
+  "plate",
+  "placa",
+  "model",
+  "modelo",
+  "email",
+  "username"
+];
+function projectItemText(item) {
+  if (item == null) return "";
+  if (typeof item === "string") return item.slice(0, MAX_DATA_PREVIEW_TEXT);
+  if (typeof item === "number" || typeof item === "boolean") return String(item);
+  if (typeof item !== "object") return "";
+  const record = item;
+  const parts = [];
+  for (const key of PREVIEW_TEXT_KEYS) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) parts.push(value.trim());
+    else if (typeof value === "number") parts.push(String(value));
+    if (parts.length >= 3) break;
+  }
+  if (parts.length === 0) {
+    for (const value of Object.values(record)) {
+      if (typeof value === "string" && value.trim()) parts.push(value.trim());
+      else if (typeof value === "number") parts.push(String(value));
+      if (parts.length >= 2) break;
+    }
+  }
+  return parts.join(" \xB7 ").slice(0, MAX_DATA_PREVIEW_TEXT);
+}
+function buildDataPreview(props) {
+  let items;
+  if (Array.isArray(props?.data)) {
+    items = props.data;
+  } else if (Array.isArray(props?.sections)) {
+    items = props.sections.flatMap(
+      (section) => Array.isArray(section?.data) ? section.data : []
+    );
+  }
+  if (!items || items.length === 0) return void 0;
+  const out = [];
+  const cap = Math.min(items.length, MAX_DATA_PREVIEW_ITEMS);
+  for (let i = 0; i < cap; i++) {
+    const text = projectItemText(items[i]);
+    if (!text) continue;
+    out.push({
+      index: i,
+      key: resolveItemKey(props, items[i], i),
+      text
+    });
+  }
+  return out.length > 0 ? out : void 0;
+}
+function readScrollMetrics(instance) {
+  try {
+    const metrics = instance?._scrollMetrics ?? instance?._listRef?._scrollMetrics;
+    if (!metrics) return void 0;
+    const { offset, visibleLength, contentLength } = metrics;
+    if (typeof offset !== "number" || typeof visibleLength !== "number" || typeof contentLength !== "number" || !Number.isFinite(offset) || !Number.isFinite(visibleLength) || !Number.isFinite(contentLength)) {
+      return void 0;
+    }
+    return { offset, visibleLength, contentLength };
+  } catch {
+    return void 0;
+  }
+}
+function flatIndexToSectionLocation(sections, flatIndex) {
+  let remaining = flatIndex;
+  for (let sectionIndex = 0; sectionIndex < sections.length; sectionIndex++) {
+    const data = Array.isArray(sections[sectionIndex]?.data) ? sections[sectionIndex].data : [];
+    if (remaining < data.length) return { sectionIndex, itemIndex: remaining };
+    remaining -= data.length;
+  }
+  return null;
+}
+function resolveItemKey(props, item, index) {
+  if (typeof props?.keyExtractor === "function") {
+    try {
+      const key = props.keyExtractor(item, index);
+      if (typeof key === "string" || typeof key === "number") return String(key);
+    } catch {
+    }
+  }
+  const raw = item?.id ?? item?.key ?? item?._id;
+  if (typeof raw === "string" || typeof raw === "number") return String(raw);
+  return typeof index === "number" ? String(index) : void 0;
+}
+function getTrackedList(OriginalComponent, componentName) {
+  let cached = _listWrapperCache.get(OriginalComponent);
+  if (cached) return cached;
+  cached = React2__default.default.forwardRef(function TrackedList(props, forwardedRef) {
+    const idRef = React2__default.default.useRef(null);
+    if (!idRef.current) idRef.current = extractListId(props, componentName);
+    const listId = idRef.current;
+    const renderItemRef = React2__default.default.useRef(props.renderItem);
+    const propsRef = React2__default.default.useRef(props);
+    const instanceRef = React2__default.default.useRef(null);
+    renderItemRef.current = props.renderItem;
+    propsRef.current = props;
+    const itemCount = resolveItemCount(props);
+    const refreshing = props.refreshing === true;
+    const label = listLabel(props);
+    const dataPreview = React2__default.default.useMemo(
+      () => buildDataPreview(props),
+      [props.data, props.sections]
+    );
+    const mergedRef = React2__default.default.useCallback(
+      (instance) => {
+        instanceRef.current = instance;
+        if (typeof forwardedRef === "function") forwardedRef(instance);
+        else if (forwardedRef && typeof forwardedRef === "object") forwardedRef.current = instance;
+      },
+      [forwardedRef]
+    );
+    React2__default.default.useEffect(() => {
+      listRegistry.register(listId, {
+        kind: "list",
+        id: listId,
+        component: componentName,
+        itemCount,
+        label,
+        refreshing,
+        empty: typeof itemCount === "number" ? itemCount === 0 : void 0,
+        dataPreview,
+        scrollToIndex: (index) => {
+          const instance = instanceRef.current;
+          if (!instance) return false;
+          try {
+            if (componentName === "SectionList" && Array.isArray(propsRef.current?.sections)) {
+              const location = flatIndexToSectionLocation(propsRef.current.sections, index);
+              if (!location || typeof instance.scrollToLocation !== "function") return false;
+              instance.scrollToLocation({ ...location, animated: true, viewPosition: 0.3 });
+              return true;
+            }
+            if (typeof instance.scrollToIndex === "function") {
+              instance.scrollToIndex({ index, animated: true, viewPosition: 0.3 });
+              return true;
+            }
+            return false;
+          } catch (err) {
+            console.warn(`[Appilots] TrackedList scrollToIndex failed for "${listId}":`, err);
+            return false;
+          }
+        },
+        scrollToOffset: (offset) => {
+          const instance = instanceRef.current;
+          if (!instance) return false;
+          try {
+            if (typeof instance.scrollToOffset === "function") {
+              instance.scrollToOffset({ offset, animated: true });
+              return true;
+            }
+            const responder = typeof instance.getScrollResponder === "function" ? instance.getScrollResponder() : void 0;
+            if (responder && typeof responder.scrollTo === "function") {
+              responder.scrollTo({ y: offset, animated: true });
+              return true;
+            }
+            return false;
+          } catch (err) {
+            console.warn(`[Appilots] TrackedList scrollToOffset failed for "${listId}":`, err);
+            return false;
+          }
+        },
+        getScrollMetrics: () => readScrollMetrics(instanceRef.current)
+      });
+      return () => {
+        listRegistry.unregister(listId);
+      };
+    }, [listId, itemCount, label, refreshing, dataPreview]);
+    const wrappedRenderItem = React2__default.default.useCallback(
+      (info) => {
+        const renderer = renderItemRef.current;
+        if (typeof renderer !== "function") return null;
+        const rendered = renderer(info);
+        if (!React2__default.default.isValidElement(rendered)) return rendered;
+        const localIndex = typeof info?.index === "number" ? info.index : void 0;
+        const index = localIndex !== void 0 && componentName === "SectionList" ? sectionListFlatIndex(propsRef.current?.sections, info?.section, localIndex) : localIndex;
+        const itemKey = localIndex !== void 0 ? resolveItemKey(propsRef.current, info?.item, localIndex) : void 0;
+        return React2__default.default.cloneElement(rendered, {
+          __appilotsListItem: true,
+          __appilotsListId: listId,
+          __appilotsItemIndex: index,
+          __appilotsItemKey: itemKey,
+          __appilotsItemCount: itemCount
+        });
+      },
+      [listId, itemCount]
+    );
+    return _originalCreateElement(OriginalComponent, {
+      ...props,
+      ref: mergedRef,
+      __appilotsListId: listId,
+      __appilotsListKind: componentName,
+      __appilotsItemCount: itemCount,
+      __appilotsListLabel: label,
+      __appilotsRefreshing: refreshing,
+      __appilotsEmpty: typeof itemCount === "number" ? itemCount === 0 : void 0,
+      renderItem: typeof props.renderItem === "function" ? wrappedRenderItem : props.renderItem
+    });
+  });
+  _listWrapperCache.set(OriginalComponent, cached);
+  return cached;
+}
+var _enabled = false;
+function enableAppilotsAutoTracking(options) {
+  if (_enabled) return;
+  _enabled = true;
+  const { trackPressable = true, debug = false } = options ?? {};
+  if (debug) {
+    componentRegistry.subscribe((id, entry) => {
+      if (entry) {
+        console.log(`[Appilots] Registered ${entry.kind}: "${id}" (${entry.label ?? "no label"})`);
+      } else {
+        console.log(`[Appilots] Unregistered: "${id}"`);
+      }
+    });
+    listRegistry.subscribe((id, entry) => {
+      if (entry) {
+        console.log(
+          `[Appilots] Registered list: "${id}" (${entry.component}, items=${entry.itemCount ?? "unknown"})`
+        );
+      } else {
+        console.log(`[Appilots] Unregistered list: "${id}"`);
+      }
+    });
+  }
+  const originalCreateElement = React2__default.default.createElement;
+  _originalCreateElement = originalCreateElement;
+  function isComponent(type, target, name) {
+    if (type === target) {
+      console.log(`[Appilots] isComponent: matched "${name}" by reference equality`);
+      return true;
+    }
+    const dn = type?.displayName || type?.name || "";
+    if (dn === name) {
+      console.log(`[Appilots] isComponent: matched "${name}" by displayName/name (reference equality failed \u2014 possible monorepo issue)`);
+      return true;
+    }
+    return false;
+  }
+  function interceptType(type, props) {
+    if (!props || !type || props.__appilotsInternal) return null;
+    const displayName = componentDisplayName(type);
+    if (LIST_COMPONENT_NAMES.has(displayName)) {
+      console.log(`[Appilots] intercepted list component "${displayName}"`);
+      return { type: getTrackedList(type, displayName), props };
+    }
+    if (isComponent(type, reactNative.TextInput, "TextInput")) {
+      if (props.testID || props.accessibilityLabel || props.placeholder) {
+        console.log(`[Appilots] intercepted TextInput (testID="${props.testID}", label="${props.accessibilityLabel}", placeholder="${props.placeholder}")`);
+        return { type: TrackedTextInput, props };
+      }
+    }
+    if (isComponent(type, reactNative.Switch, "Switch")) {
+      if (props.testID || props.accessibilityLabel) {
+        console.log(`[Appilots] intercepted Switch (testID="${props.testID}", label="${props.accessibilityLabel}")`);
+        return { type: TrackedSwitch, props };
+      }
+    }
+    if (isComponent(type, reactNative.TouchableOpacity, "TouchableOpacity") || trackPressable && isComponent(type, reactNative.Pressable, "Pressable")) {
+      if ((props.testID || props.accessibilityLabel) && props.onPress) {
+        console.log(`[Appilots] intercepted Pressable/TouchableOpacity (testID="${props.testID}", label="${props.accessibilityLabel}")`);
+        return { type: getTrackedPressable(type), props };
+      }
+    }
+    return null;
+  }
+  React2__default.default.createElement = function(type, props, ...children) {
+    const replacement = interceptType(type, props);
+    if (replacement) {
+      return originalCreateElement(replacement.type, replacement.props, ...children);
+    }
+    return originalCreateElement(type, props, ...children);
+  };
+  console.log("[Appilots] Auto-tracking: React.createElement patched");
+  _interceptType = interceptType;
+  try {
+    const jsxRuntime = __require("react/jsx-runtime");
+    if (jsxRuntime) {
+      _patchJsxRuntimeModule(jsxRuntime);
+    }
+  } catch (e) {
+    console.log("[Appilots] Auto-tracking: react/jsx-runtime not available internally (will be patched by metro shim)");
+  }
+  try {
+    const jsxDevRuntime = __require("react/jsx-dev-runtime");
+    if (jsxDevRuntime) {
+      _patchJsxDevRuntimeModule(jsxDevRuntime);
+    }
+  } catch (e) {
+    console.log("[Appilots] Auto-tracking: react/jsx-dev-runtime not available internally (will be patched by metro shim)");
+  }
+}
+var _interceptType = null;
+var _jsxRuntimePatched = false;
+var _jsxDevRuntimePatched = false;
+function _patchJsxRuntimeModule(jsxRuntime) {
+  if (_jsxRuntimePatched || !_interceptType || !jsxRuntime) return;
+  _jsxRuntimePatched = true;
+  const interceptType = _interceptType;
+  const origJsx = jsxRuntime.jsx;
+  const origJsxs = jsxRuntime.jsxs;
+  if (origJsx) {
+    jsxRuntime.jsx = function(type, props, key) {
+      const replacement = interceptType(type, props);
+      if (replacement) {
+        return origJsx(replacement.type, replacement.props, key);
+      }
+      return origJsx(type, props, key);
+    };
+    console.log("[Appilots] Auto-tracking: react/jsx-runtime jsx() patched");
+  }
+  if (origJsxs) {
+    jsxRuntime.jsxs = function(type, props, key) {
+      const replacement = interceptType(type, props);
+      if (replacement) {
+        return origJsxs(replacement.type, replacement.props, key);
+      }
+      return origJsxs(type, props, key);
+    };
+    console.log("[Appilots] Auto-tracking: react/jsx-runtime jsxs() patched");
+  }
+}
+function _patchJsxDevRuntimeModule(jsxDevRuntime) {
+  if (_jsxDevRuntimePatched || !_interceptType || !jsxDevRuntime) return;
+  _jsxDevRuntimePatched = true;
+  const interceptType = _interceptType;
+  if (jsxDevRuntime.jsxDEV) {
+    const origJsxDEV = jsxDevRuntime.jsxDEV;
+    jsxDevRuntime.jsxDEV = function(type, props, key, isStaticChildren, source, self) {
+      const replacement = interceptType(type, props);
+      if (replacement) {
+        return origJsxDEV(replacement.type, replacement.props, key, isStaticChildren, source, self);
+      }
+      return origJsxDEV(type, props, key, isStaticChildren, source, self);
+    };
+    console.log("[Appilots] Auto-tracking: react/jsx-dev-runtime jsxDEV() patched");
+  }
+}
+function _patchJsxRuntimes(jsxRuntime, jsxDevRuntime) {
+  if (!_interceptType) {
+    console.warn("[Appilots] _patchJsxRuntimes called but auto-tracking is not enabled");
+    return;
+  }
+  console.log("[Appilots] _patchJsxRuntimes: patching from app context (metro shim)");
+  if (jsxRuntime) _patchJsxRuntimeModule(jsxRuntime);
+  if (jsxDevRuntime) _patchJsxDevRuntimeModule(jsxDevRuntime);
+}
+function isAutoTrackingEnabled() {
+  return _enabled;
+}
+
+// src/core/initAppilots.ts
+var _globalConfig = null;
+var _autoConfigAttempted = false;
+function initAppilots(config) {
+  console.log(`[Appilots] initAppilots called with config: projectId="${config.projectId}", apiBaseUrl="${config.apiBaseUrl ?? config.apiUrl ?? "default"}", debug=${config.debug ?? false}, autoTracking=${JSON.stringify(config.autoTracking ?? {})}`);
+  if (config.apiUrl && !config.apiBaseUrl) {
+    config.apiBaseUrl = config.apiUrl;
+  }
+  _globalConfig = config;
+  const autoTrackingEnabled = config.autoTracking?.enabled !== false;
+  if (autoTrackingEnabled) {
+    console.log("[Appilots] initAppilots: auto-tracking is enabled, calling enableAppilotsAutoTracking()");
+    enableAppilotsAutoTracking({
+      trackPressable: config.autoTracking?.trackPressable ?? true,
+      debug: config.debug ?? false
+    });
+  } else {
+    console.log("[Appilots] initAppilots: auto-tracking is explicitly disabled");
+  }
+}
+function tryAutoConfig() {
+  if (_globalConfig || _autoConfigAttempted) {
+    console.log(`[Appilots] tryAutoConfig: skipping (alreadyConfigured=${!!_globalConfig}, alreadyAttempted=${_autoConfigAttempted})`);
+    return;
+  }
+  _autoConfigAttempted = true;
+  try {
+    const rc = globalThis.__APPILOTS_RC__;
+    if (rc && typeof rc === "object" && rc.projectId) {
+      console.log(`[Appilots] tryAutoConfig: found globalThis.__APPILOTS_RC__ with projectId="${rc.projectId}"`);
+      initAppilots(rc);
+    } else {
+      console.log("[Appilots] tryAutoConfig: globalThis.__APPILOTS_RC__ not found or missing projectId");
+    }
+  } catch {
+    console.warn("[Appilots] tryAutoConfig: error reading globalThis.__APPILOTS_RC__");
+  }
+}
+function getGlobalConfig() {
+  return _globalConfig;
+}
+
+// src/debug/actionTraceStore.ts
+var MAX_TRACE_ENTRIES = 200;
+var entries = [];
+var listeners = /* @__PURE__ */ new Set();
+var traceCounter = 0;
+function notify() {
+  const snapshot = [...entries];
+  listeners.forEach((listener) => listener(snapshot));
+}
+function append(entry) {
+  entries.push(entry);
+  if (entries.length > MAX_TRACE_ENTRIES) {
+    entries.splice(0, entries.length - MAX_TRACE_ENTRIES);
+  }
+  notify();
+}
+function recordAppilotsDebugTrace(entry) {
+  append({
+    ...entry,
+    id: entry.id ?? `trace_${++traceCounter}`
+  });
+}
+function actionFromEvent(event) {
+  const action = event.data?.action;
+  if (action && typeof action === "object" && typeof action.id === "string") {
+    return action;
+  }
+  return void 0;
+}
+function recordAppilotsEventTrace(event) {
+  if (!event.type.startsWith("agent:action:")) return;
+  const action = actionFromEvent(event);
+  const actionId = action?.id || (typeof event.data?.actionId === "string" ? event.data.actionId : void 0);
+  const actionType = action?.type || (typeof event.data?.actionType === "string" ? event.data.actionType : void 0);
+  recordAppilotsDebugTrace({
+    timestamp: event.timestamp,
+    type: event.type,
+    messageId: action?.messageId,
+    actionId,
+    actionType,
+    status: event.type === "agent:action:start" ? "started" : event.type === "agent:action:complete" ? "completed" : "error",
+    data: event.data
+  });
+}
+function getAppilotsDebugTraces() {
+  return [...entries];
+}
+function clearAppilotsDebugTraces() {
+  entries.splice(0, entries.length);
+  notify();
+}
+function subscribeAppilotsDebugTraces(listener) {
+  listeners.add(listener);
+  listener([...entries]);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+// src/introspection/fiberRoot.ts
+var _fiberRoot = null;
+function setFiberRoot(fiber) {
+  if (_fiberRoot !== fiber) {
+    console.log(`[Appilots] Introspection: fiber root captured (type=${typeName(fiber)})`);
+    _fiberRoot = fiber;
+  }
+}
+function getFiberRoot() {
+  return _fiberRoot;
+}
+function typeName(fiber) {
+  const t = fiber?.type ?? fiber?.elementType;
+  if (!t) return "unknown";
+  if (typeof t === "string") return t;
+  if (typeof t === "function") return t.displayName ?? t.name ?? "anonymous";
+  if (typeof t === "object") return t.displayName ?? t.render?.displayName ?? t.render?.name ?? "forwardRef/memo";
+  return String(t);
+}
+
+// src/introspection/AppilotsFiberRoot.tsx
+var FiberSentinel = class extends React2__default.default.Component {
+  componentDidMount() {
+    const fiber = this._reactInternals ?? this._reactInternalFiber ?? null;
+    if (!fiber) {
+      console.warn(
+        "[Appilots] FiberSentinel: this._reactInternals is undefined; snapshot capture will fall back to render-time owner. React version may be incompatible."
+      );
+      return;
+    }
+    let top = fiber;
+    while (top.return) top = top.return;
+    setFiberRoot(top);
+  }
+  render() {
+    return this.props.children ?? null;
+  }
+};
+function AppilotsFiberRoot({ children }) {
+  const Internals = React2__default.default.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED_IN_THIS_VERSION_OF_REACT;
+  const ownerFiber = Internals?.ReactCurrentOwner?.current;
+  if (ownerFiber && !getFiberRoot()) {
+    setFiberRoot(ownerFiber);
+  }
+  return /* @__PURE__ */ React2__default.default.createElement(FiberSentinel, null, children);
+}
+
+// src/debug/logger.ts
+var debugOverride;
+function setAppilotsDebugEnabled(enabled) {
+  debugOverride = enabled;
+}
+function isDebugEnabled() {
+  if (debugOverride !== void 0) return debugOverride;
+  return getGlobalConfig()?.debug === true;
+}
+function appilotsDebugWarn(...args) {
+  if (!isDebugEnabled()) return;
+  console.log("[Appilots]", ...args);
+}
+
+// src/context/AppilotsProvider.tsx
+var AppilotsContext = React2.createContext(null);
+function AppilotsProvider({ config: configProp, children, client: externalClient }) {
+  console.log(`[Appilots] AppilotsProvider initializing \u2014 config source: ${configProp ? "prop" : "auto (globalThis.__APPILOTS_RC__)"}`);
+  tryAutoConfig();
+  const globalConfig = getGlobalConfig();
+  console.log(`[Appilots] AppilotsProvider: configProp=${!!configProp}, globalConfig=${!!globalConfig}`);
+  const config = configProp ?? (globalConfig ? {
+    projectId: globalConfig.projectId,
+    apiBaseUrl: globalConfig.apiBaseUrl,
+    apiKey: globalConfig.apiKey,
+    permissions: globalConfig.permissions,
+    debug: globalConfig.debug,
+    appVersion: globalConfig.appVersion,
+    mcpVersion: globalConfig.mcpVersion,
+    fetchPersonalization: globalConfig.fetchPersonalization
+  } : null);
+  if (!config?.projectId) {
+    throw new Error(
+      "AppilotsProvider: No config found. Add withAppilots() to your metro.config.js and create a .appilotsrc file, or pass a config prop directly."
+    );
+  }
+  React2.useEffect(() => {
+    setAppilotsDebugEnabled(config.debug === true);
+  }, [config.debug]);
+  const listenersRef = React2.useRef(/* @__PURE__ */ new Set());
+  const subscribe = React2.useCallback((handler) => {
+    listenersRef.current.add(handler);
+    return () => {
+      listenersRef.current.delete(handler);
+    };
+  }, []);
+  const emit = React2.useCallback((event) => {
+    recordAppilotsEventTrace(event);
+    listenersRef.current.forEach((handler) => handler(event));
+  }, []);
+  const client = React2.useMemo(
+    () => externalClient ?? new AppilotsClient({
+      projectId: config.projectId,
+      apiBaseUrl: config.apiBaseUrl,
+      apiKey: config.apiKey,
+      debug: config.debug,
+      appVersion: config.appVersion,
+      mcpVersion: config.mcpVersion,
+      user: config.user
+    }),
+    [config.projectId, config.apiBaseUrl, config.apiKey, config.debug, config.appVersion, config.mcpVersion, config.user, externalClient]
+  );
+  const fetchPersonalizationEnabled = config.fetchPersonalization !== false;
+  const [remotePersonalization, setRemotePersonalization] = React2.useState(null);
+  React2.useEffect(() => {
+    if (!fetchPersonalizationEnabled) return;
+    let cancelled = false;
+    client.getPersonalization().then((data) => {
+      if (!cancelled) setRemotePersonalization(data);
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [client, fetchPersonalizationEnabled]);
+  const value = React2.useMemo(
+    () => ({ config, client, subscribe, emit, remotePersonalization }),
+    [config, client, subscribe, emit, remotePersonalization]
+  );
+  return /* @__PURE__ */ React2__default.default.createElement(AppilotsContext.Provider, { value }, /* @__PURE__ */ React2__default.default.createElement(AppilotsFiberRoot, null, children));
+}
+function useAppilotsContext() {
+  const context = React2.useContext(AppilotsContext);
+  if (!context) {
+    throw new Error("useAppilotsContext must be used within an <AppilotsProvider>");
+  }
+  return context;
+}
+
+// src/introspection/probeLoadingState.ts
+function getTypeName(type) {
+  if (!type) return null;
+  if (typeof type === "string") return type;
+  if (typeof type === "function") return type.displayName ?? type.name ?? null;
+  if (typeof type === "object") {
+    if (type.displayName) return type.displayName;
+    if (type.render) return type.render.displayName ?? type.render.name ?? null;
+    if (type.type) return getTypeName(type.type);
+  }
+  return null;
+}
+function matchesName(fiber, name) {
+  return getTypeName(fiber.type) === name || getTypeName(fiber.elementType) === name;
+}
+var SKELETON_NAME_RE = /skeleton|shimmer|contentloader/i;
+function looksLikeSkeleton(fiber) {
+  const name = getTypeName(fiber.type) ?? getTypeName(fiber.elementType);
+  return !!name && SKELETON_NAME_RE.test(name);
+}
+var SELF_REFERENTIAL_COMPONENTS = /* @__PURE__ */ new Set([
+  "AppilotsChat",
+  "AppilotsChatInner",
+  "ActionBreadcrumb",
+  "ConfirmDialog"
+]);
+function shouldSkipSubtree(fiber) {
+  const props = fiber.memoizedProps;
+  if (!props) return false;
+  const typeName2 = getTypeName(fiber.type) ?? getTypeName(fiber.elementType);
+  if (typeName2 && SELF_REFERENTIAL_COMPONENTS.has(typeName2)) return true;
+  if (props.__appilotsSkip === true || props["data-appilots-skip"] === true || props.appilotsSkip === true) {
+    return true;
+  }
+  if (matchesName(fiber, "Modal") && props.visible === false) return true;
+  if (matchesName(fiber, "Screen") && props.activityState === 0) return true;
+  const style = props.style;
+  if (style) {
+    const flat = Array.isArray(style) ? Object.assign({}, ...style.filter(Boolean)) : style;
+    if (flat?.display === "none") return true;
+    if (flat?.opacity === 0 && props.pointerEvents === "none") return true;
+  }
+  return false;
+}
+var TOUCHABLE_NAMES = /* @__PURE__ */ new Set([
+  "TouchableOpacity",
+  "TouchableHighlight",
+  "TouchableWithoutFeedback",
+  "TouchableNativeFeedback",
+  "Pressable"
+]);
+function isTouchable(fiber) {
+  return TOUCHABLE_NAMES.has(getTypeName(fiber.type) ?? "") || TOUCHABLE_NAMES.has(getTypeName(fiber.elementType) ?? "");
+}
+function pickId(props) {
+  return props?.testID ?? props?.accessibilityLabel ?? void 0;
+}
+function idMatches(candidate, target) {
+  if (!candidate) return false;
+  if (candidate === target) return true;
+  const c = candidate.toLowerCase();
+  const t = target.toLowerCase();
+  if (c === t) return true;
+  return c.endsWith(`-${t}`) || c.endsWith(`_${t}`) || t.endsWith(`-${c}`) || t.endsWith(`_${c}`);
+}
+function probeLoadingState(pressedComponentId, route) {
+  const root = getFiberRoot();
+  const result = {
+    loading: false,
+    pressedDisabled: false,
+    pressedFound: false,
+    modalOpen: false,
+    fingerprint: "",
+    visitedFibers: 0
+  };
+  if (!root) return result;
+  const buttonSigs = [];
+  const inputSigs = [];
+  const toggleSigs = [];
+  const visited = /* @__PURE__ */ new WeakSet();
+  const stack = [];
+  if (root.child) stack.push(root.child);
+  while (stack.length > 0) {
+    const fiber = stack.pop();
+    if (!fiber || visited.has(fiber)) continue;
+    visited.add(fiber);
+    result.visitedFibers++;
+    if (fiber.sibling) stack.push(fiber.sibling);
+    if (shouldSkipSubtree(fiber)) continue;
+    const props = fiber.memoizedProps ?? {};
+    if (matchesName(fiber, "ActivityIndicator") || looksLikeSkeleton(fiber)) {
+      result.loading = true;
+    } else if (matchesName(fiber, "Modal")) {
+      result.modalOpen = true;
+    } else if (isTouchable(fiber)) {
+      if (props.__appilotsInternal !== true) {
+        const id = pickId(props);
+        const disabled = !!props.disabled;
+        buttonSigs.push(`${id ?? "?"}:${disabled ? 1 : 0}`);
+        if (pressedComponentId && idMatches(id, pressedComponentId)) {
+          result.pressedFound = true;
+          if (disabled) result.pressedDisabled = true;
+        }
+      }
+    } else if (matchesName(fiber, "TextInput")) {
+      if (props.__appilotsInternal !== true) {
+        const id = pickId(props);
+        const editable = props.editable !== false;
+        inputSigs.push(`${id ?? "?"}:${editable ? 1 : 0}`);
+      }
+    } else if (matchesName(fiber, "Switch")) {
+      const id = pickId(props);
+      toggleSigs.push(`${id ?? "?"}:${props.value ? 1 : 0}`);
+    }
+    if (fiber.child) stack.push(fiber.child);
+  }
+  buttonSigs.sort();
+  inputSigs.sort();
+  toggleSigs.sort();
+  result.fingerprint = `r:${route ?? ""}|l:${result.loading ? 1 : 0}|m:${result.modalOpen ? 1 : 0}|b:${buttonSigs.join(",")}|i:${inputSigs.join(",")}|t:${toggleSigs.join(",")}`;
+  return result;
+}
+
+// src/navigation/navigationState.ts
+var _currentScreen = null;
+var _navigationRef = null;
+function setCurrentScreen(screen) {
+  console.log(`[Appilots] setCurrentScreen: "${_currentScreen}" \u2192 "${screen}"`);
+  _currentScreen = screen;
+}
+function getCurrentScreen() {
+  const activePath = getActiveRouteNames();
+  if (activePath.length > 0) {
+    const deepest = activePath[activePath.length - 1] ?? null;
+    if (deepest && deepest !== _currentScreen) {
+      if (_currentScreen) {
+        console.log(
+          `[Appilots] getCurrentScreen: active path differs from cached \u2014 deepest="${deepest}", cached="${_currentScreen}". Updating cache.`
+        );
+      }
+      _currentScreen = deepest;
+    }
+    if (deepest) return deepest;
+  }
+  if (_navigationRef) {
+    const liveScreen = getActiveRouteFromRef(_navigationRef);
+    if (liveScreen) {
+      if (liveScreen !== _currentScreen) {
+        console.log(`[Appilots] getCurrentScreen: live reading differs from cached \u2014 live="${liveScreen}", cached="${_currentScreen}". Updating cache.`);
+        _currentScreen = liveScreen;
+      }
+      return liveScreen;
+    }
+  }
+  return _currentScreen;
+}
+function setNavigationRef(ref) {
+  _navigationRef = ref;
+}
+function getNavigationRef() {
+  return _navigationRef;
+}
+function getActiveRouteFromState(state) {
+  if (!state) return void 0;
+  const route = state.routes?.[state.index ?? 0];
+  if (!route) return void 0;
+  if (route.state) return getActiveRouteFromState(route.state);
+  return route.name;
+}
+function getActiveRouteNamesFromState(state, out = []) {
+  if (!state) return out;
+  const route = state.routes?.[state.index ?? 0];
+  if (!route) return out;
+  if (typeof route.name === "string" && route.name) out.push(route.name);
+  if (route.state) return getActiveRouteNamesFromState(route.state, out);
+  return out;
+}
+function getActiveRouteNames() {
+  if (!_navigationRef) return _currentScreen ? [_currentScreen] : [];
+  try {
+    const state = _navigationRef.getRootState?.() ?? _navigationRef.getState?.();
+    if (!state || isStaleState(state)) return _currentScreen ? [_currentScreen] : [];
+    const names = getActiveRouteNamesFromState(state);
+    if (names.length === 0 && _currentScreen) names.push(_currentScreen);
+    return names;
+  } catch {
+    return _currentScreen ? [_currentScreen] : [];
+  }
+}
+function routeNamesAtState(state) {
+  if (!state) return [];
+  if (Array.isArray(state.routeNames)) {
+    return state.routeNames.filter((name) => typeof name === "string" && name.length > 0);
+  }
+  if (Array.isArray(state.routes)) {
+    return state.routes.map((route) => route?.name).filter((name) => typeof name === "string" && name.length > 0);
+  }
+  return [];
+}
+function collectRouteNamesFromState(state, out = /* @__PURE__ */ new Set()) {
+  if (!state) return out;
+  for (const name of routeNamesAtState(state)) out.add(name);
+  for (const route of state.routes ?? []) {
+    if (typeof route?.name === "string" && route.name.length > 0) out.add(route.name);
+    if (route?.state) collectRouteNamesFromState(route.state, out);
+  }
+  return out;
+}
+function getDeepestNavigatorState(state) {
+  if (!state) return void 0;
+  const route = state.routes?.[state.index ?? 0];
+  if (route?.state) return getDeepestNavigatorState(route.state);
+  return state;
+}
+function getNavigationStateSnapshot() {
+  if (!_navigationRef) {
+    const current = _currentScreen ? [_currentScreen] : [];
+    return current.length > 0 ? {
+      currentRouteName: _currentScreen ?? void 0,
+      activePath: current,
+      rootRouteNames: current,
+      currentRouteNames: current,
+      routeNames: current
+    } : null;
+  }
+  try {
+    const state = _navigationRef.getRootState?.() ?? _navigationRef.getState?.();
+    if (!state || isStaleState(state)) {
+      const current = _currentScreen ? [_currentScreen] : [];
+      return current.length > 0 ? {
+        currentRouteName: _currentScreen ?? void 0,
+        activePath: current,
+        rootRouteNames: current,
+        currentRouteNames: current,
+        routeNames: current,
+        canGoBack: typeof _navigationRef.canGoBack === "function" ? _navigationRef.canGoBack() : void 0
+      } : null;
+    }
+    const activePath = getActiveRouteNamesFromState(state);
+    const currentRouteName = activePath[activePath.length - 1] ?? _currentScreen ?? void 0;
+    const deepestState = getDeepestNavigatorState(state);
+    const routeNames = Array.from(collectRouteNamesFromState(state));
+    return {
+      currentRouteName,
+      activePath,
+      rootRouteNames: routeNamesAtState(state),
+      currentRouteNames: routeNamesAtState(deepestState),
+      routeNames,
+      canGoBack: typeof _navigationRef.canGoBack === "function" ? _navigationRef.canGoBack() : void 0
+    };
+  } catch {
+    const current = _currentScreen ? [_currentScreen] : [];
+    return current.length > 0 ? {
+      currentRouteName: _currentScreen ?? void 0,
+      activePath: current,
+      rootRouteNames: current,
+      currentRouteNames: current,
+      routeNames: current
+    } : null;
+  }
+}
+function getActiveRouteSignatureFromState(state) {
+  if (!state) return void 0;
+  const route = state.routes?.[state.index ?? 0];
+  if (!route) return void 0;
+  if (route.state) return getActiveRouteSignatureFromState(route.state);
+  const params = route.params;
+  let paramsStr = "";
+  if (params && typeof params === "object") {
+    try {
+      const keys = Object.keys(params).sort();
+      const ordered = {};
+      for (const k of keys) ordered[k] = params[k];
+      paramsStr = JSON.stringify(ordered);
+    } catch {
+      paramsStr = "<unserializable>";
+    }
+  }
+  return `${route.name}|${paramsStr}`;
+}
+function getCurrentScreenSignature() {
+  if (!_navigationRef) return null;
+  try {
+    const state = _navigationRef.getRootState?.() ?? _navigationRef.getState?.();
+    if (!state) return null;
+    if (isStaleState(state)) return null;
+    return getActiveRouteSignatureFromState(state) ?? null;
+  } catch {
+    return null;
+  }
+}
+function isStaleState(state) {
+  return state?.stale === true;
+}
+function getActiveRouteFromRef(navRef) {
+  try {
+    const state = navRef.getRootState?.() ?? navRef.getState?.();
+    if (state) {
+      if (isStaleState(state)) {
+        return null;
+      }
+      return getActiveRouteFromState(state) ?? null;
+    }
+    return navRef.getCurrentRoute?.()?.name ?? null;
+  } catch {
+    return null;
+  }
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function normalizeRouteFamily(name) {
+  return name.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/(tab|list|screen|details?|navigator)$/i, "");
+}
+function routesBelongToSameFeature(a, b) {
+  const na = normalizeRouteFamily(a);
+  const nb = normalizeRouteFamily(b);
+  if (!na || !nb) return false;
+  if (na === nb) return true;
+  return na.startsWith(nb) || nb.startsWith(na);
+}
+function navigationTargetReached(target, fromScreen) {
+  const cur = getCurrentScreen();
+  const path = getActiveRouteNames();
+  if (cur === target || path.includes(target)) return true;
+  if (cur && fromScreen && cur !== fromScreen && routesBelongToSameFeature(cur, target)) {
+    return true;
+  }
+  for (const route of path) {
+    if (route !== fromScreen && routesBelongToSameFeature(route, target)) return true;
+  }
+  return false;
+}
+function screenDepartedBaseline(fromScreen, fromSignature) {
+  if (fromSignature) {
+    const curSig = getCurrentScreenSignature();
+    return !!(curSig && curSig !== fromSignature);
+  }
+  const cur = getCurrentScreen();
+  return !!(cur && fromScreen && cur !== fromScreen);
+}
+async function waitForScreenSettle(opts = {}) {
+  const maxMs = opts.maxMs ?? 3500;
+  const pollMs = opts.pollMs ?? 75;
+  const stableTarget = opts.stableReads ?? 3;
+  const mountFlushMs = opts.mountFlushMs ?? 150;
+  const expectingChange = opts.expectingChange ?? false;
+  const fromScreen = opts.fromScreen ?? null;
+  const fromSignature = opts.fromSignature ?? null;
+  const targetScreen = opts.targetScreen ?? null;
+  const startMs = Date.now();
+  const remaining = () => maxMs - (Date.now() - startMs);
+  let transitioned = false;
+  if (expectingChange) {
+    while (remaining() > 0) {
+      if (targetScreen) {
+        if (navigationTargetReached(targetScreen, fromScreen)) {
+          transitioned = true;
+          break;
+        }
+      } else if (fromSignature) {
+        const curSig = getCurrentScreenSignature();
+        if (curSig && curSig !== fromSignature) {
+          transitioned = true;
+          break;
+        }
+      } else if (screenDepartedBaseline(fromScreen, null)) {
+        transitioned = true;
+        break;
+      }
+      await sleep(pollMs);
+    }
+    if (!transitioned) {
+      const partialMove = screenDepartedBaseline(fromScreen, fromSignature);
+      if (!partialMove) {
+        return {
+          screen: getCurrentScreen(),
+          transitioned: false,
+          timedOut: true,
+          waitedMs: Date.now() - startMs
+        };
+      }
+      transitioned = true;
+    }
+  }
+  let last = getCurrentScreen();
+  let stableCount = 1;
+  while (remaining() > 0) {
+    await sleep(pollMs);
+    const cur = getCurrentScreen();
+    if (cur === last) {
+      stableCount++;
+      if (stableCount >= stableTarget) {
+        const flush = Math.min(mountFlushMs, Math.max(0, remaining()));
+        if (flush > 0) await sleep(flush);
+        return {
+          screen: cur,
+          transitioned,
+          timedOut: false,
+          waitedMs: Date.now() - startMs
+        };
+      }
+    } else {
+      stableCount = 1;
+      last = cur;
+    }
+  }
+  return {
+    screen: getCurrentScreen(),
+    transitioned,
+    timedOut: true,
+    waitedMs: Date.now() - startMs
+  };
+}
+var sleepMs = (ms) => new Promise((r) => setTimeout(r, ms));
+async function waitForLoadingSettle(opts = {}) {
+  const maxMs = opts.maxMs ?? 6e3;
+  const initialPollMs = opts.pollMs ?? 150;
+  const backoffFactor = opts.backoffFactor ?? 1.5;
+  const pollMaxMs = opts.pollMaxMs ?? 1e3;
+  const stableTarget = opts.stableReads ?? 2;
+  const pressedComponentId = opts.pressedComponentId ?? null;
+  const fromScreen = opts.fromScreen ?? null;
+  const startMs = Date.now();
+  const remaining = () => maxMs - (Date.now() - startMs);
+  let probe = probeLoadingState(pressedComponentId, getCurrentScreen());
+  let probeCount = 1;
+  let stableCount = 1;
+  let lastFingerprint = probe.fingerprint;
+  let interval = initialPollMs;
+  const looksImmediatelyClean = !probe.loading && !probe.pressedDisabled && (!pressedComponentId || probe.pressedFound);
+  if (looksImmediatelyClean) {
+    await sleepMs(Math.min(80, Math.max(0, remaining())));
+    const recheck = probeLoadingState(pressedComponentId, getCurrentScreen());
+    probeCount++;
+    if (!recheck.loading && !recheck.pressedDisabled && recheck.fingerprint === probe.fingerprint) {
+      return {
+        settled: true,
+        transitioned: false,
+        loadingPending: false,
+        screen: getCurrentScreen(),
+        waitedMs: Date.now() - startMs,
+        probeCount
+      };
+    }
+    probe = recheck;
+    lastFingerprint = recheck.fingerprint;
+    stableCount = 1;
+  }
+  while (remaining() > 0) {
+    const sleepFor = Math.min(interval, Math.max(0, remaining()));
+    if (sleepFor === 0) break;
+    await sleepMs(sleepFor);
+    const currentScreen = getCurrentScreen();
+    if (fromScreen && currentScreen && currentScreen !== fromScreen) {
+      return {
+        settled: true,
+        transitioned: true,
+        loadingPending: false,
+        screen: currentScreen,
+        waitedMs: Date.now() - startMs,
+        probeCount
+      };
+    }
+    probe = probeLoadingState(pressedComponentId, currentScreen);
+    probeCount++;
+    const quiescent = !probe.loading && !probe.pressedDisabled && probe.fingerprint === lastFingerprint;
+    if (quiescent) {
+      stableCount++;
+      if (stableCount >= stableTarget) {
+        return {
+          settled: true,
+          transitioned: false,
+          loadingPending: false,
+          screen: currentScreen,
+          waitedMs: Date.now() - startMs,
+          probeCount
+        };
+      }
+    } else {
+      stableCount = 1;
+      lastFingerprint = probe.fingerprint;
+    }
+    interval = Math.min(pollMaxMs, Math.round(interval * backoffFactor));
+  }
+  const stillPending = probe.loading || probe.pressedDisabled;
+  return {
+    settled: !stillPending,
+    transitioned: false,
+    loadingPending: stillPending,
+    screen: getCurrentScreen(),
+    waitedMs: Date.now() - startMs,
+    probeCount
+  };
+}
+
+// src/navigation/registerScreen.ts
+var screenRegistry = /* @__PURE__ */ new Map();
+function registerScreen(metadata) {
+  screenRegistry.set(metadata.name, metadata);
+}
+function getScreenMetadata(name) {
+  return screenRegistry.get(name);
+}
+function getAllScreens() {
+  return Array.from(screenRegistry.values());
+}
+function clearScreenRegistry() {
+  screenRegistry.clear();
+}
+
+exports.AppilotsClient = AppilotsClient;
+exports.AppilotsProvider = AppilotsProvider;
+exports.AppilotsRegistryProvider = AppilotsRegistryProvider;
+exports.SDK_VERSION = SDK_VERSION;
+exports.StreamAbortError = StreamAbortError;
+exports.StreamTransportError = StreamTransportError;
+exports._patchJsxRuntimes = _patchJsxRuntimes;
+exports.appilotsDebugWarn = appilotsDebugWarn;
+exports.clearAppilotsDebugTraces = clearAppilotsDebugTraces;
+exports.clearScreenRegistry = clearScreenRegistry;
+exports.componentRegistry = componentRegistry;
+exports.createComponentRegistry = createComponentRegistry;
+exports.createElementRegistry = createElementRegistry;
+exports.createListRegistry = createListRegistry;
+exports.elementRegistry = elementRegistry;
+exports.enableAppilotsAutoTracking = enableAppilotsAutoTracking;
+exports.getActiveRouteNames = getActiveRouteNames;
+exports.getAllScreens = getAllScreens;
+exports.getAppilotsDebugTraces = getAppilotsDebugTraces;
+exports.getCurrentScreen = getCurrentScreen;
+exports.getCurrentScreenSignature = getCurrentScreenSignature;
+exports.getDefaultRegistry = getDefaultRegistry;
+exports.getFiberRoot = getFiberRoot;
+exports.getGlobalConfig = getGlobalConfig;
+exports.getNavigationRef = getNavigationRef;
+exports.getNavigationStateSnapshot = getNavigationStateSnapshot;
+exports.getScreenMetadata = getScreenMetadata;
+exports.initAppilots = initAppilots;
+exports.isAutoTrackingEnabled = isAutoTrackingEnabled;
+exports.listRegistry = listRegistry;
+exports.probeLoadingState = probeLoadingState;
+exports.recordAppilotsDebugTrace = recordAppilotsDebugTrace;
+exports.registerScreen = registerScreen;
+exports.routesBelongToSameFeature = routesBelongToSameFeature;
+exports.screenDepartedBaseline = screenDepartedBaseline;
+exports.setCurrentScreen = setCurrentScreen;
+exports.setNavigationRef = setNavigationRef;
+exports.subscribeAppilotsDebugTraces = subscribeAppilotsDebugTraces;
+exports.useAppilotsContext = useAppilotsContext;
+exports.useResolvedRegistry = useResolvedRegistry;
+exports.waitForLoadingSettle = waitForLoadingSettle;
+exports.waitForScreenSettle = waitForScreenSettle;