@appilots/cli 0.3.0 → 0.10.0

package/dist/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var fs = require('fs/promises');
-var path6 = require('path');
+var path8 = require('path');
 var traverse4 = require('@babel/traverse');
 var BabelTypes = require('@babel/types');
 var glob = require('fast-glob');
@@ -30,7 +30,7 @@ function _interopNamespace(e) {
 }
 
 var fs__default = /*#__PURE__*/_interopDefault(fs);
-var path6__namespace = /*#__PURE__*/_interopNamespace(path6);
+var path8__namespace = /*#__PURE__*/_interopNamespace(path8);
 var traverse4__default = /*#__PURE__*/_interopDefault(traverse4);
 var BabelTypes__namespace = /*#__PURE__*/_interopNamespace(BabelTypes);
 var glob__default = /*#__PURE__*/_interopDefault(glob);
@@ -83,6 +83,45 @@ function hasJsxAttribute(element, name) {
 }
 
 // src/ast/jsx/classify.ts
+var NON_INTERACTION_HANDLERS = /* @__PURE__ */ new Set([
+  "onLayout",
+  "onScroll",
+  "onScrollBeginDrag",
+  "onScrollEndDrag",
+  "onMomentumScrollBegin",
+  "onMomentumScrollEnd",
+  "onContentSizeChange",
+  "onEndReached",
+  "onViewableItemsChanged",
+  "onLoad",
+  "onLoadStart",
+  "onLoadEnd",
+  "onError",
+  "onProgress",
+  "onFocus",
+  "onBlur"
+]);
+var VALUE_HANDLERS = /* @__PURE__ */ new Set([
+  "onChange",
+  "onChangeText",
+  "onValueChange",
+  "onSelect",
+  "onSelectionChange",
+  "onSubmitEditing"
+]);
+function pressHandlerProp(element) {
+  let fallback;
+  for (const attr of element.attributes) {
+    if (attr.type !== "JSXAttribute" || attr.name.type !== "JSXIdentifier") continue;
+    const name = attr.name.name;
+    if (!/^on[A-Z]/.test(name)) continue;
+    if (attr.value?.type !== "JSXExpressionContainer") continue;
+    if (name === "onPress") return name;
+    if (NON_INTERACTION_HANDLERS.has(name) || VALUE_HANDLERS.has(name)) continue;
+    fallback ??= name;
+  }
+  return fallback;
+}
 var VIEW_COMPONENTS = /* @__PURE__ */ new Set(["View", "ScrollView", "SafeAreaView", "KeyboardAvoidingView"]);
 var INPUT_COMPONENTS = /* @__PURE__ */ new Set(["TextInput", "Input", "HocInput"]);
 var BUTTON_COMPONENTS = /* @__PURE__ */ new Set(["TouchableOpacity", "Pressable", "Button"]);
@@ -97,17 +136,16 @@ function classifyJsxComponent(name, element) {
   if (INPUT_COMPONENTS.has(name)) return "input";
   if (BUTTON_COMPONENTS.has(name)) return "button";
   if (element) {
-    const hasOptions = hasJsxAttribute(element, "options");
+    const hasOptions = hasJsxAttribute(element, "options") || hasJsxAttribute(element, "segments") || hasJsxAttribute(element, "choices") || hasJsxAttribute(element, "tabs");
     const hasValue = hasJsxAttribute(element, "value");
     const hasChecked = hasJsxAttribute(element, "checked") || hasJsxAttribute(element, "selected");
     const hasOnChange = hasJsxAttribute(element, "onChange") || hasJsxAttribute(element, "onValueChange") || hasJsxAttribute(element, "onChangeText");
-    const hasOnPress = hasJsxAttribute(element, "onPress");
     if (hasOptions && (hasValue || hasOnChange)) return "select";
     if (hasChecked && hasOnChange) return "toggle";
     if (hasOnChange && (hasJsxAttribute(element, "label") || hasJsxAttribute(element, "placeholder"))) {
       return "input";
     }
-    if (hasOnPress) return "button";
+    if (pressHandlerProp(element)) return "button";
     if (getStringAttr(element, "visible") || getExpressionIdentifierAttr(element, "visible")) {
       return "modal";
     }
@@ -419,12 +457,12 @@ var ScreenAnalyzer = class {
         cwd: this.config.rootDir,
         ignore: exclude
       });
-      screenPatternFiles = new Set(matched.map((f) => path6__namespace.default.resolve(this.config.rootDir, f)));
+      screenPatternFiles = new Set(matched.map((f) => path8__namespace.default.resolve(this.config.rootDir, f)));
     }
     const screens = [];
     this.screensFilteredOut = 0;
     for (const file of files) {
-      const filePath = path6__namespace.default.resolve(this.config.rootDir, file);
+      const filePath = path8__namespace.default.resolve(this.config.rootDir, file);
       try {
         const descriptor = await this.analyzeFile(filePath);
         if (!descriptor) continue;
@@ -445,12 +483,17 @@ var ScreenAnalyzer = class {
         }
       } catch (error) {
         if (this.verbose) {
-          console.warn(`[ScreenAnalyzer] Failed to parse ${file}:`, error instanceof Error ? error.message : error);
+          console.warn(
+            `[ScreenAnalyzer] Failed to parse ${file}:`,
+            error instanceof Error ? error.message : error
+          );
         }
       }
     }
     if (this.verbose && this.strictScreens) {
-      console.log(`[ScreenAnalyzer] Strict mode: ${screens.length} included, ${this.screensFilteredOut} filtered out`);
+      console.log(
+        `[ScreenAnalyzer] Strict mode: ${screens.length} included, ${this.screensFilteredOut} filtered out`
+      );
     }
     return screens;
   }
@@ -738,7 +781,11 @@ var ScreenAnalyzer = class {
     for (const form of secondary) {
       const existing = out.find((candidate) => candidate.id === form.id) ?? this.findFormWithSharedFields(out, form);
       if (!existing) {
-        out.push({ ...form, fields: [...form.fields], submitAction: this.namedSubmitAction(form.submitAction) });
+        out.push({
+          ...form,
+          fields: [...form.fields],
+          submitAction: this.namedSubmitAction(form.submitAction)
+        });
         continue;
       }
       for (const field of form.fields) {
@@ -757,9 +804,12 @@ var ScreenAnalyzer = class {
   findEquivalentField(fields, incoming) {
     return fields.find((field) => {
       if (field.name && incoming.name && field.name === incoming.name) return true;
-      if (field.valueBinding && incoming.valueBinding && field.valueBinding === incoming.valueBinding) return true;
-      if (field.locator?.id && incoming.locator?.id && field.locator.id === incoming.locator.id) return true;
-      if (field.placeholder && incoming.placeholder && field.placeholder === incoming.placeholder) return true;
+      if (field.valueBinding && incoming.valueBinding && field.valueBinding === incoming.valueBinding)
+        return true;
+      if (field.locator?.id && incoming.locator?.id && field.locator.id === incoming.locator.id)
+        return true;
+      if (field.placeholder && incoming.placeholder && field.placeholder === incoming.placeholder)
+        return true;
       if (field.locator?.accessibilityLabel && incoming.locator?.accessibilityLabel && field.locator.accessibilityLabel === incoming.locator.accessibilityLabel) {
         return true;
       }
@@ -919,9 +969,11 @@ var ScreenAnalyzer = class {
               source: field.locator?.source ?? "accessibilityLabel"
             });
           } else if (attrName === "keyboardType") {
-            if (attr.value.value === "email-address" || attr.value.value === "email") field.type = "email";
+            if (attr.value.value === "email-address" || attr.value.value === "email")
+              field.type = "email";
             if (attr.value.value === "phone-pad") field.type = "phone";
-            if (attr.value.value === "numeric" || attr.value.value === "number-pad") field.type = "number";
+            if (attr.value.value === "numeric" || attr.value.value === "number-pad")
+              field.type = "number";
           }
         } else if (BabelTypes__namespace.isJSXExpressionContainer(attr.value)) {
           if (attrName === "value" && BabelTypes__namespace.isIdentifier(attr.value.expression)) {
@@ -1087,8 +1139,10 @@ var ScreenAnalyzer = class {
       };
       if (handler.nativeConfirmationExpected) action.nativeConfirmationExpected = true;
       if (handler.targetScreen && !action.targetScreen) action.targetScreen = handler.targetScreen;
-      if (handler.successSignal && !action.successSignal) action.successSignal = handler.successSignal;
-      if (handler.failureSignal && !action.failureSignal) action.failureSignal = handler.failureSignal;
+      if (handler.successSignal && !action.successSignal)
+        action.successSignal = handler.successSignal;
+      if (handler.failureSignal && !action.failureSignal)
+        action.failureSignal = handler.failureSignal;
       if (handler.opensModal && !action.opensModal) action.opensModal = handler.opensModal;
       if (handler.destructive || action.destructive === true || action.requiresConfirmation === true || action.effect === "destructive" || action.riskLevel === "high") {
         action.destructive = true;
@@ -1106,6 +1160,7 @@ var ScreenAnalyzer = class {
         if (!BabelTypes__namespace.isJSXIdentifier(element.name)) return;
         const componentName = element.name.name;
         if (classifyJsxComponent(componentName, element) !== "button") return;
+        const pressProp = pressHandlerProp(element);
         let label;
         let handler;
         for (const attr of element.attributes) {
@@ -1115,7 +1170,7 @@ var ScreenAnalyzer = class {
           if ((attrName === "title" || attrName === "accessibilityLabel" || attrName === "label") && BabelTypes__namespace.isStringLiteral(attr.value)) {
             label = attr.value.value;
           }
-          if (attrName === "onPress" && BabelTypes__namespace.isJSXExpressionContainer(attr.value) && BabelTypes__namespace.isIdentifier(attr.value.expression)) {
+          if (attrName === pressProp && BabelTypes__namespace.isJSXExpressionContainer(attr.value) && BabelTypes__namespace.isIdentifier(attr.value.expression)) {
             handler = attr.value.expression.name;
           }
         }
@@ -1181,10 +1236,13 @@ var ScreenAnalyzer = class {
       }
     };
     if (fn.body) {
-      traverse4__default.default(fn.body, {
-        noScope: true,
-        enter: (nodePath) => inspectNode(nodePath.node)
-      });
+      traverse4__default.default(
+        fn.body,
+        {
+          noScope: true,
+          enter: (nodePath) => inspectNode(nodePath.node)
+        }
+      );
     }
     const expectedOutcome = targetScreen ? "navigation" : hasStateSetter ? "inline-feedback" : hasAwait || hasThen ? "mixed" : "none";
     return {
@@ -1213,7 +1271,7 @@ var ScreenAnalyzer = class {
    * heuristic must hit OR the JSDoc tag must be present.
    */
   isElementDestructive(element, handlerName, actionId) {
-    const DESTRUCTIVE_VERB2 = /(delete|destroy|remove|discard|wipe|erase|drop|terminate|revoke|deactivate|disable)/i;
+    const DESTRUCTIVE_VERB3 = /(delete|destroy|remove|discard|wipe|erase|drop|terminate|revoke|deactivate|disable)/i;
     for (const attr of element.attributes) {
       if (!BabelTypes__namespace.isJSXAttribute(attr)) continue;
       const attrName = BabelTypes__namespace.isJSXIdentifier(attr.name) ? attr.name.name : null;
@@ -1228,8 +1286,8 @@ var ScreenAnalyzer = class {
         }
       }
     }
-    if (handlerName && DESTRUCTIVE_VERB2.test(handlerName)) return true;
-    if (actionId && DESTRUCTIVE_VERB2.test(actionId)) return true;
+    if (handlerName && DESTRUCTIVE_VERB3.test(handlerName)) return true;
+    if (actionId && DESTRUCTIVE_VERB3.test(actionId)) return true;
     return false;
   }
   /**
@@ -1242,6 +1300,7 @@ var ScreenAnalyzer = class {
     };
     const componentName = BabelTypes__namespace.isJSXIdentifier(element.name) ? element.name.name : void 0;
     action.sourceComponent = componentName;
+    const pressProp = pressHandlerProp(element) ?? "onPress";
     let handlerName;
     for (const attr of element.attributes) {
       if (!BabelTypes__namespace.isJSXAttribute(attr)) continue;
@@ -1276,7 +1335,7 @@ var ScreenAnalyzer = class {
             }
           }
         } else if (BabelTypes__namespace.isJSXExpressionContainer(attr.value)) {
-          if (attrName === "onPress" && BabelTypes__namespace.isIdentifier(attr.value.expression)) {
+          if (attrName === pressProp && BabelTypes__namespace.isIdentifier(attr.value.expression)) {
             handlerName = attr.value.expression.name.toLowerCase();
             action.handler = attr.value.expression.name;
             if (handlerName.includes("submit")) {
@@ -1284,7 +1343,7 @@ var ScreenAnalyzer = class {
             } else if (handlerName.includes("navigate")) {
               action.type = "navigation";
             }
-          } else if (attrName === "onPress") {
+          } else if (attrName === pressProp) {
             const inline = this.extractInlineOnPressMetadata(attr.value.expression);
             if (inline.handler) {
               handlerName = inline.handler.toLowerCase();
@@ -1308,7 +1367,11 @@ var ScreenAnalyzer = class {
       }
     }
     if (!action.locator && action.id) {
-      action.locator = { id: action.id, label: action.label, source: action.label ? "label" : "inferred" };
+      action.locator = {
+        id: action.id,
+        label: action.label,
+        source: action.label ? "label" : "inferred"
+      };
     }
     if (this.isElementDestructive(element, handlerName, action.id)) {
       action.destructive = true;
@@ -1450,24 +1513,27 @@ var ScreenAnalyzer = class {
   }
   extractRowAction(fn) {
     let action;
-    traverse4__default.default(fn.body, {
-      noScope: true,
-      CallExpression: (nodePath) => {
-        const node = nodePath.node;
-        if (!BabelTypes__namespace.isMemberExpression(node.callee) || !BabelTypes__namespace.isIdentifier(node.callee.object) || node.callee.object.name !== "navigation" || !BabelTypes__namespace.isIdentifier(node.callee.property) || !["navigate", "push", "replace"].includes(node.callee.property.name)) {
-          return;
+    traverse4__default.default(
+      fn.body,
+      {
+        noScope: true,
+        CallExpression: (nodePath) => {
+          const node = nodePath.node;
+          if (!BabelTypes__namespace.isMemberExpression(node.callee) || !BabelTypes__namespace.isIdentifier(node.callee.object) || node.callee.object.name !== "navigation" || !BabelTypes__namespace.isIdentifier(node.callee.property) || !["navigate", "push", "replace"].includes(node.callee.property.name)) {
+            return;
+          }
+          const firstArg = node.arguments[0];
+          if (!BabelTypes__namespace.isStringLiteral(firstArg)) return;
+          const params = this.extractNavigationParams(node.arguments[1]);
+          action = {
+            type: "navigation",
+            targetScreen: firstArg.value,
+            ...Object.keys(params).length > 0 ? { params } : {},
+            description: `Pressing a row opens ${firstArg.value}`
+          };
         }
-        const firstArg = node.arguments[0];
-        if (!BabelTypes__namespace.isStringLiteral(firstArg)) return;
-        const params = this.extractNavigationParams(node.arguments[1]);
-        action = {
-          type: "navigation",
-          targetScreen: firstArg.value,
-          ...Object.keys(params).length > 0 ? { params } : {},
-          description: `Pressing a row opens ${firstArg.value}`
-        };
       }
-    });
+    );
     return action;
   }
   extractNavigationParams(arg) {
@@ -1500,15 +1566,18 @@ var ScreenAnalyzer = class {
     } else if (BabelTypes__namespace.isIdentifier(firstParam)) {
       itemNames.add(firstParam.name);
     }
-    traverse4__default.default(fn.body, {
-      noScope: true,
-      MemberExpression: (nodePath) => {
-        const node = nodePath.node;
-        if (BabelTypes__namespace.isIdentifier(node.object) && itemNames.has(node.object.name) && BabelTypes__namespace.isIdentifier(node.property)) {
-          fields.add(node.property.name);
+    traverse4__default.default(
+      fn.body,
+      {
+        noScope: true,
+        MemberExpression: (nodePath) => {
+          const node = nodePath.node;
+          if (BabelTypes__namespace.isIdentifier(node.object) && itemNames.has(node.object.name) && BabelTypes__namespace.isIdentifier(node.property)) {
+            fields.add(node.property.name);
+          }
         }
       }
-    });
+    );
     return Array.from(fields).sort();
   }
   inferItemType(dataSource, renderItem, displayFields) {
@@ -1520,11 +1589,19 @@ var ScreenAnalyzer = class {
     if (displayFields.length > 0) return "Item";
     return void 0;
   }
+  /**
+   * Identity comes from how a field is NAMED, not from what the app
+   * sells: `id`/`uuid`/`key`/`slug` are conventions any codebase uses,
+   * `name`/`title`/`email` are how any row introduces itself. `plate`
+   * used to sit in this list and read like one of them — but it is the
+   * example app's schema, and no other tenant ever got its equivalent
+   * (`mrn`, `trackingNumber`, `sku`) added here.
+   */
   inferIdentityFields(keyField, displayFields) {
     const out = /* @__PURE__ */ new Set();
     if (keyField) out.add(keyField);
     for (const field of displayFields) {
-      if (/^(id|uuid|key|name|title|plate|email|slug)$/i.test(field)) out.add(field);
+      if (/^(id|uuid|key|name|title|email|slug)$/i.test(field)) out.add(field);
     }
     return Array.from(out);
   }
@@ -1535,17 +1612,23 @@ var ScreenAnalyzer = class {
       CallExpression: (nodePath) => {
         const node = nodePath.node;
         if (!BabelTypes__namespace.isMemberExpression(node.callee)) return;
-        if (!BabelTypes__namespace.isIdentifier(node.callee.property) || node.callee.property.name !== "filter") return;
-        if (!BabelTypes__namespace.isIdentifier(node.callee.object) || node.callee.object.name !== dataSource) return;
+        if (!BabelTypes__namespace.isIdentifier(node.callee.property) || node.callee.property.name !== "filter")
+          return;
+        if (!BabelTypes__namespace.isIdentifier(node.callee.object) || node.callee.object.name !== dataSource)
+          return;
         const fn = node.arguments[0];
-        if (!BabelTypes__namespace.isArrowFunctionExpression(fn) && !BabelTypes__namespace.isFunctionExpression(fn)) return;
-        traverse4__default.default(fn.body, {
-          noScope: true,
-          Identifier: (innerPath) => {
-            const name = innerPath.node.name;
-            if (/query|search|filter/i.test(name)) queryBinding = queryBinding ?? name;
+        if (!BabelTypes__namespace.isArrowFunctionExpression(fn) && !BabelTypes__namespace.isFunctionExpression(fn))
+          return;
+        traverse4__default.default(
+          fn.body,
+          {
+            noScope: true,
+            Identifier: (innerPath) => {
+              const name = innerPath.node.name;
+              if (/query|search|filter/i.test(name)) queryBinding = queryBinding ?? name;
+            }
           }
-        });
+        );
       }
     });
     return queryBinding;
@@ -1573,7 +1656,7 @@ var ScreenAnalyzer = class {
    * E.g., /src/screens/ItemListScreen.tsx -> ItemListScreen
    */
   extractScreenName(filePath) {
-    const basename2 = path6__namespace.default.basename(filePath);
+    const basename2 = path8__namespace.default.basename(filePath);
     return basename2.replace(/\.(tsx?|jsx?)$/, "");
   }
 };
@@ -1628,7 +1711,7 @@ var NavigationAnalyzer = class {
       cwd: this.config.rootDir,
       ignore: excludePatterns
     });
-    return files.map((file) => path6__namespace.default.join(this.config.rootDir, file));
+    return files.map((file) => path8__namespace.default.join(this.config.rootDir, file));
   }
   /** Parse navigator definitions from a file */
   parseNavigators(content, filePath) {
@@ -1689,11 +1772,7 @@ var NavigationAnalyzer = class {
                 if (BabelTypes__namespace.isJSXAttribute(initialRouteAttr) && BabelTypes__namespace.isStringLiteral(initialRouteAttr.value)) {
                   navigator.initialRouteName = initialRouteAttr.value.value;
                 }
-                const screens = this.extractScreensFromNavigator(
-                  node,
-                  objectName,
-                  navigator.type
-                );
+                const screens = this.extractScreensFromNavigator(node, objectName, navigator.type);
                 screensByNavigator.set(objectName, screens);
               }
             }
@@ -1710,27 +1789,112 @@ var NavigationAnalyzer = class {
     }
     return navigators;
   }
+  /**
+   * Is this JSX element `<navigatorVarName.MEMBER …>`?
+   */
+  // Deliberately NOT a type predicate (`node is t.JSXElement`): a false
+  // result would then narrow `node` to "not a JSXElement", and the very
+  // next check — the same node against a different member — would see
+  // `never`. It is a question about the member name, not about the node
+  // kind.
+  isNavigatorMember(node, navigatorVarName, member) {
+    if (!BabelTypes__namespace.isJSXElement(node)) return false;
+    const name = node.openingElement.name;
+    return BabelTypes__namespace.isJSXMemberExpression(name) && BabelTypes__namespace.isJSXIdentifier(name.object) && name.object.name === navigatorVarName && BabelTypes__namespace.isJSXIdentifier(name.property) && name.property.name === member;
+  }
+  /**
+   * Flatten a navigator's JSX children into the `<X.Screen>` elements they
+   * contain, unwrapping every container a real app puts in between.
+   *
+   * The old version compared `t.isJSXElement(child)` against the direct
+   * children only. A ternary is a `JSXExpressionContainer`, so an
+   * auth-gated root — the modal shape of a commercial app, and the shape
+   * of this repo's own `apps/example-app` — contributed ZERO screens to
+   * the graph while `appilots sync` reported success (#396).
+   *
+   * Both branches of a conditional are collected on purpose. The graph is
+   * a design-time map of what routes EXIST, not a prediction of which one
+   * a given session will render; the agent needs the destination name to
+   * be there whether or not the user happens to be logged in right now.
+   */
+  collectScreenElements(children, navigatorVarName, depth = 0) {
+    if (depth > 12) return [];
+    const found = [];
+    const visit = (node) => {
+      if (!node) return;
+      if (this.isNavigatorMember(node, navigatorVarName, "Screen")) {
+        found.push(node);
+        return;
+      }
+      if (this.isNavigatorMember(node, navigatorVarName, "Group")) {
+        const group = node;
+        found.push(...this.collectScreenElements(group.children, navigatorVarName, depth + 1));
+        return;
+      }
+      if (BabelTypes__namespace.isJSXElement(node)) {
+        const name = node.openingElement.name;
+        const isForeignNavigator = BabelTypes__namespace.isJSXMemberExpression(name) && BabelTypes__namespace.isJSXIdentifier(name.property) && name.property.name === "Navigator";
+        if (isForeignNavigator) return;
+        found.push(...this.collectScreenElements(node.children, navigatorVarName, depth + 1));
+        return;
+      }
+      if (BabelTypes__namespace.isJSXFragment(node)) {
+        found.push(...this.collectScreenElements(node.children, navigatorVarName, depth + 1));
+        return;
+      }
+      if (BabelTypes__namespace.isJSXExpressionContainer(node)) {
+        visit(node.expression);
+        return;
+      }
+      if (BabelTypes__namespace.isConditionalExpression(node)) {
+        visit(node.consequent);
+        visit(node.alternate);
+        return;
+      }
+      if (BabelTypes__namespace.isLogicalExpression(node)) {
+        visit(node.left);
+        visit(node.right);
+        return;
+      }
+      if (BabelTypes__namespace.isCallExpression(node)) {
+        for (const arg of node.arguments) {
+          if (BabelTypes__namespace.isArrowFunctionExpression(arg) || BabelTypes__namespace.isFunctionExpression(arg)) {
+            if (BabelTypes__namespace.isBlockStatement(arg.body)) {
+              for (const stmt of arg.body.body) {
+                if (BabelTypes__namespace.isReturnStatement(stmt)) visit(stmt.argument);
+              }
+            } else {
+              visit(arg.body);
+            }
+          }
+        }
+        return;
+      }
+      if (BabelTypes__namespace.isArrayExpression(node)) {
+        for (const el of node.elements) visit(el);
+        return;
+      }
+      if (BabelTypes__namespace.isTSAsExpression(node) || BabelTypes__namespace.isTSNonNullExpression(node)) {
+        visit(node.expression);
+      }
+    };
+    for (const child of children) visit(child);
+    return found;
+  }
   /** Extract screens from a navigator JSX element */
   extractScreensFromNavigator(navigatorElement, navigatorVarName, navigatorType) {
     const screens = [];
     if (!navigatorElement.children) return screens;
-    for (const child of navigatorElement.children) {
-      if (BabelTypes__namespace.isJSXElement(child) && BabelTypes__namespace.isJSXMemberExpression(child.openingElement.name)) {
-        const memberExpr = child.openingElement.name;
-        if (BabelTypes__namespace.isJSXIdentifier(memberExpr.object) && memberExpr.object.name === navigatorVarName && BabelTypes__namespace.isJSXIdentifier(memberExpr.property) && memberExpr.property.name === "Screen") {
-          const screenName = this.extractAttributeValue(
-            child.openingElement.attributes,
-            "name"
-          );
-          if (screenName) {
-            screens.push({
-              name: screenName,
-              navigatorName: navigatorVarName,
-              navigatorType
-            });
-          }
-        }
-      }
+    const seen = /* @__PURE__ */ new Set();
+    for (const element of this.collectScreenElements(navigatorElement.children, navigatorVarName)) {
+      const screenName = this.extractAttributeValue(element.openingElement.attributes, "name");
+      if (!screenName || seen.has(screenName)) continue;
+      seen.add(screenName);
+      screens.push({
+        name: screenName,
+        navigatorName: navigatorVarName,
+        navigatorType
+      });
     }
     return screens;
   }
@@ -1789,9 +1953,7 @@ var NavigationAnalyzer = class {
       if (member.type === "TSPropertySignature" && member.key) {
         const keyName = member.key.type === "Identifier" ? member.key.name : null;
         if (keyName && member.typeAnnotation) {
-          const params = this.extractParamsFromType(
-            member.typeAnnotation.typeAnnotation
-          );
+          const params = this.extractParamsFromType(member.typeAnnotation.typeAnnotation);
           entries.set(keyName, params);
         }
       }
@@ -1831,7 +1993,7 @@ var NavigationAnalyzer = class {
     if (type.type === "TSUndefinedKeyword") return "undefined";
     if (type.type === "TSNullKeyword") return "null";
     if (type.type === "TSUnionType") {
-      return type.types.map((t8) => this.typeToString(t8)).join(" | ");
+      return type.types.map((t12) => this.typeToString(t12)).join(" | ");
     }
     if (type.type === "TSTypeLiteral") {
       return "object";
@@ -1852,7 +2014,7 @@ var NavigationAnalyzer = class {
   /** Attach parsed type params to navigator screens */
   attachParamsToNavigators(navigators, types) {
     for (const navigator of navigators) {
-      const matchingType = types.find((t8) => t8.type === navigator.type);
+      const matchingType = types.find((t12) => t12.type === navigator.type);
       if (matchingType) {
         for (const screen of navigator.screens) {
           const screenParams = matchingType.paramEntries.get(screen.name);
@@ -1870,6 +2032,11 @@ var NavigationAnalyzer = class {
     let initialScreen = "";
     for (const navigator of parsedNavigators) {
       const screenNames = navigator.screens.map((s) => s.name);
+      if (screenNames.length === 0) {
+        console.warn(
+          `[MCPGenerator] navigator "${navigator.name}" (${navigator.type}) declared no reachable screens. Its routes will be missing from the app map, so the agent will have no destination name for them. If the screens are there in the source, this is a parser gap \u2014 please report it with the file.`
+        );
+      }
       navigators.push({
         name: navigator.name,
         type: navigator.type,
@@ -1937,8 +2104,8 @@ var ComponentAnalyzer = class {
       });
       const components = [];
       traverse4__default.default(ast, {
-        JSXElement: (path7) => {
-          const component = this.extractComponentFromJSXElement(path7.node);
+        JSXElement: (path9) => {
+          const component = this.extractComponentFromJSXElement(path9.node);
           if (component) {
             components.push(component);
           }
@@ -2065,13 +2232,13 @@ var FormAnalyzer = class {
       this.inputElements = [];
       this.submitButtons = [];
       traverse4__default.default(ast, {
-        CallExpression: (path7) => {
-          this.extractStateVariables(path7.node);
+        CallExpression: (path9) => {
+          this.extractStateVariables(path9.node);
         }
       });
       traverse4__default.default(ast, {
-        JSXElement: (path7) => {
-          this.extractFormElements(path7.node);
+        JSXElement: (path9) => {
+          this.extractFormElements(path9.node);
         }
       });
       const validationRules = this.extractValidationRules(ast);
@@ -2171,8 +2338,8 @@ var FormAnalyzer = class {
   extractValidationRules(ast) {
     const rules = {};
     traverse4__default.default(ast, {
-      IfStatement: (path7) => {
-        const test = path7.node.test;
+      IfStatement: (path9) => {
+        const test = path9.node.test;
         const rule = this.extractRuleFromCondition(test);
         if (rule) {
           const { field, description } = rule;
@@ -2226,7 +2393,7 @@ var FormAnalyzer = class {
   }
   buildForms(filePath, validationRules) {
     if (this.inputElements.length === 0) return [];
-    const fileName = path6__namespace.basename(filePath, path6__namespace.extname(filePath));
+    const fileName = path8__namespace.basename(filePath, path8__namespace.extname(filePath));
     const formId = `${fileName}Form`.replace(/Screen$/, "").toLowerCase();
     const fields = this.inputElements.map((input) => {
       const fieldType = this.inferFieldType(input);
@@ -2304,7 +2471,7 @@ var ReactNativePlatformAnalyzer = class {
       `[ReactNativePlatformAnalyzer] Analyzing components and forms from ${screenFiles.length} files...`
     );
     const enrichmentPromises = screenFiles.map(async (file) => {
-      const filePath = path6__namespace.default.resolve(config.rootDir, file);
+      const filePath = path8__namespace.default.resolve(config.rootDir, file);
       try {
         const [components, forms] = await Promise.all([
           componentAnalyzer.analyzeFile(filePath),
@@ -2347,91 +2514,1579 @@ var ReactNativePlatformAnalyzer = class {
             });
           }
         }
-        return {
-          ...screen,
-          components: [...screen.components, ...newComponents],
-          forms: mergedForms
-        };
+        return {
+          ...screen,
+          components: [...screen.components, ...newComponents],
+          forms: mergedForms
+        };
+      }
+      return screen;
+    });
+    return {
+      screens: enrichedScreens,
+      navigation,
+      analyzedFiles: screenFiles.length,
+      ...screenAnalyzer.screensFilteredOut > 0 ? { screensFilteredOut: screenAnalyzer.screensFilteredOut } : {}
+    };
+  }
+  mergeForm(target, source) {
+    for (const field of source.fields) {
+      const existingField = this.findEquivalentField(target.fields, field);
+      if (existingField) {
+        this.mergeField(existingField, field);
+      } else {
+        target.fields.push(field);
+      }
+    }
+    target.submitAction = target.submitAction ?? this.namedSubmitAction(source.submitAction);
+    target.validationRules = source.validationRules ? { ...source.validationRules, ...target.validationRules ?? {} } : target.validationRules;
+  }
+  findEquivalentField(fields, incoming) {
+    return fields.find((field) => {
+      if (field.name && incoming.name && field.name === incoming.name) return true;
+      if (field.valueBinding && incoming.valueBinding && field.valueBinding === incoming.valueBinding) return true;
+      if (field.locator?.id && incoming.locator?.id && field.locator.id === incoming.locator.id) return true;
+      if (field.placeholder && incoming.placeholder && field.placeholder === incoming.placeholder) return true;
+      if (field.locator?.accessibilityLabel && incoming.locator?.accessibilityLabel && field.locator.accessibilityLabel === incoming.locator.accessibilityLabel) {
+        return true;
+      }
+      return false;
+    });
+  }
+  mergeField(target, source) {
+    if (this.isWeakInferredFieldName(target.name) && !this.isWeakInferredFieldName(source.name)) {
+      target.name = source.name;
+    }
+    target.label = target.label ?? source.label;
+    target.placeholder = target.placeholder ?? source.placeholder;
+    target.options = target.options ?? source.options;
+    target.locator = target.locator ?? source.locator;
+    target.sourceComponent = target.sourceComponent ?? source.sourceComponent;
+    target.valueBinding = target.valueBinding ?? source.valueBinding;
+    target.errorBinding = target.errorBinding ?? source.errorBinding;
+    target.required = target.required || source.required;
+    if (target.type === "text" && source.type !== "text") {
+      target.type = source.type;
+    }
+  }
+  namedSubmitAction(submitAction) {
+    return submitAction && submitAction !== "anonymous" ? submitAction : void 0;
+  }
+  isWeakInferredFieldName(name) {
+    return /^(text|value|input|query|search|selected|checked)$/i.test(name);
+  }
+  findFormWithSharedFields(forms, incoming) {
+    if (incoming.fields.length === 0) return void 0;
+    let best;
+    for (const form of forms) {
+      const overlap = incoming.fields.filter((field) => this.findEquivalentField(form.fields, field)).length;
+      if (overlap > 0 && (!best || overlap > best.overlap)) {
+        best = { form, overlap };
+      }
+    }
+    return best?.form;
+  }
+};
+
+// src/analyzers/GenericPlatformAnalyzer.ts
+var GenericPlatformAnalyzer = class {
+  constructor(platform) {
+    this.platform = platform;
+  }
+  platform;
+  async analyze(_config, _options) {
+    return {
+      screens: [],
+      navigation: { screens: {}, initialScreen: "", navigators: [] },
+      analyzedFiles: 0
+    };
+  }
+};
+
+// src/ast/jsx/web/classify.ts
+var VIEW_TAGS = /* @__PURE__ */ new Set([
+  "div",
+  "span",
+  "section",
+  "main",
+  "article",
+  "aside",
+  "header",
+  "footer",
+  "nav",
+  "fieldset",
+  "form",
+  "p"
+]);
+var LIST_TAGS = /* @__PURE__ */ new Set(["ul", "ol", "dl", "table", "tbody"]);
+var BUTTON_TAGS = /* @__PURE__ */ new Set(["button"]);
+var INPUT_TAGS = /* @__PURE__ */ new Set(["input", "textarea"]);
+var MODAL_TAGS = /* @__PURE__ */ new Set(["dialog"]);
+var BUTTON_COMPONENTS2 = /* @__PURE__ */ new Set(["Button", "IconButton", "Link", "NavLink"]);
+var INPUT_COMPONENTS2 = /* @__PURE__ */ new Set(["Input", "TextField", "TextArea", "Textarea"]);
+var LIST_COMPONENTS2 = /* @__PURE__ */ new Set(["List", "Table", "DataGrid", "DataTable"]);
+var MODAL_COMPONENTS2 = /* @__PURE__ */ new Set(["Modal", "Dialog", "Drawer", "Popover", "BottomSheet"]);
+var ARIA_ROLE_TO_SEMANTIC = {
+  button: "button",
+  link: "button",
+  tab: "button",
+  menuitem: "button",
+  textbox: "input",
+  searchbox: "input",
+  spinbutton: "input",
+  listbox: "select",
+  combobox: "select",
+  radiogroup: "select",
+  radio: "select",
+  option: "select",
+  checkbox: "toggle",
+  switch: "toggle",
+  dialog: "modal",
+  alertdialog: "modal",
+  list: "list",
+  table: "list",
+  grid: "list",
+  form: "view"
+};
+var INPUT_TYPE_TO_SEMANTIC = {
+  checkbox: "toggle",
+  radio: "select",
+  date: "date",
+  "datetime-local": "date",
+  month: "date",
+  week: "date",
+  time: "date",
+  submit: "button",
+  button: "button",
+  reset: "button",
+  image: "button",
+  hidden: "custom",
+  range: "input",
+  file: "input",
+  color: "input"
+};
+function classifyWebJsxComponent(name, element) {
+  if (element) {
+    const role = getStringAttr(element, "role");
+    if (role && ARIA_ROLE_TO_SEMANTIC[role]) return ARIA_ROLE_TO_SEMANTIC[role];
+  }
+  if (/^[a-z]/.test(name)) {
+    if (name === "input") {
+      const type = element ? getStringAttr(element, "type") : void 0;
+      if (type && INPUT_TYPE_TO_SEMANTIC[type]) return INPUT_TYPE_TO_SEMANTIC[type];
+      return "input";
+    }
+    if (INPUT_TAGS.has(name)) return "input";
+    if (name === "select") return "select";
+    if (BUTTON_TAGS.has(name)) return "button";
+    if (name === "a") {
+      if (element && (hasJsxAttribute(element, "href") || hasJsxAttribute(element, "onClick"))) {
+        return "button";
+      }
+      return "view";
+    }
+    if (LIST_TAGS.has(name)) return "list";
+    if (MODAL_TAGS.has(name)) return "modal";
+    if (VIEW_TAGS.has(name)) return "view";
+    return "custom";
+  }
+  if (LIST_COMPONENTS2.has(name)) return "list";
+  if (MODAL_COMPONENTS2.has(name)) return "modal";
+  if (/date/i.test(name)) return "date";
+  if (/(select|picker|dropdown|radio)/i.test(name)) return "select";
+  if (/(checkbox|switch|toggle)/i.test(name)) return "toggle";
+  if (INPUT_COMPONENTS2.has(name)) return "input";
+  if (BUTTON_COMPONENTS2.has(name)) return "button";
+  if (element) {
+    const hasOptions = hasJsxAttribute(element, "options");
+    const hasValue = hasJsxAttribute(element, "value");
+    const hasChecked = hasJsxAttribute(element, "checked") || hasJsxAttribute(element, "selected");
+    const hasOnChange = hasJsxAttribute(element, "onChange") || hasJsxAttribute(element, "onValueChange");
+    const hasOnClick = hasJsxAttribute(element, "onClick");
+    if (hasOptions && (hasValue || hasOnChange)) return "select";
+    if (hasChecked && hasOnChange) return "toggle";
+    if (hasOnChange && (hasJsxAttribute(element, "label") || hasJsxAttribute(element, "placeholder"))) {
+      return "input";
+    }
+    if (hasOnClick) return "button";
+    if (getStringAttr(element, "open") || getExpressionIdentifierAttr(element, "open") || getExpressionIdentifierAttr(element, "isOpen")) {
+      return "modal";
+    }
+  }
+  return "custom";
+}
+function getJsxElementName(openingElement) {
+  return getJsxName(openingElement.name);
+}
+function getJsxName(name) {
+  if (BabelTypes__namespace.isJSXIdentifier(name)) return name.name;
+  if (BabelTypes__namespace.isJSXNamespacedName(name)) return `${name.namespace.name}:${name.name.name}`;
+  if (BabelTypes__namespace.isJSXMemberExpression(name)) {
+    const objectName = getJsxName(name.object);
+    const propertyName = BabelTypes__namespace.isJSXIdentifier(name.property) ? name.property.name : null;
+    return objectName && propertyName ? `${objectName}.${propertyName}` : null;
+  }
+  return null;
+}
+var ROUTERISH_OBJECTS = /^(router|history|navigation)$/;
+function staticRoutePath(node) {
+  if (!node) return void 0;
+  if (BabelTypes__namespace.isStringLiteral(node)) return node.value;
+  if (BabelTypes__namespace.isTemplateLiteral(node)) {
+    let path9 = "";
+    node.quasis.forEach((quasi, index) => {
+      path9 += quasi.value.cooked ?? quasi.value.raw;
+      const expr = node.expressions[index];
+      if (expr) path9 += `:${paramNameOf(expr)}`;
+    });
+    return path9;
+  }
+  return void 0;
+}
+function paramNameOf(expr) {
+  if (BabelTypes__namespace.isIdentifier(expr)) return expr.name;
+  if (BabelTypes__namespace.isMemberExpression(expr) && BabelTypes__namespace.isIdentifier(expr.property)) return expr.property.name;
+  return "param";
+}
+function extractWebNavigationCalls(ast) {
+  const calls = [];
+  const inspect = (node) => {
+    if (BabelTypes__namespace.isCallExpression(node)) {
+      if (BabelTypes__namespace.isIdentifier(node.callee) && node.callee.name === "navigate") {
+        const first = node.arguments[0];
+        const targetPath = staticRoutePath(first);
+        if (targetPath !== void 0) {
+          calls.push({
+            method: hasReplaceOption(node.arguments[1]) ? "replace" : "navigate",
+            targetPath
+          });
+        } else if (BabelTypes__namespace.isNumericLiteral(first) || BabelTypes__namespace.isUnaryExpression(first) && first.operator === "-") {
+          calls.push({ method: "goBack" });
+        }
+        return;
+      }
+      if (BabelTypes__namespace.isMemberExpression(node.callee) && BabelTypes__namespace.isIdentifier(node.callee.object) && ROUTERISH_OBJECTS.test(node.callee.object.name) && BabelTypes__namespace.isIdentifier(node.callee.property)) {
+        const method = node.callee.property.name;
+        const targetPath = staticRoutePath(node.arguments[0]);
+        if ((method === "push" || method === "navigate") && targetPath !== void 0) {
+          calls.push({ method: "navigate", targetPath });
+        } else if (method === "replace" && targetPath !== void 0) {
+          calls.push({ method: "replace", targetPath });
+        } else if (method === "back" || method === "goBack") {
+          calls.push({ method: "goBack" });
+        }
+      }
+      return;
+    }
+    if (BabelTypes__namespace.isAssignmentExpression(node) && BabelTypes__namespace.isMemberExpression(node.left) && BabelTypes__namespace.isIdentifier(node.left.property) && node.left.property.name === "href" && isLocationExpression(node.left.object) && BabelTypes__namespace.isStringLiteral(node.right) && node.right.value.startsWith("/")) {
+      calls.push({ method: "navigate", targetPath: node.right.value });
+    }
+  };
+  traverse4__default.default(ast, {
+    noScope: !BabelTypes__namespace.isFile(ast),
+    enter: (nodePath) => inspect(nodePath.node)
+  });
+  return calls;
+}
+function hasReplaceOption(arg) {
+  if (!arg || !BabelTypes__namespace.isObjectExpression(arg)) return false;
+  return arg.properties.some(
+    (prop) => BabelTypes__namespace.isObjectProperty(prop) && BabelTypes__namespace.isIdentifier(prop.key) && prop.key.name === "replace" && BabelTypes__namespace.isBooleanLiteral(prop.value) && prop.value.value === true
+  );
+}
+function isLocationExpression(node) {
+  if (BabelTypes__namespace.isIdentifier(node)) return node.name === "location";
+  return BabelTypes__namespace.isMemberExpression(node) && BabelTypes__namespace.isIdentifier(node.object) && node.object.name === "window" && BabelTypes__namespace.isIdentifier(node.property) && node.property.name === "location";
+}
+
+// src/analyzers/web/WebScreenAnalyzer.ts
+var DEFAULT_WEB_SCREEN_PATTERNS = [
+  "**/pages/**/*.{ts,tsx,js,jsx}",
+  "**/routes/**/*.{ts,tsx,js,jsx}",
+  "**/views/**/*.{ts,tsx,js,jsx}",
+  "**/app/**/*.{ts,tsx,js,jsx}",
+  "**/*Page.{ts,tsx,js,jsx}",
+  "**/*Screen.{ts,tsx,js,jsx}",
+  "**/*View.{ts,tsx,js,jsx}"
+];
+var DESTRUCTIVE_VERB2 = /(delete|destroy|remove|discard|wipe|erase|drop|terminate|revoke|deactivate|disable)/i;
+var LISTISH_TAGS = /* @__PURE__ */ new Set(["ul", "ol", "dl", "table", "tbody"]);
+var WebScreenAnalyzer = class {
+  config;
+  verbose = process.env.VERBOSE === "true";
+  screenPatterns;
+  constructor(config, options) {
+    this.config = config;
+    this.screenPatterns = options?.screenPatterns ?? DEFAULT_WEB_SCREEN_PATTERNS;
+  }
+  async analyze() {
+    const {
+      include = ["**/*.tsx", "**/*.ts", "**/*.jsx", "**/*.js"],
+      exclude = ["**/node_modules/**", "**/dist/**", "**/build/**"]
+    } = this.config;
+    const files = (await glob__default.default(include, { cwd: this.config.rootDir, ignore: exclude })).filter(
+      (file) => !file.endsWith(".d.ts")
+    );
+    const patternMatches = await glob__default.default(this.screenPatterns, {
+      cwd: this.config.rootDir,
+      ignore: exclude
+    });
+    const patternSet = new Set(patternMatches.map((f) => path8__namespace.default.resolve(this.config.rootDir, f)));
+    const candidates = [];
+    for (const file of files) {
+      const filePath = path8__namespace.default.resolve(this.config.rootDir, file);
+      try {
+        const candidate = await this.analyzeFile(filePath);
+        if (!candidate) continue;
+        candidate.matchesScreenPattern = patternSet.has(filePath);
+        candidates.push(candidate);
+        if (this.verbose) {
+          console.log(`[WebScreenAnalyzer] \u2713 Analyzed: ${candidate.descriptor.name} (${file})`);
+        }
+      } catch (error) {
+        if (this.verbose) {
+          console.warn(
+            `[WebScreenAnalyzer] Failed to parse ${file}:`,
+            error instanceof Error ? error.message : error
+          );
+        }
+      }
+    }
+    return { candidates, analyzedFiles: files.length };
+  }
+  async analyzeFile(filePath) {
+    const source = await fs__default.default.readFile(filePath, "utf-8");
+    const ast = parseSource(source, this.config.parserPlugins);
+    const registerScreenMeta = this.extractRegisterScreenMetadata(ast);
+    const componentName = this.extractComponentName(ast);
+    const labelsByHtmlFor = this.collectHtmlForLabels(ast);
+    const handlerBehaviors = this.collectWebHandlerBehaviors(ast);
+    const forms = this.mergeForms(
+      registerScreenMeta?.forms ?? [],
+      this.extractForms(ast, labelsByHtmlFor)
+    );
+    const actions = this.extractActions(ast, registerScreenMeta, handlerBehaviors);
+    const components = this.extractComponents(ast);
+    const collections = this.extractCollections(ast);
+    const navigationTargets = this.extractNavigationTargets(ast);
+    const permissionsFromJsDoc = extractPermissionsFromJsDoc(source);
+    const destructiveTags = extractDestructiveJsDocTargets(source);
+    if (destructiveTags) {
+      for (const action of actions) {
+        if (destructiveTags === "*" || destructiveTags.has(action.id)) {
+          action.destructive = true;
+        }
+      }
+    }
+    const name = registerScreenMeta?.name || componentName || path8__namespace.default.basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
+    const descriptor = {
+      name,
+      filePath,
+      title: registerScreenMeta?.title,
+      description: registerScreenMeta?.description,
+      components,
+      forms,
+      actions,
+      navigationTargets,
+      ...collections.length > 0 ? { collections } : {},
+      ...registerScreenMeta?.suggestedPrompts && registerScreenMeta.suggestedPrompts.length > 0 ? { suggestedPrompts: registerScreenMeta.suggestedPrompts } : {},
+      ...permissionsFromJsDoc ? {
+        permissions: permissionsFromJsDoc,
+        ...permissionsFromJsDoc.isPii ? { isPii: true } : {}
+      } : {}
+    };
+    return {
+      descriptor,
+      hasRegisterScreen: registerScreenMeta !== null || this.detectRegisterScreenCall(ast),
+      matchesScreenPattern: false
+    };
+  }
+  // ── registerScreen ────────────────────────────────────────────────
+  detectRegisterScreenCall(ast) {
+    let found = false;
+    traverse4__default.default(ast, {
+      CallExpression: (nodePath) => {
+        if (found) return;
+        if (isRegisterScreenCallee(nodePath.node.callee)) {
+          found = true;
+          nodePath.stop();
+        }
+      }
+    });
+    return found;
+  }
+  extractRegisterScreenMetadata(ast) {
+    let plain = null;
+    traverse4__default.default(ast, {
+      CallExpression: (nodePath) => {
+        if (!isRegisterScreenCallee(nodePath.node.callee)) return;
+        const arg = nodePath.node.arguments[0];
+        if (BabelTypes__namespace.isObjectExpression(arg)) {
+          plain = literalToPlain(arg);
+        }
+      }
+    });
+    if (!plain) return null;
+    const meta = plain;
+    const result = {
+      name: typeof meta.name === "string" ? meta.name : "",
+      actions: [],
+      forms: [],
+      navigationTargets: [],
+      components: []
+    };
+    if (typeof meta.title === "string") result.title = meta.title;
+    if (typeof meta.description === "string") result.description = meta.description;
+    if (Array.isArray(meta.suggestedPrompts)) {
+      const prompts = meta.suggestedPrompts.filter((p) => typeof p === "string").map((p) => p.trim()).filter((p) => p.length > 0);
+      if (prompts.length > 0) result.suggestedPrompts = prompts;
+    }
+    if (Array.isArray(meta.actions)) {
+      result.actions = meta.actions.filter((a) => typeof a === "object" && a !== null).filter((a) => typeof a.id === "string" && a.id.length > 0).map((a) => ({ type: "custom", ...a }));
+    }
+    if (Array.isArray(meta.fields)) {
+      const fields = meta.fields.filter((f) => typeof f === "object" && f !== null).filter((f) => typeof f.id === "string" && f.id.length > 0).map(
+        (f) => ({
+          name: f.id,
+          type: typeof f.type === "string" ? f.type : "text",
+          required: f.required === true,
+          ...typeof f.label === "string" ? { label: f.label } : {},
+          ...typeof f.placeholder === "string" ? { placeholder: f.placeholder } : {},
+          ...f.defaultValue !== void 0 ? { defaultValue: f.defaultValue } : {},
+          ...Array.isArray(f.options) ? { options: f.options } : {}
+        })
+      );
+      if (fields.length > 0) result.forms = [{ id: "default", fields }];
+    }
+    return result;
+  }
+  // ── Component name / structure ────────────────────────────────────
+  /** Default-exported component name, else the first exported capitalized function. */
+  extractComponentName(ast) {
+    let defaultName = "";
+    let firstExported = "";
+    traverse4__default.default(ast, {
+      ExportDefaultDeclaration: (nodePath) => {
+        const declaration = nodePath.node.declaration;
+        if (BabelTypes__namespace.isFunctionDeclaration(declaration) && declaration.id?.name) {
+          defaultName = declaration.id.name;
+        } else if (BabelTypes__namespace.isIdentifier(declaration)) {
+          defaultName = declaration.name;
+        }
+      },
+      ExportNamedDeclaration: (nodePath) => {
+        if (firstExported) return;
+        const declaration = nodePath.node.declaration;
+        if (BabelTypes__namespace.isFunctionDeclaration(declaration) && declaration.id && /^[A-Z]/.test(declaration.id.name)) {
+          firstExported = declaration.id.name;
+        } else if (BabelTypes__namespace.isVariableDeclaration(declaration)) {
+          for (const declarator of declaration.declarations) {
+            if (BabelTypes__namespace.isIdentifier(declarator.id) && /^[A-Z]/.test(declarator.id.name) && (BabelTypes__namespace.isArrowFunctionExpression(declarator.init) || BabelTypes__namespace.isFunctionExpression(declarator.init))) {
+              firstExported = declarator.id.name;
+              break;
+            }
+          }
+        }
+      }
+    });
+    return defaultName || firstExported;
+  }
+  extractComponents(ast) {
+    const components = [];
+    const seen = /* @__PURE__ */ new Set();
+    traverse4__default.default(ast, {
+      JSXOpeningElement: (nodePath) => {
+        const element = nodePath.node;
+        const name = getJsxElementName(element);
+        if (!name || seen.has(name)) return;
+        seen.add(name);
+        const role = classifyWebJsxComponent(name, element);
+        const type = role === "select" || role === "toggle" || role === "date" ? "input" : role === "input" || role === "button" || role === "list" || role === "modal" || role === "view" ? role : "custom";
+        const component = { name, type };
+        const testId = getStringAttr(element, "data-testid") ?? getStringAttr(element, "testID");
+        const ariaLabel = getStringAttr(element, "aria-label");
+        if (testId) component.testID = testId;
+        if (ariaLabel) component.accessibilityLabel = ariaLabel;
+        components.push(component);
+      }
+    });
+    return components;
+  }
+  // ── <label htmlFor> association ───────────────────────────────────
+  collectHtmlForLabels(ast) {
+    const labels = /* @__PURE__ */ new Map();
+    traverse4__default.default(ast, {
+      JSXElement: (nodePath) => {
+        const element = nodePath.node;
+        if (getJsxElementName(element.openingElement) !== "label") return;
+        const htmlFor = getStringAttr(element.openingElement, "htmlFor");
+        if (!htmlFor) return;
+        const text = jsxTextContent(element);
+        if (text) labels.set(htmlFor, text);
+      }
+    });
+    return labels;
+  }
+  // ── Forms ─────────────────────────────────────────────────────────
+  extractForms(ast, labelsByHtmlFor) {
+    const formBuckets = /* @__PURE__ */ new Map();
+    const usedIds = /* @__PURE__ */ new Set();
+    let formCount = 0;
+    const uniqueId = (preferred) => {
+      if (!usedIds.has(preferred)) {
+        usedIds.add(preferred);
+        return preferred;
+      }
+      let suffix = 2;
+      while (usedIds.has(`${preferred}-${suffix}`)) suffix += 1;
+      const id = `${preferred}-${suffix}`;
+      usedIds.add(id);
+      return id;
+    };
+    const bucketFor = (formElement) => {
+      let bucket = formBuckets.get(formElement);
+      if (bucket) return bucket;
+      formCount += 1;
+      let preferred = "default";
+      let submitAction;
+      if (formElement) {
+        const opening = formElement.openingElement;
+        preferred = getStringAttr(opening, "id") ?? getStringAttr(opening, "name") ?? getStringAttr(opening, "data-testid") ?? (formCount === 1 ? "default" : `form-${formCount}`);
+        submitAction = this.handlerNameFromAttr(opening, "onSubmit");
+      }
+      bucket = { id: uniqueId(preferred), fields: /* @__PURE__ */ new Map(), submitAction };
+      formBuckets.set(formElement, bucket);
+      return bucket;
+    };
+    traverse4__default.default(ast, {
+      JSXElement: (nodePath) => {
+        const element = nodePath.node;
+        const name = getJsxElementName(element.openingElement);
+        if (!name) return;
+        const role = classifyWebJsxComponent(name, element.openingElement);
+        if (!["input", "select", "toggle", "date"].includes(role)) return;
+        if (name === "option") return;
+        const field = this.extractField(element, role, labelsByHtmlFor);
+        if (!field.name) return;
+        const formParent = nodePath.findParent(
+          (p) => p.isJSXElement() && (getJsxElementName(p.node.openingElement) === "form" || getStringAttr(p.node.openingElement, "role") === "form")
+        );
+        const bucket = bucketFor(formParent ? formParent.node : null);
+        if (!bucket.fields.has(field.name)) bucket.fields.set(field.name, field);
+      }
+    });
+    traverse4__default.default(ast, {
+      JSXElement: (nodePath) => {
+        const element = nodePath.node;
+        const name = getJsxElementName(element.openingElement);
+        if (!name) return;
+        if (!this.isSubmitElement(name, element.openingElement)) return;
+        const formParent = nodePath.findParent(
+          (p) => p.isJSXElement() && getJsxElementName(p.node.openingElement) === "form"
+        );
+        if (!formParent) return;
+        const bucket = formBuckets.get(formParent.node);
+        if (!bucket) return;
+        const handler = this.handlerNameFromAttr(element.openingElement, "onClick");
+        if (!bucket.submitAction && handler) bucket.submitAction = handler;
+      }
+    });
+    return Array.from(formBuckets.values()).filter((bucket) => bucket.fields.size > 0).map((bucket) => ({
+      id: bucket.id,
+      fields: Array.from(bucket.fields.values()),
+      ...bucket.submitAction && bucket.submitAction !== "anonymous" ? { submitAction: bucket.submitAction } : {}
+    }));
+  }
+  isSubmitElement(name, opening) {
+    const type = getStringAttr(opening, "type");
+    if (name === "button") return type === "submit" || type === void 0;
+    if (name === "input") return type === "submit";
+    return false;
+  }
+  extractField(element, role, labelsByHtmlFor) {
+    const opening = element.openingElement;
+    const componentName = getJsxElementName(opening) ?? void 0;
+    const field = {
+      name: "",
+      type: "text",
+      required: false,
+      sourceComponent: componentName
+    };
+    const appilotsId = getStringAttr(opening, "appilotsId");
+    const dataTestId = getStringAttr(opening, "data-testid");
+    const domId = getStringAttr(opening, "id");
+    const nameAttr = getStringAttr(opening, "name");
+    const ariaLabel = getStringAttr(opening, "aria-label");
+    const placeholder = getStringAttr(opening, "placeholder");
+    if (placeholder) field.placeholder = placeholder;
+    if (ariaLabel) field.label = ariaLabel;
+    if (domId && labelsByHtmlFor.has(domId)) field.label = labelsByHtmlFor.get(domId);
+    if (appilotsId) {
+      field.name = appilotsId;
+      field.locator = mergeLocator(field.locator, {
+        id: appilotsId,
+        appilotsId,
+        source: "appilotsId"
+      });
+    }
+    if (dataTestId) {
+      if (!field.name) field.name = dataTestId.replace(/^(input-|field-|txt-)/, "");
+      field.locator = mergeLocator(field.locator, {
+        ...field.locator?.id ? {} : { id: dataTestId },
+        testID: dataTestId,
+        source: field.locator?.source ?? "data-testid"
+      });
+    }
+    if (nameAttr && !field.name) field.name = nameAttr;
+    if (domId) {
+      if (!field.name) field.name = domId;
+      field.locator = mergeLocator(field.locator, {
+        ...field.locator?.id ? {} : { id: domId },
+        source: field.locator?.source ?? "id"
+      });
+    }
+    if (ariaLabel) {
+      field.locator = mergeLocator(field.locator, {
+        ...field.locator?.id ? {} : { id: slugify(ariaLabel) },
+        accessibilityLabel: ariaLabel,
+        source: field.locator?.source ?? "aria-label"
+      });
+    }
+    for (const attr of opening.attributes) {
+      if (!BabelTypes__namespace.isJSXAttribute(attr) || !BabelTypes__namespace.isJSXIdentifier(attr.name)) continue;
+      const attrName = attr.name.name;
+      if (attrName === "required") {
+        if (attr.value === null) field.required = true;
+        else if (BabelTypes__namespace.isJSXExpressionContainer(attr.value) && BabelTypes__namespace.isBooleanLiteral(attr.value.expression)) {
+          field.required = attr.value.expression.value;
+        }
+      }
+      if ((attrName === "value" || attrName === "checked") && attr.value && BabelTypes__namespace.isJSXExpressionContainer(attr.value) && BabelTypes__namespace.isIdentifier(attr.value.expression)) {
+        field.valueBinding = attr.value.expression.name;
+        if (!field.name) field.name = attr.value.expression.name;
+      }
+    }
+    if (getStringAttr(opening, "aria-required") === "true") field.required = true;
+    if (role === "select") field.type = "select";
+    else if (role === "toggle") field.type = "toggle";
+    else if (role === "date") field.type = "date";
+    else {
+      field.type = this.inferInputType(opening, field);
+    }
+    if (componentName === "select") {
+      const options = this.extractSelectOptions(element);
+      if (options.length > 0) field.options = options;
+    }
+    if (!field.name || isWeakInferredFieldName(field.name)) {
+      const labelish = field.label ?? field.placeholder;
+      if (labelish) field.name = slugify(labelish);
+    }
+    if (!field.locator && field.name) {
+      field.locator = { id: field.name, label: field.label, source: "inferred" };
+    } else if (field.locator && !field.locator.id && field.name) {
+      field.locator = mergeLocator(field.locator, {
+        id: field.name,
+        label: field.label,
+        source: field.locator.source ?? "inferred"
+      });
+    }
+    return field;
+  }
+  inferInputType(opening, field) {
+    const type = getStringAttr(opening, "type");
+    if (type === "email") return "email";
+    if (type === "tel") return "phone";
+    if (type === "number") return "number";
+    if (type === "date" || type === "datetime-local" || type === "month" || type === "week")
+      return "date";
+    const inputMode = getStringAttr(opening, "inputMode") ?? getStringAttr(opening, "inputmode");
+    if (inputMode === "email") return "email";
+    if (inputMode === "tel") return "phone";
+    if (inputMode === "numeric" || inputMode === "decimal") return "number";
+    const combined = `${field.name} ${field.label ?? ""} ${field.placeholder ?? ""}`.toLowerCase();
+    if (combined.includes("email")) return "email";
+    if (combined.includes("phone") || combined.includes("tel")) return "phone";
+    return "text";
+  }
+  extractSelectOptions(selectElement) {
+    const options = [];
+    for (const child of selectElement.children) {
+      if (!BabelTypes__namespace.isJSXElement(child)) continue;
+      if (getJsxElementName(child.openingElement) !== "option") continue;
+      const value = getStringAttr(child.openingElement, "value");
+      const label = jsxTextContent(child) || value || "";
+      if (label && value) options.push({ label, value });
+    }
+    return options;
+  }
+  mergeForms(primary, secondary) {
+    const out = primary.map((form) => ({ ...form, fields: [...form.fields] }));
+    for (const form of secondary) {
+      const existing = out.find((candidate) => candidate.id === form.id);
+      if (!existing) {
+        out.push({ ...form, fields: [...form.fields] });
+        continue;
+      }
+      for (const field of form.fields) {
+        const existingField = existing.fields.find((candidate) => candidate.name === field.name);
+        if (!existingField) {
+          existing.fields.push(field);
+          continue;
+        }
+        existingField.label = existingField.label ?? field.label;
+        existingField.placeholder = existingField.placeholder ?? field.placeholder;
+        existingField.options = existingField.options ?? field.options;
+        existingField.locator = existingField.locator ?? field.locator;
+        existingField.sourceComponent = existingField.sourceComponent ?? field.sourceComponent;
+        existingField.valueBinding = existingField.valueBinding ?? field.valueBinding;
+        existingField.required = existingField.required || field.required;
+        if (existingField.type === "text" && field.type !== "text") existingField.type = field.type;
+      }
+      existing.submitAction = existing.submitAction ?? form.submitAction;
+    }
+    return out;
+  }
+  // ── Actions ───────────────────────────────────────────────────────
+  extractActions(ast, registerScreenMeta, handlerBehaviors) {
+    const actions = [...registerScreenMeta?.actions ?? []];
+    const actionIds = new Set(actions.map((a) => a.id));
+    const actionLabels = new Map(
+      actions.filter((a) => a.label).map((a) => [normalizeLabel(a.label), a])
+    );
+    traverse4__default.default(ast, {
+      JSXElement: (nodePath) => {
+        const element = nodePath.node;
+        const name = getJsxElementName(element.openingElement);
+        if (!name) return;
+        if (classifyWebJsxComponent(name, element.openingElement) !== "button") return;
+        const action = this.extractActionFromElement(element, nodePath);
+        if (!action) return;
+        const existingByLabel = action.label ? actionLabels.get(normalizeLabel(action.label)) : void 0;
+        if (existingByLabel) {
+          this.mergeActionMetadata(existingByLabel, action);
+          return;
+        }
+        if (action.id && !actionIds.has(action.id)) {
+          actions.push(action);
+          actionIds.add(action.id);
+          if (action.label) actionLabels.set(normalizeLabel(action.label), action);
+        }
+      }
+    });
+    this.enrichActionsFromHandlers(actions, handlerBehaviors);
+    return actions;
+  }
+  extractActionFromElement(element, nodePath) {
+    const opening = element.openingElement;
+    const componentName = getJsxElementName(opening) ?? void 0;
+    const action = { id: "", type: "custom", sourceComponent: componentName };
+    const ariaLabel = getStringAttr(opening, "aria-label");
+    const label = ariaLabel ?? jsxTextContent(element) ?? getStringAttr(opening, "value") ?? getStringAttr(opening, "title");
+    if (label) action.label = label;
+    if (ariaLabel) {
+      action.locator = mergeLocator(action.locator, {
+        accessibilityLabel: ariaLabel,
+        source: "aria-label"
+      });
+    }
+    const appilotsId = getStringAttr(opening, "appilotsId");
+    const dataTestId = getStringAttr(opening, "data-testid");
+    const domId = getStringAttr(opening, "id");
+    if (appilotsId) {
+      action.id = appilotsId;
+      action.locator = mergeLocator(action.locator, {
+        id: appilotsId,
+        appilotsId,
+        source: "appilotsId"
+      });
+    } else if (dataTestId) {
+      action.id = dataTestId;
+      action.locator = mergeLocator(action.locator, {
+        id: dataTestId,
+        testID: dataTestId,
+        source: "data-testid"
+      });
+    } else if (domId) {
+      action.id = domId;
+      action.locator = mergeLocator(action.locator, { id: domId, source: "id" });
+    } else if (action.label) {
+      action.id = slugify(action.label);
+    }
+    if (!action.id) return null;
+    const to = routePathAttr(opening, "to") ?? routePathAttr(opening, "href");
+    if (to && to.startsWith("/")) {
+      action.type = "navigation";
+      action.targetScreen = to;
+    } else if (to && !to.startsWith("/") && !hasJsxAttribute(opening, "onClick")) {
+      return null;
+    }
+    let handlerName;
+    const onClickAttr = opening.attributes.find(
+      (attr) => BabelTypes__namespace.isJSXAttribute(attr) && BabelTypes__namespace.isJSXIdentifier(attr.name) && attr.name.name === "onClick"
+    );
+    if (onClickAttr?.value && BabelTypes__namespace.isJSXExpressionContainer(onClickAttr.value)) {
+      const expr = onClickAttr.value.expression;
+      if (BabelTypes__namespace.isIdentifier(expr)) {
+        handlerName = expr.name;
+        action.handler = expr.name;
+      } else if (!BabelTypes__namespace.isJSXEmptyExpression(expr)) {
+        const inlineNavCalls = extractWebNavigationCalls(expr);
+        const inlineNav = inlineNavCalls.find((call) => call.targetPath);
+        if (inlineNav?.targetPath) {
+          action.type = "navigation";
+          action.targetScreen = inlineNav.targetPath;
+        } else if (inlineNavCalls.some((call) => call.method === "goBack")) {
+          action.type = "navigation";
+          action.successSignal = {
+            type: "goBack",
+            description: "Action returns to the previous page"
+          };
+          action.appilotsInferred = {
+            ...action.appilotsInferred ?? {},
+            expectedOutcome: "navigation"
+          };
+        }
+        const inlineHandler = firstCalledFunctionName(expr);
+        if (inlineHandler) {
+          handlerName = inlineHandler;
+          action.handler = inlineHandler;
+        }
+      }
+    }
+    if (handlerName) {
+      const lower = handlerName.toLowerCase();
+      if (lower.includes("submit")) action.type = "submit";
+      else if (lower.includes("navigate") && action.type === "custom") action.type = "navigation";
+    }
+    if (componentName && this.isSubmitElement(componentName, opening)) {
+      const formParent = nodePath.findParent(
+        (p) => p.isJSXElement() && getJsxElementName(p.node.openingElement) === "form"
+      );
+      if (formParent) {
+        action.type = "submit";
+        if (!action.handler) {
+          const formHandler = this.handlerNameFromAttr(formParent.node.openingElement, "onSubmit");
+          if (formHandler && formHandler !== "anonymous") {
+            action.handler = formHandler;
+            handlerName = formHandler;
+          }
+        }
+      }
+    }
+    if (hasJsxAttribute(opening, "destructive") || hasJsxAttribute(opening, "aria-destructive")) {
+      const value = getStringAttr(opening, "destructive") ?? getStringAttr(opening, "aria-destructive");
+      action.destructive = value !== "false";
+    } else if (handlerName && DESTRUCTIVE_VERB2.test(handlerName) || DESTRUCTIVE_VERB2.test(action.id)) {
+      action.destructive = true;
+    }
+    if (!action.locator && action.id) {
+      action.locator = {
+        id: action.id,
+        label: action.label,
+        source: action.label ? "label" : "inferred"
+      };
+    }
+    return action;
+  }
+  mergeActionMetadata(target, source) {
+    target.handler = target.handler ?? source.handler;
+    target.targetScreen = target.targetScreen ?? source.targetScreen;
+    target.description = target.description ?? source.description;
+    target.locator = target.locator ?? source.locator;
+    target.nativeConfirmationExpected = target.nativeConfirmationExpected || source.nativeConfirmationExpected || void 0;
+    target.requiresConfirmation = target.requiresConfirmation || source.requiresConfirmation || void 0;
+    target.destructive = target.destructive || source.destructive || void 0;
+    target.effect = target.effect ?? source.effect;
+    target.riskLevel = target.riskLevel ?? source.riskLevel;
+    target.appilotsInferred = target.appilotsInferred ?? source.appilotsInferred;
+  }
+  enrichActionsFromHandlers(actions, behaviors) {
+    for (const action of actions) {
+      const behavior = action.handler ? behaviors.get(action.handler) : void 0;
+      if (!behavior) continue;
+      action.appilotsInferred = {
+        ...action.appilotsInferred ?? {},
+        ...behavior.base.appilotsInferred
+      };
+      if (behavior.nativeConfirmationExpected || behavior.base.nativeConfirmationExpected) {
+        action.nativeConfirmationExpected = true;
+      }
+      if (behavior.targetPath && !action.targetScreen) {
+        action.targetScreen = behavior.targetPath;
+        if (action.type === "custom") action.type = "navigation";
+        action.appilotsInferred = {
+          ...action.appilotsInferred ?? {},
+          expectedOutcome: "navigation"
+        };
+      }
+      if (behavior.base.successSignal && !action.successSignal) {
+        action.successSignal = behavior.base.successSignal;
+      }
+      if (behavior.base.failureSignal && !action.failureSignal) {
+        action.failureSignal = behavior.base.failureSignal;
+      }
+      if (behavior.base.opensModal && !action.opensModal) {
+        action.opensModal = behavior.base.opensModal;
+      }
+      if (behavior.base.destructive || action.destructive === true || action.requiresConfirmation === true || action.effect === "destructive" || action.riskLevel === "high") {
+        action.destructive = true;
+        action.effect = action.effect ?? "destructive";
+        action.riskLevel = action.riskLevel ?? "high";
+        action.requiresConfirmation = action.requiresConfirmation ?? true;
+      }
+    }
+  }
+  /**
+   * Handler behavior via the shared, platform-neutral analyzer
+   * (async/await, `.then`, state setters, toasts, destructive verbs)
+   * plus the web-only signals: React Router navigation targets and
+   * `window.confirm(...)` as the native confirmation dialog.
+   */
+  collectWebHandlerBehaviors(ast) {
+    const handlers = collectFunctions(ast);
+    const out = /* @__PURE__ */ new Map();
+    for (const [name, fn] of handlers) {
+      const base = analyzeFunctionBehavior(name, fn, handlers);
+      const navCalls = fn.body ? extractWebNavigationCalls(fn.body) : [];
+      const firstNav = navCalls.find((call) => call.targetPath);
+      const goesBack = navCalls.some((call) => call.method === "goBack");
+      out.set(name, {
+        base: {
+          ...base,
+          ...goesBack && !base.successSignal ? {
+            successSignal: {
+              type: "goBack",
+              description: "Action returns to the previous page"
+            }
+          } : {}
+        },
+        targetPath: firstNav?.targetPath,
+        nativeConfirmationExpected: fn.body ? containsWindowConfirm(fn.body) : false
+      });
+    }
+    return out;
+  }
+  handlerNameFromAttr(opening, attrName) {
+    const attr = opening.attributes.find(
+      (candidate) => BabelTypes__namespace.isJSXAttribute(candidate) && BabelTypes__namespace.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
+    );
+    if (!attr?.value || !BabelTypes__namespace.isJSXExpressionContainer(attr.value)) return void 0;
+    const expr = attr.value.expression;
+    if (BabelTypes__namespace.isIdentifier(expr)) return expr.name;
+    if (BabelTypes__namespace.isArrowFunctionExpression(expr) || BabelTypes__namespace.isFunctionExpression(expr)) {
+      return firstCalledFunctionName(expr) ?? "anonymous";
+    }
+    return void 0;
+  }
+  // ── Navigation targets (route paths — resolved by the orchestrator) ─
+  extractNavigationTargets(ast) {
+    const targets = /* @__PURE__ */ new Set();
+    for (const call of extractWebNavigationCalls(ast)) {
+      if (call.targetPath && call.targetPath.startsWith("/")) targets.add(call.targetPath);
+    }
+    traverse4__default.default(ast, {
+      JSXOpeningElement: (nodePath) => {
+        const element = nodePath.node;
+        const name = getJsxElementName(element);
+        if (name === "Link" || name === "NavLink" || name === "Navigate") {
+          const to = routePathAttr(element, "to");
+          if (to && to.startsWith("/")) targets.add(to);
+        }
+        if (name === "a") {
+          const href = routePathAttr(element, "href");
+          if (href && href.startsWith("/")) targets.add(href);
+        }
+      }
+    });
+    return Array.from(targets).sort();
+  }
+  // ── Collections ───────────────────────────────────────────────────
+  extractCollections(ast) {
+    const collections = [];
+    const seen = /* @__PURE__ */ new Set();
+    traverse4__default.default(ast, {
+      JSXExpressionContainer: (nodePath) => {
+        const expr = nodePath.node.expression;
+        if (!BabelTypes__namespace.isCallExpression(expr) || !BabelTypes__namespace.isMemberExpression(expr.callee) || !BabelTypes__namespace.isIdentifier(expr.callee.object) || !BabelTypes__namespace.isIdentifier(expr.callee.property) || expr.callee.property.name !== "map") {
+          return;
+        }
+        const callback = expr.arguments[0];
+        if (!BabelTypes__namespace.isArrowFunctionExpression(callback) && !BabelTypes__namespace.isFunctionExpression(callback)) return;
+        const enclosing = nodePath.findParent(
+          (p) => p.isJSXElement()
+        );
+        const enclosingName = enclosing ? getJsxElementName(enclosing.node.openingElement) : null;
+        const enclosingRole = enclosing && enclosingName ? classifyWebJsxComponent(enclosingName, enclosing.node.openingElement) : null;
+        const returnsListItem = callbackReturnsTag(callback, /* @__PURE__ */ new Set(["li", "tr"]));
+        if (enclosingName === "select") return;
+        const isListContext = enclosingName !== null && LISTISH_TAGS.has(enclosingName) || enclosingRole === "list" || returnsListItem;
+        if (!isListContext) return;
+        const dataSource = expr.callee.object.name;
+        if (seen.has(dataSource)) return;
+        seen.add(dataSource);
+        const itemNames = collectionItemNames(callback);
+        const displayFields = collectionDisplayFields(callback, itemNames);
+        const keyField = collectionKeyField(callback, itemNames);
+        const rowAction = collectionRowAction(callback);
+        const itemType = inferItemType(dataSource, displayFields);
+        const identityFields = inferIdentityFields(keyField, displayFields);
+        collections.push({
+          id: dataSource,
+          component: enclosingName ?? "list",
+          ...itemType ? { itemType } : {},
+          dataSource,
+          ...keyField ? { keyField } : {},
+          ...displayFields.length > 0 ? { displayFields } : {},
+          ...rowAction ? { rowAction, rowActions: [rowAction] } : {},
+          ...identityFields.length > 0 ? { identityFields } : {}
+        });
+      }
+    });
+    return collections;
+  }
+};
+function isRegisterScreenCallee(callee) {
+  return BabelTypes__namespace.isIdentifier(callee) && callee.name === "registerScreen" || BabelTypes__namespace.isMemberExpression(callee) && BabelTypes__namespace.isIdentifier(callee.property) && callee.property.name === "registerScreen";
+}
+function literalToPlain(node) {
+  if (BabelTypes__namespace.isStringLiteral(node) || BabelTypes__namespace.isNumericLiteral(node) || BabelTypes__namespace.isBooleanLiteral(node)) {
+    return node.value;
+  }
+  if (BabelTypes__namespace.isNullLiteral(node)) return null;
+  if (BabelTypes__namespace.isArrayExpression(node)) {
+    return node.elements.filter((el) => el !== null && BabelTypes__namespace.isExpression(el)).map((el) => literalToPlain(el)).filter((value) => value !== void 0);
+  }
+  if (BabelTypes__namespace.isObjectExpression(node)) {
+    const out = {};
+    for (const prop of node.properties) {
+      if (!BabelTypes__namespace.isObjectProperty(prop)) continue;
+      const key = BabelTypes__namespace.isIdentifier(prop.key) ? prop.key.name : BabelTypes__namespace.isStringLiteral(prop.key) ? prop.key.value : void 0;
+      if (!key || !BabelTypes__namespace.isExpression(prop.value)) continue;
+      const value = literalToPlain(prop.value);
+      if (value !== void 0) out[key] = value;
+    }
+    return out;
+  }
+  return void 0;
+}
+function jsxTextContent(element) {
+  const parts = [];
+  const walk = (children) => {
+    for (const child of children) {
+      if (BabelTypes__namespace.isJSXText(child)) {
+        const trimmed = child.value.replace(/\s+/g, " ").trim();
+        if (trimmed) parts.push(trimmed);
+      } else if (BabelTypes__namespace.isJSXExpressionContainer(child) && BabelTypes__namespace.isStringLiteral(child.expression)) {
+        parts.push(child.expression.value);
+      } else if (BabelTypes__namespace.isJSXElement(child)) {
+        walk(child.children);
+      }
+    }
+  };
+  walk(element.children);
+  const text = parts.join(" ").trim();
+  return text.length > 0 ? text : void 0;
+}
+function firstCalledFunctionName(node) {
+  if (BabelTypes__namespace.isIdentifier(node)) return node.name;
+  if (BabelTypes__namespace.isArrowFunctionExpression(node) || BabelTypes__namespace.isFunctionExpression(node)) {
+    return firstCalledFunctionName(node.body);
+  }
+  if (BabelTypes__namespace.isBlockStatement(node)) {
+    for (const statement of node.body) {
+      const handler = firstCalledFunctionName(statement);
+      if (handler) return handler;
+    }
+    return void 0;
+  }
+  if (BabelTypes__namespace.isExpressionStatement(node)) return firstCalledFunctionName(node.expression);
+  if (BabelTypes__namespace.isReturnStatement(node)) {
+    return node.argument ? firstCalledFunctionName(node.argument) : void 0;
+  }
+  if (BabelTypes__namespace.isAwaitExpression(node) || BabelTypes__namespace.isUnaryExpression(node)) {
+    return firstCalledFunctionName(node.argument);
+  }
+  if (BabelTypes__namespace.isCallExpression(node)) {
+    if (BabelTypes__namespace.isIdentifier(node.callee) && !/^(navigate|confirm|alert)$/.test(node.callee.name)) {
+      return node.callee.name;
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function containsWindowConfirm(body) {
+  let found = false;
+  traverse4__default.default(
+    body,
+    {
+      noScope: true,
+      CallExpression: (nodePath) => {
+        const callee = nodePath.node.callee;
+        if (BabelTypes__namespace.isIdentifier(callee) && callee.name === "confirm") found = true;
+        if (BabelTypes__namespace.isMemberExpression(callee) && BabelTypes__namespace.isIdentifier(callee.object) && callee.object.name === "window" && BabelTypes__namespace.isIdentifier(callee.property) && callee.property.name === "confirm") {
+          found = true;
+        }
+      }
+    }
+  );
+  return found;
+}
+function mergeLocator(current, next) {
+  return { ...current ?? {}, ...next };
+}
+function routePathAttr(opening, attrName) {
+  const literal = getStringAttr(opening, attrName);
+  if (literal) return literal;
+  const attr = opening.attributes.find(
+    (candidate) => BabelTypes__namespace.isJSXAttribute(candidate) && BabelTypes__namespace.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
+  );
+  if (!attr?.value || !BabelTypes__namespace.isJSXExpressionContainer(attr.value)) return void 0;
+  return staticRoutePath(attr.value.expression);
+}
+function slugify(label) {
+  return label.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeLabel(label) {
+  return label.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function isWeakInferredFieldName(name) {
+  return /^(text|value|input|query|search|selected|checked)$/i.test(name);
+}
+function collectionItemNames(callback) {
+  const names = /* @__PURE__ */ new Set(["item"]);
+  const firstParam = callback.params[0];
+  if (BabelTypes__namespace.isIdentifier(firstParam)) names.add(firstParam.name);
+  if (BabelTypes__namespace.isObjectPattern(firstParam)) {
+    for (const prop of firstParam.properties) {
+      if (BabelTypes__namespace.isObjectProperty(prop) && BabelTypes__namespace.isIdentifier(prop.key) && BabelTypes__namespace.isIdentifier(prop.value)) {
+        names.add(prop.value.name);
+      }
+    }
+  }
+  return names;
+}
+function collectionDisplayFields(callback, itemNames) {
+  const fields = /* @__PURE__ */ new Set();
+  if (!callback.body) return [];
+  traverse4__default.default(
+    callback.body,
+    {
+      noScope: true,
+      MemberExpression: (nodePath) => {
+        const node = nodePath.node;
+        if (BabelTypes__namespace.isIdentifier(node.object) && itemNames.has(node.object.name) && BabelTypes__namespace.isIdentifier(node.property)) {
+          fields.add(node.property.name);
+        }
+      }
+    }
+  );
+  return Array.from(fields).sort();
+}
+function collectionKeyField(callback, itemNames) {
+  let keyField;
+  if (!callback.body) return void 0;
+  traverse4__default.default(
+    callback.body,
+    {
+      noScope: true,
+      JSXAttribute: (nodePath) => {
+        const attr = nodePath.node;
+        if (!BabelTypes__namespace.isJSXIdentifier(attr.name) || attr.name.name !== "key") return;
+        if (!attr.value || !BabelTypes__namespace.isJSXExpressionContainer(attr.value)) return;
+        const expr = attr.value.expression;
+        if (BabelTypes__namespace.isMemberExpression(expr) && BabelTypes__namespace.isIdentifier(expr.object) && itemNames.has(expr.object.name) && BabelTypes__namespace.isIdentifier(expr.property)) {
+          keyField = keyField ?? expr.property.name;
+        }
+      }
+    }
+  );
+  return keyField;
+}
+function collectionRowAction(callback) {
+  if (!callback.body) return void 0;
+  const navCall = extractWebNavigationCalls(callback.body).find((call) => call.targetPath);
+  if (!navCall?.targetPath) return void 0;
+  return {
+    type: "navigation",
+    // Route path — the orchestrator resolves it to a screen name.
+    targetScreen: navCall.targetPath,
+    description: `Clicking a row opens ${navCall.targetPath}`
+  };
+}
+function callbackReturnsTag(callback, tags) {
+  let found = false;
+  const inspect = (node) => {
+    if (!node || found) return;
+    if (BabelTypes__namespace.isJSXElement(node)) {
+      const name = getJsxElementName(node.openingElement);
+      if (name && tags.has(name)) found = true;
+      return;
+    }
+    if (BabelTypes__namespace.isBlockStatement(node)) {
+      for (const statement of node.body) {
+        if (BabelTypes__namespace.isReturnStatement(statement)) inspect(statement.argument);
+      }
+    }
+    if (BabelTypes__namespace.isParenthesizedExpression(node)) inspect(node.expression);
+    if (BabelTypes__namespace.isConditionalExpression(node)) {
+      inspect(node.consequent);
+      inspect(node.alternate);
+    }
+  };
+  inspect(callback.body);
+  return found;
+}
+function inferItemType(dataSource, displayFields) {
+  const singular = dataSource.replace(/^render/i, "").replace(/(List|Items|Data|Rows|Sections)$/i, "").replace(/s$/i, "");
+  const candidate = singular.charAt(0).toUpperCase() + singular.slice(1);
+  if (candidate.length > 1) return candidate;
+  if (displayFields.length > 0) return "Item";
+  return void 0;
+}
+function inferIdentityFields(keyField, displayFields) {
+  const out = /* @__PURE__ */ new Set();
+  if (keyField) out.add(keyField);
+  for (const field of displayFields) {
+    if (/^(id|uuid|key|name|title|email|slug)$/i.test(field)) out.add(field);
+  }
+  return Array.from(out);
+}
+var WEB_NAVIGATOR_TYPE = "route";
+var WebNavigationAnalyzer = class {
+  config;
+  navigationInclude;
+  navigationExclude;
+  constructor(config, options) {
+    this.config = config;
+    this.navigationInclude = options?.navigationInclude ?? [];
+    this.navigationExclude = options?.navigationExclude ?? [];
+  }
+  async analyze() {
+    const files = await this.findRouteFiles();
+    const routes = [];
+    for (const filePath of files) {
+      try {
+        const content = await fs$1.promises.readFile(filePath, "utf-8");
+        if (!/createBrowserRouter|createHashRouter|createMemoryRouter|useRoutes|<Route[\s>]/.test(content)) {
+          continue;
+        }
+        const ast = parseSource(content, this.config.parserPlugins);
+        routes.push(...this.extractJsxRoutes(ast));
+        routes.push(...this.extractObjectRoutes(ast));
+      } catch (error) {
+        console.warn(`[WebNavigationAnalyzer] Failed to parse ${filePath}:`, error);
+      }
+    }
+    const deduped = this.dedupeRoutes(routes);
+    return { graph: this.buildGraph(deduped), routes: deduped };
+  }
+  /** Files likely to contain route configuration. */
+  async findRouteFiles() {
+    const patterns = [
+      "**/*{router,routes,Router,Routes}*.{ts,tsx,js,jsx}",
+      "**/App.{ts,tsx,js,jsx}",
+      "**/app.{ts,tsx,js,jsx}",
+      "**/main.{ts,tsx,js,jsx}",
+      "**/index.{ts,tsx,js,jsx}",
+      ...this.navigationInclude
+    ];
+    const ignore = [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      ...this.config.exclude || [],
+      ...this.navigationExclude
+    ];
+    const files = await glob__default.default(patterns, { cwd: this.config.rootDir, ignore });
+    return files.map((file) => path8__namespace.default.join(this.config.rootDir, file));
+  }
+  // ── JSX <Route> style ────────────────────────────────────────────
+  extractJsxRoutes(ast) {
+    const routes = [];
+    const visitRoute = (element, parentPath) => {
+      const opening = element.openingElement;
+      const name = getJsxElementName(opening);
+      if (name !== "Route") {
+        for (const child of element.children) {
+          if (BabelTypes__namespace.isJSXElement(child)) visitRoute(child, parentPath);
+        }
+        return;
+      }
+      const segment = getStringAttr(opening, "path");
+      const isIndex = hasJsxAttribute(opening, "index") && !segment;
+      const fullPath = this.joinPaths(parentPath, segment, isIndex);
+      const componentName = this.componentNameFromElementAttr(opening) ?? void 0;
+      const isLeaf = !element.children.some(
+        (child) => BabelTypes__namespace.isJSXElement(child) && getJsxElementName(child.openingElement) === "Route"
+      );
+      if ((segment || isIndex) && (componentName || isLeaf)) {
+        routes.push(this.buildRoute(fullPath, componentName, isIndex, !isLeaf));
+      }
+      for (const child of element.children) {
+        if (BabelTypes__namespace.isJSXElement(child)) visitRoute(child, fullPath);
+      }
+    };
+    traverse4__default.default(ast, {
+      JSXElement: (nodePath) => {
+        const name = getJsxElementName(nodePath.node.openingElement);
+        if (name !== "Routes" && name !== "Route") return;
+        if (nodePath.findParent((p) => {
+          if (!p.isJSXElement()) return false;
+          const parentName = getJsxElementName(p.node.openingElement);
+          return parentName === "Routes" || parentName === "Route";
+        })) {
+          return;
+        }
+        visitRoute(nodePath.node, "");
       }
-      return screen;
     });
-    return {
-      screens: enrichedScreens,
-      navigation,
-      analyzedFiles: screenFiles.length,
-      ...screenAnalyzer.screensFilteredOut > 0 ? { screensFilteredOut: screenAnalyzer.screensFilteredOut } : {}
-    };
+    return routes;
   }
-  mergeForm(target, source) {
-    for (const field of source.fields) {
-      const existingField = this.findEquivalentField(target.fields, field);
-      if (existingField) {
-        this.mergeField(existingField, field);
-      } else {
-        target.fields.push(field);
+  /** `element={<VehicleList/>}` or `Component={VehicleList}`. */
+  componentNameFromElementAttr(opening) {
+    for (const attr of opening.attributes) {
+      if (!BabelTypes__namespace.isJSXAttribute(attr) || !BabelTypes__namespace.isJSXIdentifier(attr.name)) continue;
+      if (attr.name.name === "element" && BabelTypes__namespace.isJSXExpressionContainer(attr.value)) {
+        const expr = attr.value.expression;
+        if (BabelTypes__namespace.isJSXElement(expr)) return getJsxElementName(expr.openingElement);
+      }
+      if (attr.name.name === "Component" && BabelTypes__namespace.isJSXExpressionContainer(attr.value)) {
+        if (BabelTypes__namespace.isIdentifier(attr.value.expression)) return attr.value.expression.name;
       }
     }
-    target.submitAction = target.submitAction ?? this.namedSubmitAction(source.submitAction);
-    target.validationRules = source.validationRules ? { ...source.validationRules, ...target.validationRules ?? {} } : target.validationRules;
+    return null;
   }
-  findEquivalentField(fields, incoming) {
-    return fields.find((field) => {
-      if (field.name && incoming.name && field.name === incoming.name) return true;
-      if (field.valueBinding && incoming.valueBinding && field.valueBinding === incoming.valueBinding) return true;
-      if (field.locator?.id && incoming.locator?.id && field.locator.id === incoming.locator.id) return true;
-      if (field.placeholder && incoming.placeholder && field.placeholder === incoming.placeholder) return true;
-      if (field.locator?.accessibilityLabel && incoming.locator?.accessibilityLabel && field.locator.accessibilityLabel === incoming.locator.accessibilityLabel) {
-        return true;
+  // ── createBrowserRouter([...]) / useRoutes([...]) style ──────────
+  extractObjectRoutes(ast) {
+    const routes = [];
+    const ROUTER_FACTORIES = /* @__PURE__ */ new Set([
+      "createBrowserRouter",
+      "createHashRouter",
+      "createMemoryRouter",
+      "useRoutes"
+    ]);
+    traverse4__default.default(ast, {
+      CallExpression: (nodePath) => {
+        const callee = nodePath.node.callee;
+        if (!BabelTypes__namespace.isIdentifier(callee) || !ROUTER_FACTORIES.has(callee.name)) return;
+        const first = nodePath.node.arguments[0];
+        if (!BabelTypes__namespace.isArrayExpression(first)) return;
+        this.visitRouteObjects(first, "", routes);
       }
-      return false;
     });
+    return routes;
   }
-  mergeField(target, source) {
-    if (this.isWeakInferredFieldName(target.name) && !this.isWeakInferredFieldName(source.name)) {
-      target.name = source.name;
-    }
-    target.label = target.label ?? source.label;
-    target.placeholder = target.placeholder ?? source.placeholder;
-    target.options = target.options ?? source.options;
-    target.locator = target.locator ?? source.locator;
-    target.sourceComponent = target.sourceComponent ?? source.sourceComponent;
-    target.valueBinding = target.valueBinding ?? source.valueBinding;
-    target.errorBinding = target.errorBinding ?? source.errorBinding;
-    target.required = target.required || source.required;
-    if (target.type === "text" && source.type !== "text") {
-      target.type = source.type;
+  visitRouteObjects(arr, parentPath, out) {
+    for (const element of arr.elements) {
+      if (!BabelTypes__namespace.isObjectExpression(element)) continue;
+      let segment;
+      let isIndex = false;
+      let componentName;
+      let children;
+      for (const prop of element.properties) {
+        if (!BabelTypes__namespace.isObjectProperty(prop) || !BabelTypes__namespace.isIdentifier(prop.key)) continue;
+        const key = prop.key.name;
+        if (key === "path" && BabelTypes__namespace.isStringLiteral(prop.value)) segment = prop.value.value;
+        if (key === "index" && BabelTypes__namespace.isBooleanLiteral(prop.value)) isIndex = prop.value.value;
+        if (key === "element" && BabelTypes__namespace.isJSXElement(prop.value)) {
+          componentName = getJsxElementName(prop.value.openingElement) ?? void 0;
+        }
+        if (key === "Component" && BabelTypes__namespace.isIdentifier(prop.value)) componentName = prop.value.name;
+        if (key === "children" && BabelTypes__namespace.isArrayExpression(prop.value)) children = prop.value;
+      }
+      const fullPath = this.joinPaths(parentPath, segment, isIndex);
+      if ((segment !== void 0 || isIndex) && (componentName || !children)) {
+        out.push(this.buildRoute(fullPath, componentName, isIndex, Boolean(children)));
+      }
+      if (children) this.visitRouteObjects(children, fullPath, out);
     }
   }
-  namedSubmitAction(submitAction) {
-    return submitAction && submitAction !== "anonymous" ? submitAction : void 0;
+  // ── Shared route building ────────────────────────────────────────
+  joinPaths(parent, segment, isIndex) {
+    if (isIndex || segment === void 0) return parent || "/";
+    if (segment.startsWith("/")) return this.normalizePath(segment);
+    return this.normalizePath(`${parent === "/" ? "" : parent}/${segment}`);
   }
-  isWeakInferredFieldName(name) {
-    return /^(text|value|input|query|search|selected|checked)$/i.test(name);
+  normalizePath(p) {
+    const cleaned = `/${p}`.replace(/\/+/g, "/");
+    return cleaned.length > 1 ? cleaned.replace(/\/$/, "") : cleaned;
   }
-  findFormWithSharedFields(forms, incoming) {
-    if (incoming.fields.length === 0) return void 0;
-    let best;
-    for (const form of forms) {
-      const overlap = incoming.fields.filter((field) => this.findEquivalentField(form.fields, field)).length;
-      if (overlap > 0 && (!best || overlap > best.overlap)) {
-        best = { form, overlap };
+  buildRoute(fullPath, componentName, isIndex, isLayout) {
+    const params = this.paramsFromPath(fullPath);
+    return {
+      path: fullPath,
+      screenName: componentName ?? screenNameFromPath(fullPath),
+      ...params.length > 0 ? { params } : {},
+      ...isIndex ? { index: true } : {},
+      ...isLayout ? { layout: true } : {}
+    };
+  }
+  paramsFromPath(routePath) {
+    const params = [];
+    for (const segment of routePath.split("/")) {
+      if (!segment.startsWith(":")) continue;
+      const optional = segment.endsWith("?");
+      const name = segment.slice(1, optional ? -1 : void 0);
+      if (name) params.push({ name, type: "string", required: !optional });
+    }
+    return params;
+  }
+  /**
+   * One entry per path. When several declarations resolve to the same
+   * path, keep the one that best describes what the user lands on: a
+   * page beats a layout wrapper (an `index` child and its parent layout
+   * share a path), and a resolved component name beats a name derived
+   * from the path.
+   */
+  dedupeRoutes(routes) {
+    const byPath = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      const existing = byPath.get(route.path);
+      if (!existing || routeScore(route) > routeScore(existing)) {
+        byPath.set(route.path, route);
       }
     }
-    return best?.form;
+    return Array.from(byPath.values());
+  }
+  buildGraph(routes) {
+    const screens = {};
+    const navigatorName = "router";
+    const screenNames = routes.map((r) => r.screenName);
+    for (const route of routes) {
+      const others = screenNames.filter((name) => name !== route.screenName);
+      screens[route.screenName] = {
+        screenName: route.screenName,
+        // Open-union value — web routes, not a RN stack/tab/drawer.
+        navigatorType: WEB_NAVIGATOR_TYPE,
+        parentNavigator: navigatorName,
+        // Any route is one URL away from any other — both directions,
+        // like the RN analyzer models tab navigators.
+        reachableFrom: others,
+        reachableTo: others,
+        ...route.params ? { params: route.params } : {}
+      };
+    }
+    const initialRoute = routes.find((r) => r.path === "/") ?? routes.find((r) => r.index) ?? routes[0];
+    return {
+      screens,
+      initialScreen: initialRoute?.screenName ?? "",
+      navigators: routes.length > 0 ? [{
+        name: navigatorName,
+        type: WEB_NAVIGATOR_TYPE,
+        screens: screenNames
+      }] : []
+    };
   }
 };
+function screenNameFromPath(routePath) {
+  if (routePath === "/" || routePath === "") return "Home";
+  return routePath.split("/").filter(Boolean).map((segment) => segment.replace(/^:/, "").replace(/\?$/, "")).map(
+    (segment) => segment.split(/[-_.]/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("")
+  ).join("");
+}
+function routeScore(route) {
+  const isPage = route.layout ? 0 : 2;
+  const hasRealName = route.screenName === screenNameFromPath(route.path) ? 0 : 1;
+  return isPage + hasRealName;
+}
+function resolvePathToScreen(routes, target) {
+  const normalized = `/${target}`.replace(/\/+/g, "/").replace(/\?.*$/, "").replace(/#.*$/, "");
+  const cleaned = normalized.length > 1 ? normalized.replace(/\/$/, "") : normalized;
+  const exact = routes.find((r) => r.path === cleaned);
+  if (exact) return exact.screenName;
+  const targetSegments = cleaned.split("/").filter(Boolean);
+  for (const route of routes) {
+    const routeSegments = route.path.split("/").filter(Boolean);
+    if (routeSegments.length !== targetSegments.length) continue;
+    const matches = routeSegments.every(
+      (seg, i) => seg.startsWith(":") || seg === "*" || seg === targetSegments[i]
+    );
+    if (matches) return route.screenName;
+  }
+  return void 0;
+}
 
-// src/analyzers/GenericPlatformAnalyzer.ts
-var GenericPlatformAnalyzer = class {
-  constructor(platform) {
-    this.platform = platform;
+// src/analyzers/web/ReactWebPlatformAnalyzer.ts
+var ReactWebPlatformAnalyzer = class {
+  platform = "web";
+  async analyze(config, options) {
+    const screenAnalyzer = new WebScreenAnalyzer(config, {
+      screenPatterns: options.screenPatterns
+    });
+    const navigationAnalyzer = new WebNavigationAnalyzer(config, {
+      navigationInclude: options.navigationInclude,
+      navigationExclude: options.navigationExclude
+    });
+    console.log("[ReactWebPlatformAnalyzer] Running analyzers...");
+    const [screenAnalysis, navigationResult] = await Promise.all([
+      screenAnalyzer.analyze(),
+      navigationAnalyzer.analyze()
+    ]);
+    const routeScreenNames = new Set(navigationResult.routes.map((route) => route.screenName));
+    const strictScreens = options.strictScreens ?? true;
+    let screensFilteredOut = 0;
+    const included = [];
+    for (const candidate of screenAnalysis.candidates) {
+      if (!strictScreens || this.isScreen(candidate, routeScreenNames)) {
+        included.push(candidate);
+      } else {
+        screensFilteredOut++;
+      }
+    }
+    const screens = included.map(
+      (candidate) => this.resolveRoutePaths(candidate.descriptor, navigationResult.routes)
+    );
+    console.log(
+      `[ReactWebPlatformAnalyzer] Screen and navigation analysis complete. Found ${screens.length} screens, ${navigationResult.routes.length} routes`
+    );
+    return {
+      screens,
+      navigation: navigationResult.graph,
+      analyzedFiles: screenAnalysis.analyzedFiles,
+      ...screensFilteredOut > 0 ? { screensFilteredOut } : {}
+    };
   }
-  platform;
-  async analyze(_config, _options) {
+  isScreen(candidate, routeScreenNames) {
+    return candidate.hasRegisterScreen || candidate.matchesScreenPattern || routeScreenNames.has(candidate.descriptor.name);
+  }
+  /** Replace route-path references with screen names where the route table resolves them. */
+  resolveRoutePaths(screen, routes) {
+    const resolve2 = (target) => {
+      if (!target || !target.startsWith("/")) return target;
+      return resolvePathToScreen(routes, target) ?? target;
+    };
+    const navigationTargets = Array.from(
+      new Set(
+        screen.navigationTargets.map((target) => resolve2(target)).filter((target) => target !== screen.name)
+      )
+    ).sort();
+    const actions = screen.actions.map((action) => {
+      const resolved = resolve2(action.targetScreen);
+      return resolved === action.targetScreen ? action : { ...action, targetScreen: resolved };
+    });
+    const collections = screen.collections?.map((collection) => {
+      const resolveRow = (row) => {
+        if (!row?.targetScreen) return row;
+        const resolved = resolve2(row.targetScreen);
+        if (resolved === row.targetScreen) return row;
+        return {
+          ...row,
+          targetScreen: resolved,
+          ...row.description ? { description: `Clicking a row opens ${resolved}` } : {}
+        };
+      };
+      const rowAction = resolveRow(collection.rowAction);
+      return {
+        ...collection,
+        ...rowAction ? { rowAction } : {},
+        ...collection.rowActions ? { rowActions: collection.rowActions.map((row) => resolveRow(row)) } : {}
+      };
+    });
     return {
-      screens: [],
-      navigation: { screens: {}, initialScreen: "", navigators: [] },
-      analyzedFiles: 0
+      ...screen,
+      navigationTargets,
+      actions,
+      ...collections ? { collections } : {}
     };
   }
 };
@@ -2641,8 +4296,8 @@ var ZodParsedType = util.arrayToEnum([
   "set"
 ]);
 var getParsedType = (data) => {
-  const t8 = typeof data;
-  switch (t8) {
+  const t12 = typeof data;
+  switch (t12) {
     case "undefined":
       return ZodParsedType.undefined;
     case "string":
@@ -2914,8 +4569,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path7, errorMaps, issueData } = params;
-  const fullPath = [...path7, ...issueData.path || []];
+  const { data, path: path9, errorMaps, issueData } = params;
+  const fullPath = [...path9, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -3031,11 +4686,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path7, key) {
+  constructor(parent, value, path9, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path7;
+    this._path = path9;
     this._key = key;
   }
   get path() {
@@ -6476,7 +8131,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../shared/dist/chunk-XLOYG3DH.mjs
+// ../shared/dist/chunk-PKS3VDNB.mjs
 var locatorSourceSchema = external_exports.enum([
   "appilotsId",
   "testID",
@@ -6502,7 +8157,16 @@ var locatorDescriptorSchema = external_exports.object({
   source: locatorSourceSchema.optional()
 }).passthrough();
 var signalDescriptorSchema = external_exports.object({
-  type: external_exports.enum(["navigation", "goBack", "toast", "modal", "inline-error", "data-arrival", "loading", "none"]).or(external_exports.string().min(1).max(60)),
+  type: external_exports.enum([
+    "navigation",
+    "goBack",
+    "toast",
+    "modal",
+    "inline-error",
+    "data-arrival",
+    "loading",
+    "none"
+  ]).or(external_exports.string().min(1).max(60)),
   target: external_exports.string().optional(),
   description: external_exports.string().optional()
 }).passthrough();
@@ -6516,7 +8180,20 @@ var waitPolicyDescriptorSchema = external_exports.object({
   signals: external_exports.array(signalDescriptorSchema).optional(),
   maxMs: external_exports.number().finite().optional()
 }).passthrough();
-var targetDescriptorRoleSchema = external_exports.enum(["button", "submit", "input", "toggle", "select", "date", "list", "row", "menuItem", "modal", "custom"]).or(external_exports.string().min(1).max(60));
+var targetDescriptorRoleSchema = external_exports.enum([
+  "button",
+  "submit",
+  "input",
+  "toggle",
+  "select",
+  "date",
+  "list",
+  "row",
+  "menuItem",
+  "modal",
+  "custom"
+]).or(external_exports.string().min(1).max(60));
+var targetOriginSchema = external_exports.enum(["analyzer", "manifest"]).or(external_exports.string().min(1).max(40));
 var targetDescriptorSchema = external_exports.object({
   id: external_exports.string(),
   role: targetDescriptorRoleSchema,
@@ -6530,10 +8207,20 @@ var targetDescriptorSchema = external_exports.object({
   requiresConfirmation: external_exports.boolean().optional(),
   opensModal: external_exports.string().optional(),
   opensBottomSheet: external_exports.string().optional(),
-  sourceComponent: external_exports.string().optional()
+  sourceComponent: external_exports.string().optional(),
+  origin: targetOriginSchema.optional()
 }).passthrough();
 var flowStepDescriptorSchema = external_exports.object({
-  type: external_exports.enum(["navigate", "fill", "press", "select", "toggle", "wait", "confirm", "choose-list-item"]).or(external_exports.string().min(1).max(60)),
+  type: external_exports.enum([
+    "navigate",
+    "fill",
+    "press",
+    "select",
+    "toggle",
+    "wait",
+    "confirm",
+    "choose-list-item"
+  ]).or(external_exports.string().min(1).max(60)),
   target: external_exports.string().optional(),
   label: external_exports.string().optional(),
   description: external_exports.string().optional(),
@@ -6661,7 +8348,19 @@ var navigationNodeSchema = external_exports.object({
   parentNavigator: external_exports.string().optional(),
   reachableFrom: external_exports.array(external_exports.string()).default([]),
   reachableTo: external_exports.array(external_exports.string()).default([]),
-  params: external_exports.array(paramDescriptorSchema).optional()
+  params: external_exports.array(paramDescriptorSchema).optional(),
+  /**
+   * Web clients only (documented convention, additive — previously
+   * round-tripped via `.passthrough()`): the screen's URL route
+   * template, e.g. `/users/:id`. Param segments use `:name` (the
+   * relay also accepts `[name]` / `{name}`). When present and the
+   * request's `context.platform` is `'web'`, the relay resolves
+   * `navigate` targets against these templates and injects the
+   * concrete URL segments as the navigate payload's `path` — the web
+   * equivalent of RN's nested-navigation path injection. See
+   * docs/agent-contract.md ("Web clients" section).
+   */
+  path: external_exports.string().max(500).optional()
 }).passthrough();
 var navigatorDescriptorSchema = external_exports.object({
   name: external_exports.string(),
@@ -6708,6 +8407,50 @@ var loginSchema = external_exports.object({
 loginSchema.extend({
   name: external_exports.string().min(2, "Name must be at least 2 characters").max(100)
 });
+external_exports.object({
+  name: external_exports.string().min(2, "Name must be at least 2 characters").max(100).optional(),
+  avatarUrl: external_exports.string().url("Invalid URL").max(2048).nullable().optional()
+}).refine((v) => v.name !== void 0 || v.avatarUrl !== void 0, {
+  message: "At least one field must be provided"
+});
+external_exports.object({
+  currentPassword: external_exports.string().min(1, "Current password is required"),
+  newPassword: external_exports.string().min(8, "Password must be at least 8 characters")
+});
+var totpCodeSchema = external_exports.string().transform((v) => v.replace(/\s/g, "")).pipe(external_exports.string().regex(/^\d{6}$/, "Code must be 6 digits"));
+var recoveryCodeSchema = external_exports.string().transform((v) => v.toUpperCase().replace(/[^A-Z0-9]/g, "")).pipe(external_exports.string().regex(/^[23456789BCDFGHJKMNPQRSTVWXYZ]{10}$/, "Invalid recovery code"));
+external_exports.object({
+  code: totpCodeSchema
+});
+external_exports.object({
+  challengeToken: external_exports.string().min(1, "Challenge token is required"),
+  code: totpCodeSchema.optional(),
+  recoveryCode: recoveryCodeSchema.optional()
+}).refine((v) => Boolean(v.code) !== Boolean(v.recoveryCode), {
+  message: "Provide either a TOTP code or a recovery code",
+  path: ["code"]
+});
+external_exports.object({
+  password: external_exports.string().min(1, "Password is required"),
+  code: totpCodeSchema.optional(),
+  recoveryCode: recoveryCodeSchema.optional()
+}).refine((v) => Boolean(v.code) !== Boolean(v.recoveryCode), {
+  message: "Provide either a TOTP code or a recovery code",
+  path: ["code"]
+});
+external_exports.object({
+  password: external_exports.string().min(1, "Password is required"),
+  code: totpCodeSchema
+});
+external_exports.object({
+  password: external_exports.string().min(1, "Password is required"),
+  code: totpCodeSchema.optional(),
+  recoveryCode: recoveryCodeSchema.optional(),
+  confirm: external_exports.literal("DELETE MY ACCOUNT")
+}).refine((v) => !(v.code && v.recoveryCode), {
+  message: "Provide either a TOTP code or a recovery code, not both",
+  path: ["code"]
+});
 var createProjectSchema = external_exports.object({
   name: external_exports.string().min(1).max(100),
   description: external_exports.string().max(500).optional(),
@@ -6743,6 +8486,7 @@ external_exports.object({
   content: external_exports.record(external_exports.unknown())
 });
 var apiKeyScopeSchema = external_exports.enum(["sdk", "operator"]);
+var apiKeyEnvironmentSchema = external_exports.enum(["test", "live"]);
 external_exports.object({
   name: external_exports.string().min(1).max(100),
   // Required for `sdk` (default), forbidden/ignored for `operator` —
@@ -6750,6 +8494,7 @@ external_exports.object({
   // missing scope still validates as the pre-existing SDK shape.
   projectId: external_exports.string().min(1).optional(),
   scope: apiKeyScopeSchema.default("sdk"),
+  environment: apiKeyEnvironmentSchema.optional(),
   expiresAt: external_exports.string().datetime().optional()
 }).refine((v) => v.scope !== "sdk" || !!v.projectId, {
   message: 'projectId is required for scope "sdk"',
@@ -6757,13 +8502,23 @@ external_exports.object({
 });
 var boundedString = (max) => external_exports.string().max(max);
 var clientPlatformSchema = external_exports.enum(["react-native", "web", "android", "ios"]).or(external_exports.string().min(1).max(40));
+var identityProvenanceSchema = external_exports.enum(["declared", "derived", "positional"]).or(external_exports.string().min(1).max(40));
 var snapshotInputSchema = external_exports.object({
   id: boundedString(160).optional(),
+  provenance: identityProvenanceSchema.optional(),
+  /**
+   * False when the control is mounted but currently OUTSIDE the window —
+   * below the fold, scrolled off, pushed sideways. Absent means the client
+   * cannot tell (old React Native architecture, or any SDK published
+   * before the field existed), which must never be read as `false`.
+   */
+  onScreen: external_exports.boolean().optional(),
   label: boundedString(300).optional(),
   value: boundedString(4096).optional(),
   placeholder: boundedString(300).optional(),
   editable: external_exports.boolean().optional(),
   secure: external_exports.boolean().optional(),
+  submitsOnReturn: external_exports.boolean().optional(),
   type: boundedString(40).optional(),
   required: external_exports.boolean().optional(),
   invalid: external_exports.boolean().optional(),
@@ -6771,6 +8526,14 @@ var snapshotInputSchema = external_exports.object({
 }).passthrough();
 var snapshotButtonSchema = external_exports.object({
   id: boundedString(160).optional(),
+  provenance: identityProvenanceSchema.optional(),
+  /**
+   * False when the control is mounted but currently OUTSIDE the window —
+   * below the fold, scrolled off, pushed sideways. Absent means the client
+   * cannot tell (old React Native architecture, or any SDK published
+   * before the field existed), which must never be read as `false`.
+   */
+  onScreen: external_exports.boolean().optional(),
   label: boundedString(300).optional(),
   disabled: external_exports.boolean().optional(),
   inModal: external_exports.boolean().optional(),
@@ -6780,12 +8543,28 @@ var snapshotButtonSchema = external_exports.object({
 }).passthrough();
 var snapshotToggleSchema = external_exports.object({
   id: boundedString(160).optional(),
+  provenance: identityProvenanceSchema.optional(),
+  /**
+   * False when the control is mounted but currently OUTSIDE the window —
+   * below the fold, scrolled off, pushed sideways. Absent means the client
+   * cannot tell (old React Native architecture, or any SDK published
+   * before the field existed), which must never be read as `false`.
+   */
+  onScreen: external_exports.boolean().optional(),
   label: boundedString(300).optional(),
   value: external_exports.boolean().optional(),
   inModal: external_exports.boolean().optional()
 }).passthrough();
 var snapshotSliderSchema = external_exports.object({
   id: boundedString(160).optional(),
+  provenance: identityProvenanceSchema.optional(),
+  /**
+   * False when the control is mounted but currently OUTSIDE the window —
+   * below the fold, scrolled off, pushed sideways. Absent means the client
+   * cannot tell (old React Native architecture, or any SDK published
+   * before the field existed), which must never be read as `false`.
+   */
+  onScreen: external_exports.boolean().optional(),
   label: boundedString(300).optional(),
   value: external_exports.number().finite().optional(),
   min: external_exports.number().finite().optional(),
@@ -6826,6 +8605,26 @@ var snapshotListSchema = external_exports.object({
   // should chase, and the relay only reads a known subset.
   items: external_exports.array(external_exports.record(external_exports.unknown())).max(500).optional()
 }).passthrough();
+var snapshotNativeDialogSchema = external_exports.object({
+  id: boundedString(160),
+  title: boundedString(300).optional(),
+  message: boundedString(2e3).optional(),
+  buttons: external_exports.array(
+    external_exports.object({
+      label: boundedString(160),
+      style: external_exports.enum(["default", "cancel", "destructive"]).optional()
+    }).passthrough()
+  ).max(10)
+}).passthrough();
+var snapshotScrollableSchema = external_exports.object({
+  id: boundedString(160),
+  containerType: boundedString(60).optional(),
+  label: boundedString(300).optional(),
+  scrollOffsetY: external_exports.number().finite().optional(),
+  canScrollUp: external_exports.boolean().optional(),
+  canScrollDown: external_exports.boolean().optional(),
+  horizontal: external_exports.boolean().optional()
+}).passthrough();
 var snapshotChoiceGroupSchema = external_exports.object({
   index: external_exports.number().int().optional(),
   id: boundedString(160).optional(),
@@ -6842,6 +8641,14 @@ var snapshotElementSchema = external_exports.object({
   disabled: external_exports.boolean().optional(),
   selected: external_exports.boolean().optional(),
   source: boundedString(40).optional(),
+  provenance: identityProvenanceSchema.optional(),
+  /**
+   * False when the control is mounted but currently OUTSIDE the window —
+   * below the fold, scrolled off, pushed sideways. Absent means the client
+   * cannot tell (old React Native architecture, or any SDK published
+   * before the field existed), which must never be read as `false`.
+   */
+  onScreen: external_exports.boolean().optional(),
   targetId: boundedString(160).optional(),
   listContext: external_exports.record(external_exports.unknown()).optional(),
   inModal: external_exports.boolean().optional()
@@ -6858,7 +8665,34 @@ var agentSnapshotSchema = external_exports.object({
   modalOpen: external_exports.boolean().optional(),
   lists: external_exports.array(snapshotListSchema).max(100).optional(),
   choiceGroups: external_exports.array(snapshotChoiceGroupSchema).max(100).optional(),
-  elements: external_exports.array(snapshotElementSchema).max(1e3).optional()
+  scrollables: external_exports.array(snapshotScrollableSchema).max(20).optional(),
+  nativeDialog: snapshotNativeDialogSchema.optional(),
+  elements: external_exports.array(snapshotElementSchema).max(1e3).optional(),
+  /**
+   * The client clamped this observation to the caps above and lost
+   * data doing it (`clampSnapshotToWireLimits` in
+   * `@appilots/client-core`). Read by the prompt serializer so the
+   * model is told the view is partial — a screen truncated at 500
+   * texts must not be read as a screen that only has 500 things on
+   * it. Optional: older SDKs never clamp and never send it.
+   */
+  truncated: external_exports.boolean().optional(),
+  /**
+   * How many of this screen's controls the client could name, split by
+   * `identityProvenance`. Diagnostic only — the relay never grounds an
+   * action on it — but it is the number that says whether an app needs
+   * annotating, and comparing it between a debug and a release build is
+   * the first direct measurement of what minification costs the agent.
+   */
+  stats: external_exports.object({
+    visitedFibers: external_exports.number().int().nonnegative().optional(),
+    skippedHidden: external_exports.number().int().nonnegative().optional(),
+    identity: external_exports.object({
+      declared: external_exports.number().int().nonnegative().optional(),
+      derived: external_exports.number().int().nonnegative().optional(),
+      positional: external_exports.number().int().nonnegative().optional()
+    }).passthrough().optional()
+  }).passthrough().optional()
 }).passthrough();
 var agentContextSchema = external_exports.object({
   /**
@@ -6908,6 +8742,19 @@ var agentContextSchema = external_exports.object({
   ).max(200).optional(),
   loadingPending: external_exports.boolean().optional()
 }).passthrough();
+var introspectionFailureReasonSchema = external_exports.enum([
+  "sentinel-missing-internals",
+  "never-mounted",
+  "render-crashed",
+  "names-mangled",
+  "walk-recognized-nothing"
+]);
+var introspectionDiagnosticsSchema = external_exports.object({
+  captured: external_exports.boolean(),
+  failureReason: introspectionFailureReasonSchema.nullish(),
+  reactVersion: boundedString(32).nullish(),
+  failureCount: external_exports.number().int().min(0).max(1e6).optional()
+});
 external_exports.object({
   content: external_exports.string().min(1).max(4096),
   sessionId: external_exports.string().optional(),
@@ -6917,7 +8764,20 @@ external_exports.object({
    * the active MCP doc and emits `mcp_version_mismatch` telemetry when
    * they differ. Optional — older SDKs simply skip the check.
    */
-  mcpVersion: external_exports.string().max(64).optional()
+  mcpVersion: external_exports.string().max(64).optional(),
+  /**
+   * SDK-side introspection health. Only sent when it FAILED — a client
+   * that reached the React tree omits the field entirely, so the happy
+   * path costs nothing on the wire.
+   *
+   * Without this, an app whose introspection is dead sends a snapshot
+   * that is empty but perfectly well-formed, indistinguishable from a
+   * genuinely empty screen. The server emits
+   * `introspection_unavailable` so the failure is visible to us instead
+   * of waiting for a bug report. Optional — older SDKs simply never
+   * send it.
+   */
+  introspection: introspectionDiagnosticsSchema.optional()
 });
 var agentActionTypeSchema = external_exports.enum([
   "navigate",
@@ -6928,11 +8788,22 @@ var agentActionTypeSchema = external_exports.enum([
   "custom"
 ]);
 var navigationPayloadSchema = external_exports.object({
-  screenName: external_exports.string().min(1),
+  // Optional ONLY so `goBack` can exist (#398): it returns to whatever
+  // is beneath on the stack and has no destination to name. Every other
+  // action is still required to carry one — enforced by the refine
+  // below rather than by the field, so the error names the real problem
+  // ("navigate needs a screenName") instead of a missing key.
+  screenName: external_exports.string().min(1).optional(),
   params: external_exports.record(external_exports.unknown()).optional(),
   navigationAction: external_exports.enum(["push", "navigate", "replace", "goBack", "reset"]).default("navigate").optional(),
   path: external_exports.array(external_exports.string().min(1)).optional()
-}).passthrough();
+}).passthrough().refine(
+  (payload) => payload.navigationAction === "goBack" || typeof payload.screenName === "string" && payload.screenName.length > 0,
+  {
+    message: 'screenName is required for every navigationAction except "goBack"',
+    path: ["screenName"]
+  }
+);
 var formFillFieldSchema = external_exports.object({
   fieldId: external_exports.string().min(1),
   fieldType: external_exports.enum(["text", "select", "toggle", "date", "number", "custom"]).default("text").optional(),
@@ -7266,6 +9137,8 @@ var sandboxObservationSchema = external_exports.object({
   inputs: external_exports.array(
     external_exports.object({
       id: external_exports.string().max(120),
+      provenance: identityProvenanceSchema.optional(),
+      onScreen: external_exports.boolean().optional(),
       label: external_exports.string().max(200).optional(),
       value: external_exports.string().max(2e3).optional(),
       disabled: external_exports.boolean().optional(),
@@ -7279,6 +9152,8 @@ var sandboxObservationSchema = external_exports.object({
   buttons: external_exports.array(
     external_exports.object({
       id: external_exports.string().max(120),
+      provenance: identityProvenanceSchema.optional(),
+      onScreen: external_exports.boolean().optional(),
       label: external_exports.string().max(200).optional(),
       disabled: external_exports.boolean().optional(),
       /** Risk metadata (e.g. "high") the SDK forwards for danger UI. */
@@ -7300,6 +9175,8 @@ var sandboxObservationSchema = external_exports.object({
   sliders: external_exports.array(
     external_exports.object({
       id: external_exports.string().max(120),
+      provenance: identityProvenanceSchema.optional(),
+      onScreen: external_exports.boolean().optional(),
       label: external_exports.string().max(200).optional(),
       value: external_exports.number().finite().optional(),
       min: external_exports.number().finite().optional(),
@@ -7329,6 +9206,44 @@ var sandboxObservationSchema = external_exports.object({
       ).max(200).optional()
     }).passthrough()
   ).max(20).optional(),
+  /**
+   * Toggles exactly as the SDK snapshot reports them (#390).
+   *
+   * Their absence is why `generality-component-control-smarthome`
+   * came back `errored` with a 422 instead of measuring anything:
+   * this schema is `.strict()`, so a scenario that declares a switch
+   * is rejected before the agent is ever asked. Which means the
+   * corpus could not express the single control behind failure 02 of
+   * the functional audit — "disable an agent; the switch never
+   * moves". The one defect the eval most needed to catch was the one
+   * shape it could not describe.
+   */
+  toggles: external_exports.array(
+    external_exports.object({
+      id: external_exports.string().max(120),
+      provenance: identityProvenanceSchema.optional(),
+      onScreen: external_exports.boolean().optional(),
+      label: external_exports.string().max(200).optional(),
+      value: external_exports.boolean().optional(),
+      disabled: external_exports.boolean().optional()
+    })
+  ).max(100).optional(),
+  /**
+   * The interaction graph — the `el:*` ids the prompt tells the model
+   * to prefer over ordinal handles. Passthrough per entry for the
+   * same reason `lists` is: the SDK adds fields faster than this
+   * schema should chase them.
+   */
+  elements: external_exports.array(
+    external_exports.object({
+      id: external_exports.string().max(160),
+      role: external_exports.string().max(40).optional(),
+      label: external_exports.string().max(300).optional()
+    }).passthrough()
+  ).max(500).optional(),
+  /** Screen-level state the relay renders and branches on. */
+  loading: external_exports.boolean().optional(),
+  modalOpen: external_exports.boolean().optional(),
   extra: external_exports.record(external_exports.unknown()).optional()
 }).strict();
 external_exports.object({
@@ -7369,8 +9284,36 @@ external_exports.object({
    * heuristics, forces tool choice when the last user message carries a
    * failure marker). Only meaningful alongside `history`.
    */
-  isRecoveryHop: external_exports.boolean().optional()
+  isRecoveryHop: external_exports.boolean().optional(),
+  /**
+   * Run this call against the application structure supplied here
+   * instead of the project's active MCP document.
+   *
+   * Sandbox-only, and the relay honours it only on a `dryRun` call —
+   * see `resolveMcpOverride` in apps/api. It exists because the eval
+   * corpus could otherwise only ever describe ONE app: every scenario
+   * resolves to the same seeded project, so every navigate destination,
+   * every screen title and every bit of domain priming in the prompt
+   * came from the same vehicle-management demo. A suite that can only
+   * pose questions about one app cannot measure whether the agent works
+   * on another one.
+   *
+   * Deliberately loose (`z.record`): the MCP document's shape is owned
+   * by the generator, and pinning it here would turn every additive
+   * generator change into a 422 in the sandbox.
+   */
+  applicationStructure: external_exports.record(external_exports.unknown()).optional()
 }).strict();
+var relayDiagnosticsSchema = external_exports.object({
+  unverifiedTargets: external_exports.array(external_exports.string()),
+  guardsFired: external_exports.array(external_exports.object({ guard: external_exports.string(), detail: external_exports.string().optional() })),
+  repairMode: external_exports.enum(["repair", "strict", "disabled"]),
+  promptVersion: external_exports.string(),
+  // Defaulted for producers that predate the field: before it existed
+  // every response had reached the model, so `true` is the correct
+  // backfill.
+  modelInvoked: external_exports.boolean().default(true)
+});
 var sandboxTraceHopSchema = external_exports.object({
   hop: external_exports.number().int().nonnegative(),
   inputPreview: external_exports.string(),
@@ -7409,7 +9352,16 @@ external_exports.object({
   /** Hop-by-hop trace. Always at least one entry. */
   trace: external_exports.array(sandboxTraceHopSchema),
   /** True when the run was a no-op (e.g. project has no MCP yet). */
-  warning: external_exports.string().optional()
+  warning: external_exports.string().optional(),
+  /**
+   * SPEC-046 — guard / hallucination telemetry for the run.
+   *
+   * ADDITIVE AND OPTIONAL, permanently: SDK and dashboard consumers
+   * predate it, and older API deployments will not send it. Consumers
+   * must treat an absent block as "no information", never as "no guards
+   * fired".
+   */
+  diagnostics: relayDiagnosticsSchema.optional()
 });
 external_exports.object({
   name: external_exports.string().min(1).max(120),
@@ -7613,6 +9565,30 @@ external_exports.object({
   name: external_exports.string().min(1).max(200).optional(),
   identifiers: endUserIdentifiersSchema.optional()
 });
+var MAX_EXTERNAL_USER_ID_LENGTH = 128;
+function normalizeExternalUserId(value) {
+  let raw;
+  if (typeof value === "string") raw = value;
+  else if (typeof value === "number" && Number.isFinite(value)) raw = String(value);
+  else return void 0;
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.length > MAX_EXTERNAL_USER_ID_LENGTH) return void 0;
+  return trimmed;
+}
+var MAX_DEVICE_INFO_BYTES = 4096;
+var sessionDeviceInfoSchema = external_exports.object({
+  platform: external_exports.string().max(64).optional(),
+  osVersion: external_exports.string().max(64).optional(),
+  appVersion: external_exports.string().max(64).optional(),
+  sdkVersion: external_exports.string().max(64).optional()
+}).passthrough().refine((info) => JSON.stringify(info).length <= MAX_DEVICE_INFO_BYTES, {
+  message: `device_info exceeds ${MAX_DEVICE_INFO_BYTES} bytes`
+});
+external_exports.object({
+  userId: external_exports.preprocess(normalizeExternalUserId, external_exports.string().optional()),
+  deviceInfo: sessionDeviceInfoSchema.optional().catch(void 0)
+});
 external_exports.object({
   projectId: external_exports.string().min(1).max(64),
   externalId: external_exports.string().min(1).max(128),
@@ -7620,6 +9596,27 @@ external_exports.object({
   identifiers: endUserIdentifiersSchema.optional()
 });
 
+// src/utils/stringify.ts
+function stringifyUnknown(value) {
+  if (value instanceof Error) {
+    const message = value.message || value.name;
+    const cause = value.cause;
+    if (cause instanceof Error && cause.message && cause.message !== message) {
+      return `${message} (${cause.message})`;
+    }
+    return message;
+  }
+  if (typeof value === "string") return value;
+  if (value === null || value === void 0) return String(value);
+  if (typeof value !== "object") return String(value);
+  try {
+    const json = JSON.stringify(value);
+    if (json && json !== "{}") return json;
+  } catch {
+  }
+  return String(value);
+}
+
 // src/manifest/loadManifest.ts
 var DEFAULT_MANIFEST_FILENAME = "appilots.manifest.json";
 var manifestSchema = external_exports.object({
@@ -7628,7 +9625,7 @@ var manifestSchema = external_exports.object({
   navigation: navigationGraphSchema.partial().optional()
 }).passthrough();
 async function loadManifest(rootDir, manifestPath) {
-  const resolvedPath = path6__namespace.default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
+  const resolvedPath = path8__namespace.default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
   let raw;
   try {
     raw = await fs.readFile(resolvedPath, "utf-8");
@@ -7636,14 +9633,16 @@ async function loadManifest(rootDir, manifestPath) {
     if (error?.code === "ENOENT") {
       return { manifest: null, resolvedPath };
     }
-    throw new Error(`Failed to read Appilots manifest at ${resolvedPath}: ${error?.message ?? String(error)}`);
+    throw new Error(
+      `Failed to read Appilots manifest at ${resolvedPath}: ${stringifyUnknown(error)}`
+    );
   }
   let parsedJson;
   try {
     parsedJson = JSON.parse(raw);
   } catch (error) {
     throw new Error(
-      `Appilots manifest at ${resolvedPath} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`
+      `Appilots manifest at ${resolvedPath} is not valid JSON: ${stringifyUnknown(error)}`
     );
   }
   const result = manifestSchema.safeParse(parsedJson);
@@ -7657,11 +9656,47 @@ Each entry in "screens" must match the ScreenDescriptor shape (see docs/platform
   }
   return { manifest: result.data, resolvedPath };
 }
+function mergeScreen(base, declared) {
+  const fields = { ...base };
+  for (const [key, value] of Object.entries(declared)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value) && value.length === 0) continue;
+    fields[key] = value;
+  }
+  const merged = fields;
+  merged.targets = mergeById(base.targets, markManifestOrigin(declared.targets));
+  merged.actions = mergeById(base.actions, declared.actions) ?? [];
+  if (base.agentHints || declared.agentHints) {
+    merged.agentHints = { ...base.agentHints, ...declared.agentHints };
+  }
+  return merged;
+}
+function mergeById(base, overlay) {
+  if (!overlay || overlay.length === 0) return base;
+  if (!base || base.length === 0) return overlay;
+  const byId = /* @__PURE__ */ new Map();
+  for (const entry of base) byId.set(entry.id, entry);
+  for (const entry of overlay) {
+    const existing = byId.get(entry.id);
+    byId.set(entry.id, existing ? { ...existing, ...entry } : entry);
+  }
+  return Array.from(byId.values());
+}
+function markManifestOrigin(targets) {
+  if (!targets || targets.length === 0) return targets;
+  return targets.map((target) => ({ origin: "manifest", ...target }));
+}
 function mergeManifestScreens(analyzerScreens, manifestScreens) {
   if (!manifestScreens || manifestScreens.length === 0) return analyzerScreens;
   const byName = /* @__PURE__ */ new Map();
   for (const screen of analyzerScreens) byName.set(screen.name, screen);
-  for (const screen of manifestScreens) byName.set(screen.name, screen);
+  for (const declared of manifestScreens) {
+    const base = byName.get(declared.name);
+    byName.set(
+      declared.name,
+      base ? mergeScreen(base, declared) : { ...declared, targets: markManifestOrigin(declared.targets) }
+    );
+  }
   return Array.from(byName.values());
 }
 function mergeManifestNavigation(analyzerNavigation, manifestNavigation) {
@@ -7913,12 +9948,15 @@ var MCPGenerator = class _MCPGenerator {
   /**
    * Select the `PlatformAnalyzer` implementation for a `.appilotsrc`
    * `platform` value. `'react-native'` (or unset — the existing default)
-   * gets the real Babel/JSX pipeline; anything else gets the no-op
-   * generic analyzer, relying entirely on a declared manifest.
+   * gets the RN Babel/JSX pipeline; `'web'` gets the React web (DOM +
+   * React Router) pipeline; anything else gets the no-op generic
+   * analyzer, relying entirely on a declared manifest. The manifest
+   * still merges on top of every analyzer's output either way.
    */
   static createPlatformAnalyzer(platform) {
     const resolved = platform ?? "react-native";
     if (resolved === "react-native") return new ReactNativePlatformAnalyzer();
+    if (resolved === "web") return new ReactWebPlatformAnalyzer();
     return new GenericPlatformAnalyzer(resolved);
   }
   /** Generate MCP documents from the project */
@@ -7948,7 +9986,12 @@ var MCPGenerator = class _MCPGenerator {
     }
     const mergedScreens = mergeManifestScreens(analyzed.screens, manifest?.screens);
     const navigation = mergeManifestNavigation(analyzed.navigation, manifest?.navigation);
-    const agentReadyScreens = mergedScreens.map(enrichScreenForAgent);
+    const agentReadyScreens = mergedScreens.map(
+      (screen) => enrichScreenForAgent({
+        ...screen,
+        filePath: screen.filePath ? path8__namespace.default.relative(this.generatorConfig.rootDir, screen.filePath) : screen.filePath
+      })
+    );
     const projectInfo = await this.getProjectInfo();
     const projectName = projectInfo.name;
     console.log(`[MCPGenerator] Project name: ${projectName}`);
@@ -7971,13 +10014,10 @@ var MCPGenerator = class _MCPGenerator {
     };
     const serialized = JSON.stringify(document, null, 2);
     const checksum = this.calculateChecksum(serialized);
-    const filePath = path6__namespace.default.resolve(
-      outputDir,
-      `mcp-document.${this.options.format}`
-    );
+    const filePath = path8__namespace.default.resolve(outputDir, `mcp-document.${this.options.format}`);
     await fs.writeFile(filePath, serialized, "utf-8");
     console.log(`[MCPGenerator] Document written to: ${filePath}`);
-    const checksumFilePath = path6__namespace.default.resolve(outputDir, ".appilots-checksum");
+    const checksumFilePath = path8__namespace.default.resolve(outputDir, ".appilots-checksum");
     await fs.writeFile(checksumFilePath, checksum, "utf-8");
     console.log(`[MCPGenerator] Checksum written to: ${checksumFilePath}`);
     console.log("[MCPGenerator] Generation complete!");
@@ -7997,7 +10037,7 @@ var MCPGenerator = class _MCPGenerator {
    * after calling `generate()`.
    */
   static async readPreviousChecksum(outputDir) {
-    const checksumFilePath = path6__namespace.default.resolve(outputDir, ".appilots-checksum");
+    const checksumFilePath = path8__namespace.default.resolve(outputDir, ".appilots-checksum");
     try {
       const content = await fs.readFile(checksumFilePath, "utf-8");
       return content.trim() || null;
@@ -8016,7 +10056,7 @@ var MCPGenerator = class _MCPGenerator {
    */
   async getProjectInfo() {
     try {
-      const packageJsonPath = path6__namespace.default.resolve(this.analyzerConfig.rootDir, "package.json");
+      const packageJsonPath = path8__namespace.default.resolve(this.analyzerConfig.rootDir, "package.json");
       const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
       const packageJson = JSON.parse(packageJsonContent);
       return {
@@ -8029,6 +10069,70 @@ var MCPGenerator = class _MCPGenerator {
     }
   }
 };
+var DEFAULT_SERVER_URL = "http://localhost:4000";
+var KNOWN_CONFIG_KEYS = [
+  "apiKey",
+  "projectId",
+  "serverUrl",
+  "outputDir",
+  "include",
+  "exclude",
+  "autoActivate",
+  "strictScreens",
+  "screenPatterns",
+  "navigationInclude",
+  "navigationExclude",
+  "platform",
+  "manifestPath",
+  "eval"
+];
+var KEY_ALIASES = {
+  apiUrl: "serverUrl",
+  // `@appilots/sdk`'s own name for this. One `.appilotsrc` feeds both
+  // packages, so an integrator who wrote the SDK's key should not be told
+  // it is unrecognized.
+  apiBaseUrl: "serverUrl",
+  apiURL: "serverUrl",
+  baseUrl: "serverUrl",
+  url: "serverUrl",
+  host: "serverUrl",
+  endpoint: "serverUrl",
+  server: "serverUrl",
+  key: "apiKey",
+  token: "apiKey",
+  project: "projectId",
+  sourceDir: "include",
+  srcDir: "include",
+  source: "include",
+  outDir: "outputDir"
+};
+function editDistance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const deletion = (previous[j] ?? 0) + 1;
+      const insertion = (current[j - 1] ?? 0) + 1;
+      const substitution = (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1);
+      current.push(Math.min(deletion, insertion, substitution));
+    }
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+function suggestConfigKey(key) {
+  const alias = KEY_ALIASES[key];
+  if (alias) return alias;
+  const lower = key.toLowerCase();
+  let best;
+  for (const known of KNOWN_CONFIG_KEYS) {
+    const distance = editDistance(lower, known.toLowerCase());
+    if (distance <= 2 && (!best || distance < best.distance)) {
+      best = { key: known, distance };
+    }
+  }
+  return best?.key;
+}
 function getEnvOverrides(env = process.env) {
   const clean = (value) => {
     const trimmed = value?.trim();
@@ -8040,7 +10144,7 @@ function getEnvOverrides(env = process.env) {
     serverUrl: clean(env.APPILOTS_SERVER_URL)
   };
 }
-function loadConfig() {
+function loadConfig(onWarn) {
   const configPath = getConfigPath();
   const env = getEnvOverrides();
   let fileConfig = {};
@@ -8048,13 +10152,15 @@ function loadConfig() {
     try {
       fileConfig = JSON.parse(fs$1.readFileSync(configPath, "utf-8"));
     } catch (error) {
-      throw new Error(`Failed to parse .appilotsrc at ${configPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+      throw new Error(
+        `Failed to parse .appilotsrc at ${configPath}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
     }
   } else if (!env.apiKey) {
     return null;
   }
   const merged = {
-    serverUrl: "http://localhost:4000",
+    serverUrl: DEFAULT_SERVER_URL,
     outputDir: ".appilots",
     autoActivate: true,
     strictScreens: true,
@@ -8064,6 +10170,12 @@ function loadConfig() {
     ...env.serverUrl ? { serverUrl: env.serverUrl } : {}
   };
   const validation = validateConfig(merged);
+  if (onWarn) {
+    const source = configPath ?? "environment variables";
+    for (const warning of validation.warnings) {
+      onWarn(`${source}: ${warning}`);
+    }
+  }
   if (!validation.valid) {
     const source = configPath ?? "environment variables";
     throw new Error(
@@ -8074,12 +10186,12 @@ function loadConfig() {
   return merged;
 }
 function saveConfig(dir, config) {
-  const configPath = path6.join(dir, ".appilotsrc");
+  const configPath = path8.join(dir, ".appilotsrc");
   const existingConfig = getConfigPath() ? loadConfig() : null;
   const mergedConfig = {
     apiKey: config.apiKey || existingConfig?.apiKey || "",
     projectId: config.projectId || existingConfig?.projectId || "",
-    serverUrl: config.serverUrl || existingConfig?.serverUrl || "http://localhost:4000",
+    serverUrl: config.serverUrl || existingConfig?.serverUrl || DEFAULT_SERVER_URL,
     outputDir: config.outputDir || existingConfig?.outputDir || ".appilots",
     autoActivate: config.autoActivate !== void 0 ? config.autoActivate : existingConfig?.autoActivate ?? true,
     include: config.include || existingConfig?.include,
@@ -8095,23 +10207,25 @@ function saveConfig(dir, config) {
   try {
     fs$1.writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
   } catch (error) {
-    throw new Error(`Failed to write .appilotsrc to ${configPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    throw new Error(
+      `Failed to write .appilotsrc to ${configPath}: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
   }
 }
 function getConfigPath() {
-  let currentDir = path6.resolve(process.cwd());
-  const root = path6.resolve("/");
+  let currentDir = path8.resolve(process.cwd());
+  const root = path8.resolve("/");
   while (currentDir !== root) {
-    const configPath = path6.join(currentDir, ".appilotsrc");
+    const configPath = path8.join(currentDir, ".appilotsrc");
     try {
       if (fs$1.existsSync(configPath) && fs$1.statSync(configPath).isFile()) {
         return configPath;
       }
     } catch {
     }
-    currentDir = path6.resolve(currentDir, "..");
+    currentDir = path8.resolve(currentDir, "..");
   }
-  const rootConfigPath = path6.join(root, ".appilotsrc");
+  const rootConfigPath = path8.join(root, ".appilotsrc");
   try {
     if (fs$1.existsSync(rootConfigPath) && fs$1.statSync(rootConfigPath).isFile()) {
       return rootConfigPath;
@@ -8122,14 +10236,25 @@ function getConfigPath() {
 }
 function validateConfig(config) {
   const errors = [];
+  const warnings = [];
   if (!config || typeof config !== "object") {
     return {
       valid: false,
-      errors: ["Configuration must be an object"]
+      errors: ["Configuration must be an object"],
+      warnings
     };
   }
+  for (const key of Object.keys(config)) {
+    if (KNOWN_CONFIG_KEYS.includes(key)) continue;
+    const suggestion = suggestConfigKey(key);
+    warnings.push(
+      `unknown key "${key}" \u2014 ignored` + (suggestion ? ` (did you mean "${suggestion}"?)` : "")
+    );
+  }
   if (!config.apiKey || typeof config.apiKey !== "string") {
-    errors.push("apiKey is required and must be a string (set it in .appilotsrc or via APPILOTS_API_KEY)");
+    errors.push(
+      "apiKey is required and must be a string (set it in .appilotsrc or via APPILOTS_API_KEY)"
+    );
   } else if (!config.apiKey.startsWith("ak_")) {
     errors.push('apiKey must start with "ak_"');
   }
@@ -8191,7 +10316,8 @@ function validateConfig(config) {
   }
   return {
     valid: errors.length === 0,
-    errors
+    errors,
+    warnings
   };
 }
 
@@ -8237,19 +10363,76 @@ function formatMetadataWarnings(warnings) {
   );
 }
 
+// ../shared/dist/chunk-UEMUBXFH.mjs
+var DEFAULT_API_BASE_URL = "https://api.appilots.com";
+var APPILOTS_API_PATH_PREFIX = "/api/v1";
+function normalizeApiBaseUrl(configured) {
+  const raw = (configured ?? DEFAULT_API_BASE_URL).trim().replace(/\/+$/, "");
+  if (!raw) return `${DEFAULT_API_BASE_URL}${APPILOTS_API_PATH_PREFIX}`;
+  if (new RegExp(`${APPILOTS_API_PATH_PREFIX}(/|$)`).test(raw)) return raw;
+  return `${raw}${APPILOTS_API_PATH_PREFIX}`;
+}
+
 // src/services/api-client.ts
-var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_TIMEOUT_MS2 = 3e4;
 var DEFAULT_MAX_RETRIES = 2;
 var RETRY_BASE_DELAY_MS = 500;
+function describeNetworkError(url, err) {
+  let origin = url;
+  try {
+    origin = new URL(url).origin;
+  } catch {
+  }
+  const cause = err?.cause;
+  const code = typeof cause?.code === "string" ? cause.code : void 0;
+  const detail = code ?? stringifyUnknown(err);
+  return new Error(`Cannot reach Appilots server at ${origin} (${detail})`);
+}
+function errorCodeOf(payload) {
+  const error = payload?.error;
+  if (error && typeof error === "object") {
+    const { code } = error;
+    if (typeof code === "string" && code.trim()) return code;
+  }
+  return void 0;
+}
+function describeApiError(payload, fallback) {
+  const error = payload?.error;
+  if (typeof error === "string" && error.trim()) return error;
+  if (error && typeof error === "object") {
+    const { code, message: message2 } = error;
+    const text = typeof message2 === "string" && message2.trim() ? message2 : void 0;
+    const tag = typeof code === "string" && code.trim() ? code : void 0;
+    if (text && tag) return `${text} (${tag})`;
+    if (text) return text;
+    if (tag) return tag;
+  }
+  const message = payload?.message;
+  if (typeof message === "string" && message.trim()) return message;
+  return fallback;
+}
 var AppilotsAPIClient = class {
-  serverUrl;
+  /**
+   * `serverUrl` with the API's mount prefix resolved — every path below
+   * is relative to THIS, not to the configured origin.
+   *
+   * It used to be the raw `serverUrl` with `/api/v1` hardcoded into each
+   * path, which made the field mean something different here than in the
+   * SDK. Both read the same `.appilotsrc`: the SDK completes the prefix
+   * when it is missing, so `https://api.appilots.com/api/v1` is correct
+   * there — and here that same value produced
+   * `/api/v1/api/v1/cli/sync`, a 404 whose body reads `Route not found`.
+   * Sharing `normalizeApiBaseUrl` is what makes one file mean one thing:
+   * with or without the prefix now works in both.
+   */
+  baseUrl;
   apiKey;
   timeoutMs;
   maxRetries;
   constructor(config) {
-    this.serverUrl = config.serverUrl.replace(/\/$/, "");
+    this.baseUrl = normalizeApiBaseUrl(config.serverUrl);
     this.apiKey = config.apiKey;
-    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
     this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
   }
   /**
@@ -8273,7 +10456,7 @@ var AppilotsAPIClient = class {
         }
         return response;
       } catch (err) {
-        lastError = controller.signal.aborted ? new Error(`Request timed out after ${this.timeoutMs}ms: ${url}`) : err;
+        lastError = controller.signal.aborted ? new Error(`Request timed out after ${this.timeoutMs}ms: ${url}`) : describeNetworkError(url, err);
       } finally {
         clearTimeout(timer);
       }
@@ -8292,7 +10475,7 @@ var AppilotsAPIClient = class {
    */
   async sync(content, version, appVersion) {
     try {
-      const response = await this.request(`${this.serverUrl}/api/v1/cli/sync`, {
+      const response = await this.request(`${this.baseUrl}/cli/sync`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -8306,7 +10489,9 @@ var AppilotsAPIClient = class {
         return {
           success: false,
           unchanged: false,
-          error: errorData?.error || `HTTP ${response.status}: ${response.statusText}`
+          error: describeApiError(errorData, `HTTP ${response.status}: ${response.statusText}`),
+          errorCode: errorCodeOf(errorData),
+          errorStatus: response.status
         };
       }
       const json = await response.json();
@@ -8319,7 +10504,8 @@ var AppilotsAPIClient = class {
       return {
         success: false,
         unchanged: false,
-        error: error instanceof Error ? error.message : "Failed to sync with Appilots API"
+        error: error instanceof Error ? error.message : "Failed to sync with Appilots API",
+        errorStatus: 0
       };
     }
   }
@@ -8330,7 +10516,7 @@ var AppilotsAPIClient = class {
    */
   async status() {
     try {
-      const response = await this.request(`${this.serverUrl}/api/v1/cli/status`, {
+      const response = await this.request(`${this.baseUrl}/cli/status`, {
         method: "GET",
         headers: {
           Authorization: `Bearer ${this.apiKey}`
@@ -8339,7 +10525,7 @@ var AppilotsAPIClient = class {
       if (!response.ok) {
         const errorData = await response.json().catch(() => ({}));
         return {
-          error: errorData?.error || `HTTP ${response.status}: ${response.statusText}`
+          error: describeApiError(errorData, `HTTP ${response.status}: ${response.statusText}`)
         };
       }
       const json = await response.json();
@@ -8361,7 +10547,7 @@ var AppilotsAPIClient = class {
    */
   async evalRun(scenarios) {
     try {
-      const response = await this.request(`${this.serverUrl}/api/v1/cli/eval/run`, {
+      const response = await this.request(`${this.baseUrl}/cli/eval/run`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -8392,7 +10578,7 @@ var AppilotsAPIClient = class {
    */
   async health() {
     try {
-      const response = await this.request(`${this.serverUrl}/api/v1/health`, {
+      const response = await this.request(`${this.baseUrl}/health`, {
         method: "GET"
       });
       return response.ok;
@@ -8402,15 +10588,23 @@ var AppilotsAPIClient = class {
   }
 };
 
+// src/version.ts
+var CLI_VERSION = "0.10.0";
+
 exports.AppilotsAPIClient = AppilotsAPIClient;
+exports.CLI_VERSION = CLI_VERSION;
 exports.ComponentAnalyzer = ComponentAnalyzer;
 exports.DEFAULT_MANIFEST_FILENAME = DEFAULT_MANIFEST_FILENAME;
+exports.DEFAULT_WEB_SCREEN_PATTERNS = DEFAULT_WEB_SCREEN_PATTERNS;
 exports.FormAnalyzer = FormAnalyzer;
 exports.GenericPlatformAnalyzer = GenericPlatformAnalyzer;
 exports.MCPGenerator = MCPGenerator;
 exports.NavigationAnalyzer = NavigationAnalyzer;
 exports.ReactNativePlatformAnalyzer = ReactNativePlatformAnalyzer;
+exports.ReactWebPlatformAnalyzer = ReactWebPlatformAnalyzer;
 exports.ScreenAnalyzer = ScreenAnalyzer;
+exports.WebNavigationAnalyzer = WebNavigationAnalyzer;
+exports.WebScreenAnalyzer = WebScreenAnalyzer;
 exports.formatMetadataWarnings = formatMetadataWarnings;
 exports.getConfigPath = getConfigPath;
 exports.getEnvOverrides = getEnvOverrides;
@@ -8419,7 +10613,9 @@ exports.loadConfig = loadConfig;
 exports.loadManifest = loadManifest;
 exports.mergeManifestNavigation = mergeManifestNavigation;
 exports.mergeManifestScreens = mergeManifestScreens;
+exports.resolvePathToScreen = resolvePathToScreen;
 exports.saveConfig = saveConfig;
+exports.screenNameFromPath = screenNameFromPath;
 exports.validateConfig = validateConfig;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map