@appilots/cli 0.3.0 → 0.4.0

package/dist/cli/index.js

@@ -532,11 +532,11 @@ function initCommand() {
 
 // src/cli/commands/sync.ts
 var import_commander2 = require("commander");
-var import_promises4 = require("fs/promises");
+var import_promises5 = require("fs/promises");
 var import_node_path4 = require("path");
 
 // src/generators/MCPGenerator.ts
-var import_promises3 = require("fs/promises");
+var import_promises4 = require("fs/promises");
 var import_node_crypto = require("crypto");
 var import_node_path3 = __toESM(require("path"));
 
@@ -1955,7 +1955,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.isJSXAttribute(attr)) continue;
       const attrName = BabelTypes.isJSXIdentifier(attr.name) ? attr.name.name : null;
@@ -1970,8 +1970,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;
   }
   /**
@@ -2581,7 +2581,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";
@@ -2602,7 +2602,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);
@@ -2693,8 +2693,8 @@ var ComponentAnalyzer = class {
       });
       const components = [];
       (0, import_traverse6.default)(ast, {
-        JSXElement: (path7) => {
-          const component = this.extractComponentFromJSXElement(path7.node);
+        JSXElement: (path9) => {
+          const component = this.extractComponentFromJSXElement(path9.node);
           if (component) {
             components.push(component);
           }
@@ -2828,13 +2828,13 @@ var FormAnalyzer = class {
       this.inputElements = [];
       this.submitButtons = [];
       (0, import_traverse7.default)(ast, {
-        CallExpression: (path7) => {
-          this.extractStateVariables(path7.node);
+        CallExpression: (path9) => {
+          this.extractStateVariables(path9.node);
         }
       });
       (0, import_traverse7.default)(ast, {
-        JSXElement: (path7) => {
-          this.extractFormElements(path7.node);
+        JSXElement: (path9) => {
+          this.extractFormElements(path9.node);
         }
       });
       const validationRules = this.extractValidationRules(ast);
@@ -2934,8 +2934,8 @@ var FormAnalyzer = class {
   extractValidationRules(ast) {
     const rules = {};
     (0, import_traverse7.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;
@@ -2985,224 +2985,1719 @@ var FormAnalyzer = class {
         }
       }
     }
-    return fieldName && description ? { field: fieldName, description } : null;
+    return fieldName && description ? { field: fieldName, description } : null;
+  }
+  buildForms(filePath, validationRules) {
+    if (this.inputElements.length === 0) return [];
+    const fileName = path3.basename(filePath, path3.extname(filePath));
+    const formId = `${fileName}Form`.replace(/Screen$/, "").toLowerCase();
+    const fields = this.inputElements.map((input) => {
+      const fieldType = this.inferFieldType(input);
+      const required = this.isFieldRequired(input.varName, validationRules);
+      return {
+        name: input.appilotsId || input.varName || input.testID || "field",
+        label: input.label,
+        type: fieldType,
+        required,
+        placeholder: input.placeholder
+      };
+    });
+    const lastButton = this.submitButtons[this.submitButtons.length - 1];
+    const submitAction = lastButton?.handler;
+    return [
+      {
+        id: formId,
+        fields,
+        submitAction,
+        validationRules: Object.keys(validationRules).length > 0 ? validationRules : void 0
+      }
+    ];
+  }
+  inferFieldType(input) {
+    const lowerVarName = input.varName.toLowerCase();
+    const lowerLabel = input.label?.toLowerCase() || "";
+    const lowerPlaceholder = input.placeholder?.toLowerCase() || "";
+    const combined = `${lowerVarName} ${lowerLabel} ${lowerPlaceholder}`;
+    if (input.keyboardType === "email-address" || input.keyboardType === "email") {
+      return "email";
+    }
+    if (input.keyboardType === "phone-pad" || input.keyboardType === "numeric") {
+      return input.keyboardType === "numeric" ? "number" : "phone";
+    }
+    if (combined.includes("email")) return "email";
+    if (combined.includes("phone") || combined.includes("tel")) return "phone";
+    if (combined.includes("password")) return "text";
+    if (combined.includes("number") || combined.includes("numeric")) return "number";
+    if (combined.includes("date")) return "date";
+    if (combined.includes("toggle") || combined.includes("check")) return "toggle";
+    if (combined.includes("select") || combined.includes("choice")) return "select";
+    return "text";
+  }
+  isFieldRequired(fieldName, rules) {
+    const rule = rules[fieldName];
+    return rule !== void 0 && rule.includes("required");
+  }
+};
+
+// src/analyzers/ReactNativePlatformAnalyzer.ts
+var ReactNativePlatformAnalyzer = class {
+  platform = "react-native";
+  async analyze(config, options) {
+    const screenAnalyzer = new ScreenAnalyzer(config, {
+      strictScreens: options.strictScreens ?? true,
+      screenPatterns: options.screenPatterns
+    });
+    const navigationAnalyzer = new NavigationAnalyzer(config, {
+      navigationInclude: options.navigationInclude,
+      navigationExclude: options.navigationExclude
+    });
+    const componentAnalyzer = new ComponentAnalyzer(config);
+    const formAnalyzer = new FormAnalyzer(config);
+    console.log("[ReactNativePlatformAnalyzer] Running analyzers...");
+    const [screens, navigation] = await Promise.all([
+      screenAnalyzer.analyze(),
+      navigationAnalyzer.analyze()
+    ]);
+    console.log(
+      `[ReactNativePlatformAnalyzer] Screen and navigation analysis complete. Found ${screens.length} screens`
+    );
+    const screenFiles = await (0, import_fast_glob3.default)(config.include || ["**/*.tsx", "**/*.ts"], {
+      cwd: config.rootDir,
+      ignore: config.exclude || ["**/node_modules/**"]
+    });
+    console.log(
+      `[ReactNativePlatformAnalyzer] Analyzing components and forms from ${screenFiles.length} files...`
+    );
+    const enrichmentPromises = screenFiles.map(async (file) => {
+      const filePath = import_node_path.default.resolve(config.rootDir, file);
+      try {
+        const [components, forms] = await Promise.all([
+          componentAnalyzer.analyzeFile(filePath),
+          formAnalyzer.analyzeFile(filePath)
+        ]);
+        return { filePath, components, forms };
+      } catch (error2) {
+        console.warn(`[ReactNativePlatformAnalyzer] Failed to analyze ${file}:`, error2);
+        return { filePath, components: [], forms: [] };
+      }
+    });
+    const enrichmentResults = await Promise.all(enrichmentPromises);
+    const enrichmentMap = /* @__PURE__ */ new Map();
+    for (const result of enrichmentResults) {
+      enrichmentMap.set(result.filePath, {
+        components: result.components,
+        forms: result.forms
+      });
+    }
+    const enrichedScreens = screens.map((screen) => {
+      const enrichment = enrichmentMap.get(screen.filePath);
+      if (enrichment) {
+        const existingComponentNames = new Set(screen.components.map((c) => c.name));
+        const newComponents = enrichment.components.filter(
+          (c) => !existingComponentNames.has(c.name)
+        );
+        const mergedForms = screen.forms.map((form) => ({
+          ...form,
+          fields: [...form.fields]
+        }));
+        for (const newForm of enrichment.forms) {
+          const existingForm = mergedForms.find((form) => form.id === newForm.id) ?? this.findFormWithSharedFields(mergedForms, newForm);
+          if (existingForm) {
+            this.mergeForm(existingForm, newForm);
+          } else {
+            mergedForms.push({
+              ...newForm,
+              fields: [...newForm.fields],
+              submitAction: this.namedSubmitAction(newForm.submitAction)
+            });
+          }
+        }
+        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/analyzers/web/WebScreenAnalyzer.ts
+var import_promises2 = __toESM(require("fs/promises"));
+var import_path5 = __toESM(require("path"));
+var import_fast_glob4 = __toESM(require("fast-glob"));
+var import_traverse9 = __toESM(require("@babel/traverse"));
+var t10 = __toESM(require("@babel/types"));
+
+// 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";
+}
+
+// src/ast/jsx/names.ts
+var t8 = __toESM(require("@babel/types"));
+function getJsxElementName(openingElement) {
+  return getJsxName(openingElement.name);
+}
+function getJsxName(name) {
+  if (t8.isJSXIdentifier(name)) return name.name;
+  if (t8.isJSXNamespacedName(name)) return `${name.namespace.name}:${name.name.name}`;
+  if (t8.isJSXMemberExpression(name)) {
+    const objectName = getJsxName(name.object);
+    const propertyName = t8.isJSXIdentifier(name.property) ? name.property.name : null;
+    return objectName && propertyName ? `${objectName}.${propertyName}` : null;
+  }
+  return null;
+}
+
+// src/ast/navigation/web-calls.ts
+var import_traverse8 = __toESM(require("@babel/traverse"));
+var t9 = __toESM(require("@babel/types"));
+var ROUTERISH_OBJECTS = /^(router|history|navigation)$/;
+function staticRoutePath(node) {
+  if (!node) return void 0;
+  if (t9.isStringLiteral(node)) return node.value;
+  if (t9.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 (t9.isIdentifier(expr)) return expr.name;
+  if (t9.isMemberExpression(expr) && t9.isIdentifier(expr.property)) return expr.property.name;
+  return "param";
+}
+function extractWebNavigationCalls(ast) {
+  const calls = [];
+  const inspect = (node) => {
+    if (t9.isCallExpression(node)) {
+      if (t9.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 (t9.isNumericLiteral(first) || t9.isUnaryExpression(first) && first.operator === "-") {
+          calls.push({ method: "goBack" });
+        }
+        return;
+      }
+      if (t9.isMemberExpression(node.callee) && t9.isIdentifier(node.callee.object) && ROUTERISH_OBJECTS.test(node.callee.object.name) && t9.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 (t9.isAssignmentExpression(node) && t9.isMemberExpression(node.left) && t9.isIdentifier(node.left.property) && node.left.property.name === "href" && isLocationExpression(node.left.object) && t9.isStringLiteral(node.right) && node.right.value.startsWith("/")) {
+      calls.push({ method: "navigate", targetPath: node.right.value });
+    }
+  };
+  (0, import_traverse8.default)(ast, {
+    noScope: !t9.isFile(ast),
+    enter: (nodePath) => inspect(nodePath.node)
+  });
+  return calls;
+}
+function hasReplaceOption(arg) {
+  if (!arg || !t9.isObjectExpression(arg)) return false;
+  return arg.properties.some(
+    (prop) => t9.isObjectProperty(prop) && t9.isIdentifier(prop.key) && prop.key.name === "replace" && t9.isBooleanLiteral(prop.value) && prop.value.value === true
+  );
+}
+function isLocationExpression(node) {
+  if (t9.isIdentifier(node)) return node.name === "location";
+  return t9.isMemberExpression(node) && t9.isIdentifier(node.object) && node.object.name === "window" && t9.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 (0, import_fast_glob4.default)(include, { cwd: this.config.rootDir, ignore: exclude });
+    const patternMatches = await (0, import_fast_glob4.default)(this.screenPatterns, {
+      cwd: this.config.rootDir,
+      ignore: exclude
+    });
+    const patternSet = new Set(patternMatches.map((f) => import_path5.default.resolve(this.config.rootDir, f)));
+    const candidates = [];
+    for (const file of files) {
+      const filePath = import_path5.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 (error2) {
+        if (this.verbose) {
+          console.warn(
+            `[WebScreenAnalyzer] Failed to parse ${file}:`,
+            error2 instanceof Error ? error2.message : error2
+          );
+        }
+      }
+    }
+    return { candidates, analyzedFiles: files.length };
+  }
+  async analyzeFile(filePath) {
+    const source = await import_promises2.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 || import_path5.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;
+    (0, import_traverse9.default)(ast, {
+      CallExpression: (nodePath) => {
+        if (found) return;
+        if (isRegisterScreenCallee(nodePath.node.callee)) {
+          found = true;
+          nodePath.stop();
+        }
+      }
+    });
+    return found;
+  }
+  extractRegisterScreenMetadata(ast) {
+    let plain = null;
+    (0, import_traverse9.default)(ast, {
+      CallExpression: (nodePath) => {
+        if (!isRegisterScreenCallee(nodePath.node.callee)) return;
+        const arg = nodePath.node.arguments[0];
+        if (t10.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 = "";
+    (0, import_traverse9.default)(ast, {
+      ExportDefaultDeclaration: (nodePath) => {
+        const declaration = nodePath.node.declaration;
+        if (t10.isFunctionDeclaration(declaration) && declaration.id?.name) {
+          defaultName = declaration.id.name;
+        } else if (t10.isIdentifier(declaration)) {
+          defaultName = declaration.name;
+        }
+      },
+      ExportNamedDeclaration: (nodePath) => {
+        if (firstExported) return;
+        const declaration = nodePath.node.declaration;
+        if (t10.isFunctionDeclaration(declaration) && declaration.id && /^[A-Z]/.test(declaration.id.name)) {
+          firstExported = declaration.id.name;
+        } else if (t10.isVariableDeclaration(declaration)) {
+          for (const declarator of declaration.declarations) {
+            if (t10.isIdentifier(declarator.id) && /^[A-Z]/.test(declarator.id.name) && (t10.isArrowFunctionExpression(declarator.init) || t10.isFunctionExpression(declarator.init))) {
+              firstExported = declarator.id.name;
+              break;
+            }
+          }
+        }
+      }
+    });
+    return defaultName || firstExported;
+  }
+  extractComponents(ast) {
+    const components = [];
+    const seen = /* @__PURE__ */ new Set();
+    (0, import_traverse9.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();
+    (0, import_traverse9.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;
+    };
+    (0, import_traverse9.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);
+      }
+    });
+    (0, import_traverse9.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 (!t10.isJSXAttribute(attr) || !t10.isJSXIdentifier(attr.name)) continue;
+      const attrName = attr.name.name;
+      if (attrName === "required") {
+        if (attr.value === null) field.required = true;
+        else if (t10.isJSXExpressionContainer(attr.value) && t10.isBooleanLiteral(attr.value.expression)) {
+          field.required = attr.value.expression.value;
+        }
+      }
+      if ((attrName === "value" || attrName === "checked") && attr.value && t10.isJSXExpressionContainer(attr.value) && t10.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 (!t10.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])
+    );
+    (0, import_traverse9.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) => t10.isJSXAttribute(attr) && t10.isJSXIdentifier(attr.name) && attr.name.name === "onClick"
+    );
+    if (onClickAttr?.value && t10.isJSXExpressionContainer(onClickAttr.value)) {
+      const expr = onClickAttr.value.expression;
+      if (t10.isIdentifier(expr)) {
+        handlerName = expr.name;
+        action.handler = expr.name;
+      } else if (!t10.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) => t10.isJSXAttribute(candidate) && t10.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
+    );
+    if (!attr?.value || !t10.isJSXExpressionContainer(attr.value)) return void 0;
+    const expr = attr.value.expression;
+    if (t10.isIdentifier(expr)) return expr.name;
+    if (t10.isArrowFunctionExpression(expr) || t10.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);
+    }
+    (0, import_traverse9.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();
+    (0, import_traverse9.default)(ast, {
+      JSXExpressionContainer: (nodePath) => {
+        const expr = nodePath.node.expression;
+        if (!t10.isCallExpression(expr) || !t10.isMemberExpression(expr.callee) || !t10.isIdentifier(expr.callee.object) || !t10.isIdentifier(expr.callee.property) || expr.callee.property.name !== "map") {
+          return;
+        }
+        const callback = expr.arguments[0];
+        if (!t10.isArrowFunctionExpression(callback) && !t10.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 t10.isIdentifier(callee) && callee.name === "registerScreen" || t10.isMemberExpression(callee) && t10.isIdentifier(callee.property) && callee.property.name === "registerScreen";
+}
+function literalToPlain(node) {
+  if (t10.isStringLiteral(node) || t10.isNumericLiteral(node) || t10.isBooleanLiteral(node)) {
+    return node.value;
+  }
+  if (t10.isNullLiteral(node)) return null;
+  if (t10.isArrayExpression(node)) {
+    return node.elements.filter((el) => el !== null && t10.isExpression(el)).map((el) => literalToPlain(el)).filter((value) => value !== void 0);
+  }
+  if (t10.isObjectExpression(node)) {
+    const out = {};
+    for (const prop of node.properties) {
+      if (!t10.isObjectProperty(prop)) continue;
+      const key = t10.isIdentifier(prop.key) ? prop.key.name : t10.isStringLiteral(prop.key) ? prop.key.value : void 0;
+      if (!key || !t10.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 (t10.isJSXText(child)) {
+        const trimmed = child.value.replace(/\s+/g, " ").trim();
+        if (trimmed) parts.push(trimmed);
+      } else if (t10.isJSXExpressionContainer(child) && t10.isStringLiteral(child.expression)) {
+        parts.push(child.expression.value);
+      } else if (t10.isJSXElement(child)) {
+        walk(child.children);
+      }
+    }
+  };
+  walk(element.children);
+  const text = parts.join(" ").trim();
+  return text.length > 0 ? text : void 0;
+}
+function firstCalledFunctionName(node) {
+  if (t10.isIdentifier(node)) return node.name;
+  if (t10.isArrowFunctionExpression(node) || t10.isFunctionExpression(node)) {
+    return firstCalledFunctionName(node.body);
+  }
+  if (t10.isBlockStatement(node)) {
+    for (const statement of node.body) {
+      const handler = firstCalledFunctionName(statement);
+      if (handler) return handler;
+    }
+    return void 0;
+  }
+  if (t10.isExpressionStatement(node)) return firstCalledFunctionName(node.expression);
+  if (t10.isReturnStatement(node)) {
+    return node.argument ? firstCalledFunctionName(node.argument) : void 0;
+  }
+  if (t10.isAwaitExpression(node) || t10.isUnaryExpression(node)) {
+    return firstCalledFunctionName(node.argument);
+  }
+  if (t10.isCallExpression(node)) {
+    if (t10.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;
+  (0, import_traverse9.default)(body, {
+    noScope: true,
+    CallExpression: (nodePath) => {
+      const callee = nodePath.node.callee;
+      if (t10.isIdentifier(callee) && callee.name === "confirm") found = true;
+      if (t10.isMemberExpression(callee) && t10.isIdentifier(callee.object) && callee.object.name === "window" && t10.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) => t10.isJSXAttribute(candidate) && t10.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
+  );
+  if (!attr?.value || !t10.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 (t10.isIdentifier(firstParam)) names.add(firstParam.name);
+  if (t10.isObjectPattern(firstParam)) {
+    for (const prop of firstParam.properties) {
+      if (t10.isObjectProperty(prop) && t10.isIdentifier(prop.key) && t10.isIdentifier(prop.value)) {
+        names.add(prop.value.name);
+      }
+    }
+  }
+  return names;
+}
+function collectionDisplayFields(callback, itemNames) {
+  const fields = /* @__PURE__ */ new Set();
+  if (!callback.body) return [];
+  (0, import_traverse9.default)(callback.body, {
+    noScope: true,
+    MemberExpression: (nodePath) => {
+      const node = nodePath.node;
+      if (t10.isIdentifier(node.object) && itemNames.has(node.object.name) && t10.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;
+  (0, import_traverse9.default)(callback.body, {
+    noScope: true,
+    JSXAttribute: (nodePath) => {
+      const attr = nodePath.node;
+      if (!t10.isJSXIdentifier(attr.name) || attr.name.name !== "key") return;
+      if (!attr.value || !t10.isJSXExpressionContainer(attr.value)) return;
+      const expr = attr.value.expression;
+      if (t10.isMemberExpression(expr) && t10.isIdentifier(expr.object) && itemNames.has(expr.object.name) && t10.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 (t10.isJSXElement(node)) {
+      const name = getJsxElementName(node.openingElement);
+      if (name && tags.has(name)) found = true;
+      return;
+    }
+    if (t10.isBlockStatement(node)) {
+      for (const statement of node.body) {
+        if (t10.isReturnStatement(statement)) inspect(statement.argument);
+      }
+    }
+    if (t10.isParenthesizedExpression(node)) inspect(node.expression);
+    if (t10.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|plate|email|slug)$/i.test(field)) out.add(field);
+  }
+  return Array.from(out);
+}
+
+// src/analyzers/web/WebNavigationAnalyzer.ts
+var import_fs7 = require("fs");
+var import_path6 = __toESM(require("path"));
+var import_fast_glob5 = __toESM(require("fast-glob"));
+var import_traverse10 = __toESM(require("@babel/traverse"));
+var t11 = __toESM(require("@babel/types"));
+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 import_fs7.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 (error2) {
+        console.warn(`[WebNavigationAnalyzer] Failed to parse ${filePath}:`, error2);
+      }
+    }
+    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 (0, import_fast_glob5.default)(patterns, { cwd: this.config.rootDir, ignore });
+    return files.map((file) => import_path6.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 (t11.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) => t11.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 (t11.isJSXElement(child)) visitRoute(child, fullPath);
+      }
+    };
+    (0, import_traverse10.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 routes;
+  }
+  /** `element={<VehicleList/>}` or `Component={VehicleList}`. */
+  componentNameFromElementAttr(opening) {
+    for (const attr of opening.attributes) {
+      if (!t11.isJSXAttribute(attr) || !t11.isJSXIdentifier(attr.name)) continue;
+      if (attr.name.name === "element" && t11.isJSXExpressionContainer(attr.value)) {
+        const expr = attr.value.expression;
+        if (t11.isJSXElement(expr)) return getJsxElementName(expr.openingElement);
+      }
+      if (attr.name.name === "Component" && t11.isJSXExpressionContainer(attr.value)) {
+        if (t11.isIdentifier(attr.value.expression)) return attr.value.expression.name;
+      }
+    }
+    return null;
   }
-  buildForms(filePath, validationRules) {
-    if (this.inputElements.length === 0) return [];
-    const fileName = path3.basename(filePath, path3.extname(filePath));
-    const formId = `${fileName}Form`.replace(/Screen$/, "").toLowerCase();
-    const fields = this.inputElements.map((input) => {
-      const fieldType = this.inferFieldType(input);
-      const required = this.isFieldRequired(input.varName, validationRules);
-      return {
-        name: input.appilotsId || input.varName || input.testID || "field",
-        label: input.label,
-        type: fieldType,
-        required,
-        placeholder: input.placeholder
-      };
-    });
-    const lastButton = this.submitButtons[this.submitButtons.length - 1];
-    const submitAction = lastButton?.handler;
-    return [
-      {
-        id: formId,
-        fields,
-        submitAction,
-        validationRules: Object.keys(validationRules).length > 0 ? validationRules : void 0
+  // ── createBrowserRouter([...]) / useRoutes([...]) style ──────────
+  extractObjectRoutes(ast) {
+    const routes = [];
+    const ROUTER_FACTORIES = /* @__PURE__ */ new Set([
+      "createBrowserRouter",
+      "createHashRouter",
+      "createMemoryRouter",
+      "useRoutes"
+    ]);
+    (0, import_traverse10.default)(ast, {
+      CallExpression: (nodePath) => {
+        const callee = nodePath.node.callee;
+        if (!t11.isIdentifier(callee) || !ROUTER_FACTORIES.has(callee.name)) return;
+        const first = nodePath.node.arguments[0];
+        if (!t11.isArrayExpression(first)) return;
+        this.visitRouteObjects(first, "", routes);
       }
-    ];
+    });
+    return routes;
   }
-  inferFieldType(input) {
-    const lowerVarName = input.varName.toLowerCase();
-    const lowerLabel = input.label?.toLowerCase() || "";
-    const lowerPlaceholder = input.placeholder?.toLowerCase() || "";
-    const combined = `${lowerVarName} ${lowerLabel} ${lowerPlaceholder}`;
-    if (input.keyboardType === "email-address" || input.keyboardType === "email") {
-      return "email";
+  visitRouteObjects(arr, parentPath, out) {
+    for (const element of arr.elements) {
+      if (!t11.isObjectExpression(element)) continue;
+      let segment;
+      let isIndex = false;
+      let componentName;
+      let children;
+      for (const prop of element.properties) {
+        if (!t11.isObjectProperty(prop) || !t11.isIdentifier(prop.key)) continue;
+        const key = prop.key.name;
+        if (key === "path" && t11.isStringLiteral(prop.value)) segment = prop.value.value;
+        if (key === "index" && t11.isBooleanLiteral(prop.value)) isIndex = prop.value.value;
+        if (key === "element" && t11.isJSXElement(prop.value)) {
+          componentName = getJsxElementName(prop.value.openingElement) ?? void 0;
+        }
+        if (key === "Component" && t11.isIdentifier(prop.value)) componentName = prop.value.name;
+        if (key === "children" && t11.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);
+    }
+  }
+  // ── 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}`);
+  }
+  normalizePath(p) {
+    const cleaned = `/${p}`.replace(/\/+/g, "/");
+    return cleaned.length > 1 ? cleaned.replace(/\/$/, "") : cleaned;
+  }
+  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 });
     }
-    if (input.keyboardType === "phone-pad" || input.keyboardType === "numeric") {
-      return input.keyboardType === "numeric" ? "number" : "phone";
+    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);
+      }
     }
-    if (combined.includes("email")) return "email";
-    if (combined.includes("phone") || combined.includes("tel")) return "phone";
-    if (combined.includes("password")) return "text";
-    if (combined.includes("number") || combined.includes("numeric")) return "number";
-    if (combined.includes("date")) return "date";
-    if (combined.includes("toggle") || combined.includes("check")) return "toggle";
-    if (combined.includes("select") || combined.includes("choice")) return "select";
-    return "text";
+    return Array.from(byPath.values());
   }
-  isFieldRequired(fieldName, rules) {
-    const rule = rules[fieldName];
-    return rule !== void 0 && rule.includes("required");
+  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/ReactNativePlatformAnalyzer.ts
-var ReactNativePlatformAnalyzer = class {
-  platform = "react-native";
+// src/analyzers/web/ReactWebPlatformAnalyzer.ts
+var ReactWebPlatformAnalyzer = class {
+  platform = "web";
   async analyze(config, options) {
-    const screenAnalyzer = new ScreenAnalyzer(config, {
-      strictScreens: options.strictScreens ?? true,
+    const screenAnalyzer = new WebScreenAnalyzer(config, {
       screenPatterns: options.screenPatterns
     });
-    const navigationAnalyzer = new NavigationAnalyzer(config, {
+    const navigationAnalyzer = new WebNavigationAnalyzer(config, {
       navigationInclude: options.navigationInclude,
       navigationExclude: options.navigationExclude
     });
-    const componentAnalyzer = new ComponentAnalyzer(config);
-    const formAnalyzer = new FormAnalyzer(config);
-    console.log("[ReactNativePlatformAnalyzer] Running analyzers...");
-    const [screens, navigation] = await Promise.all([
+    console.log("[ReactWebPlatformAnalyzer] Running analyzers...");
+    const [screenAnalysis, navigationResult] = await Promise.all([
       screenAnalyzer.analyze(),
       navigationAnalyzer.analyze()
     ]);
-    console.log(
-      `[ReactNativePlatformAnalyzer] Screen and navigation analysis complete. Found ${screens.length} screens`
+    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)
     );
-    const screenFiles = await (0, import_fast_glob3.default)(config.include || ["**/*.tsx", "**/*.ts"], {
-      cwd: config.rootDir,
-      ignore: config.exclude || ["**/node_modules/**"]
-    });
     console.log(
-      `[ReactNativePlatformAnalyzer] Analyzing components and forms from ${screenFiles.length} files...`
+      `[ReactWebPlatformAnalyzer] Screen and navigation analysis complete. Found ${screens.length} screens, ${navigationResult.routes.length} routes`
     );
-    const enrichmentPromises = screenFiles.map(async (file) => {
-      const filePath = import_node_path.default.resolve(config.rootDir, file);
-      try {
-        const [components, forms] = await Promise.all([
-          componentAnalyzer.analyzeFile(filePath),
-          formAnalyzer.analyzeFile(filePath)
-        ]);
-        return { filePath, components, forms };
-      } catch (error2) {
-        console.warn(`[ReactNativePlatformAnalyzer] Failed to analyze ${file}:`, error2);
-        return { filePath, components: [], forms: [] };
-      }
-    });
-    const enrichmentResults = await Promise.all(enrichmentPromises);
-    const enrichmentMap = /* @__PURE__ */ new Map();
-    for (const result of enrichmentResults) {
-      enrichmentMap.set(result.filePath, {
-        components: result.components,
-        forms: result.forms
-      });
-    }
-    const enrichedScreens = screens.map((screen) => {
-      const enrichment = enrichmentMap.get(screen.filePath);
-      if (enrichment) {
-        const existingComponentNames = new Set(screen.components.map((c) => c.name));
-        const newComponents = enrichment.components.filter(
-          (c) => !existingComponentNames.has(c.name)
-        );
-        const mergedForms = screen.forms.map((form) => ({
-          ...form,
-          fields: [...form.fields]
-        }));
-        for (const newForm of enrichment.forms) {
-          const existingForm = mergedForms.find((form) => form.id === newForm.id) ?? this.findFormWithSharedFields(mergedForms, newForm);
-          if (existingForm) {
-            this.mergeForm(existingForm, newForm);
-          } else {
-            mergedForms.push({
-              ...newForm,
-              fields: [...newForm.fields],
-              submitAction: this.namedSubmitAction(newForm.submitAction)
-            });
-          }
-        }
-        return {
-          ...screen,
-          components: [...screen.components, ...newComponents],
-          forms: mergedForms
-        };
-      }
-      return screen;
-    });
     return {
-      screens: enrichedScreens,
-      navigation,
-      analyzedFiles: screenFiles.length,
-      ...screenAnalyzer.screensFilteredOut > 0 ? { screensFilteredOut: screenAnalyzer.screensFilteredOut } : {}
+      screens,
+      navigation: navigationResult.graph,
+      analyzedFiles: screenAnalysis.analyzedFiles,
+      ...screensFilteredOut > 0 ? { 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;
+  isScreen(candidate, routeScreenNames) {
+    return candidate.hasRegisterScreen || candidate.matchesScreenPattern || routeScreenNames.has(candidate.descriptor.name);
   }
-  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;
+  /** 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)) } : {}
+      };
     });
-  }
-  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
+      ...screen,
+      navigationTargets,
+      actions,
+      ...collections ? { collections } : {}
     };
   }
 };
 
 // src/manifest/loadManifest.ts
-var import_promises2 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 var import_node_path2 = __toESM(require("path"));
 
 // ../../node_modules/zod/v3/external.js
@@ -3410,8 +4905,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":
@@ -3683,8 +5178,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
@@ -3800,11 +5295,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() {
@@ -7246,7 +8741,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../shared/dist/chunk-XLOYG3DH.mjs
+// ../shared/dist/chunk-MSOZJNXB.mjs
 var locatorSourceSchema = external_exports.enum([
   "appilotsId",
   "testID",
@@ -7431,7 +8926,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(),
@@ -7478,6 +8985,41 @@ var loginSchema = external_exports.object({
 var registerSchema = loginSchema.extend({
   name: external_exports.string().min(2, "Name must be at least 2 characters").max(100)
 });
+var updateMeSchema = 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"
+});
+var changePasswordSchema = 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"));
+var mfaVerifySchema = external_exports.object({
+  code: totpCodeSchema
+});
+var mfaChallengeSchema = 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"]
+});
+var mfaDisableSchema = 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"]
+});
+var mfaRegenerateRecoveryCodesSchema = external_exports.object({
+  password: external_exports.string().min(1, "Password is required"),
+  code: totpCodeSchema
+});
 var createProjectSchema = external_exports.object({
   name: external_exports.string().min(1).max(100),
   description: external_exports.string().max(500).optional(),
@@ -8141,6 +9683,18 @@ var sandboxRunRequestSchema = external_exports.object({
    */
   isRecoveryHop: external_exports.boolean().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(),
@@ -8179,7 +9733,16 @@ var sandboxRunResponseSchema = 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()
 });
 var saveSandboxTestSchema = external_exports.object({
   name: external_exports.string().min(1).max(120),
@@ -8401,7 +9964,7 @@ async function loadManifest(rootDir, manifestPath) {
   const resolvedPath = import_node_path2.default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
   let raw;
   try {
-    raw = await (0, import_promises2.readFile)(resolvedPath, "utf-8");
+    raw = await (0, import_promises3.readFile)(resolvedPath, "utf-8");
   } catch (error2) {
     if (error2?.code === "ENOENT") {
       return { manifest: null, resolvedPath };
@@ -8468,19 +10031,22 @@ 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 */
   async generate() {
     console.log("[MCPGenerator] Starting generation...");
     const outputDir = this.options.outputDir || ".appilots";
-    await (0, import_promises3.mkdir)(outputDir, { recursive: true });
+    await (0, import_promises4.mkdir)(outputDir, { recursive: true });
     console.log(`[MCPGenerator] Output directory ensured: ${outputDir}`);
     console.log(`[MCPGenerator] Running "${this.platformAnalyzer.platform}" platform analyzer...`);
     const analyzed = await this.platformAnalyzer.analyze(this.analyzerConfig, {
@@ -8530,10 +10096,10 @@ var MCPGenerator = class _MCPGenerator {
       outputDir,
       `mcp-document.${this.options.format}`
     );
-    await (0, import_promises3.writeFile)(filePath, serialized, "utf-8");
+    await (0, import_promises4.writeFile)(filePath, serialized, "utf-8");
     console.log(`[MCPGenerator] Document written to: ${filePath}`);
     const checksumFilePath = import_node_path3.default.resolve(outputDir, ".appilots-checksum");
-    await (0, import_promises3.writeFile)(checksumFilePath, checksum, "utf-8");
+    await (0, import_promises4.writeFile)(checksumFilePath, checksum, "utf-8");
     console.log(`[MCPGenerator] Checksum written to: ${checksumFilePath}`);
     console.log("[MCPGenerator] Generation complete!");
     return {
@@ -8554,7 +10120,7 @@ var MCPGenerator = class _MCPGenerator {
   static async readPreviousChecksum(outputDir) {
     const checksumFilePath = import_node_path3.default.resolve(outputDir, ".appilots-checksum");
     try {
-      const content = await (0, import_promises3.readFile)(checksumFilePath, "utf-8");
+      const content = await (0, import_promises4.readFile)(checksumFilePath, "utf-8");
       return content.trim() || null;
     } catch {
       return null;
@@ -8572,7 +10138,7 @@ var MCPGenerator = class _MCPGenerator {
   async getProjectInfo() {
     try {
       const packageJsonPath = import_node_path3.default.resolve(this.analyzerConfig.rootDir, "package.json");
-      const packageJsonContent = await (0, import_promises3.readFile)(packageJsonPath, "utf-8");
+      const packageJsonContent = await (0, import_promises4.readFile)(packageJsonPath, "utf-8");
       const packageJson = JSON.parse(packageJsonContent);
       return {
         name: packageJson.name || "Unknown Project",
@@ -8678,7 +10244,7 @@ function syncCommand() {
       let previousChecksum = "";
       try {
         const checksumPath = (0, import_node_path4.join)(outputDir, ".appilots-checksum");
-        previousChecksum = (await (0, import_promises4.readFile)(checksumPath, "utf-8")).trim();
+        previousChecksum = (await (0, import_promises5.readFile)(checksumPath, "utf-8")).trim();
       } catch {
       }
       let spinner = createSpinner("Analyzing project...");
@@ -8799,7 +10365,12 @@ function watchCommand() {
         include: config.include,
         exclude: config.exclude,
         navigationInclude: config.navigationInclude,
-        navigationExclude: config.navigationExclude
+        navigationExclude: config.navigationExclude,
+        // Same analyzer selection `generate` and `sync` already do —
+        // without these, watching a non-`react-native` project would
+        // silently run the RN analyzers and ignore the manifest.
+        platform: config.platform,
+        manifestPath: config.manifestPath
       };
       const generator = new MCPGenerator(generatorConfig);
       const initialOutput = await generator.generate();
@@ -8978,12 +10549,12 @@ function statusCommand() {
 
 // src/cli/commands/eval.ts
 var import_commander6 = require("commander");
-var import_fs9 = require("fs");
-var import_path7 = require("path");
+var import_fs10 = require("fs");
+var import_path9 = require("path");
 
 // src/eval/scenario-loader.ts
-var import_fs7 = require("fs");
-var import_path5 = require("path");
+var import_fs8 = require("fs");
+var import_path7 = require("path");
 function validateScenarioShape(raw) {
   if (!raw || typeof raw !== "object") return "scenario must be a JSON object";
   const s = raw;
@@ -9003,15 +10574,15 @@ function loadScenarios(dir) {
   const errors = [];
   let files;
   try {
-    files = (0, import_fs7.readdirSync)(dir).filter((f) => f.endsWith(".json")).sort();
+    files = (0, import_fs8.readdirSync)(dir).filter((f) => f.endsWith(".json")).sort();
   } catch {
     return { scenarios, errors };
   }
   for (const file of files) {
-    const full = (0, import_path5.join)(dir, file);
+    const full = (0, import_path7.join)(dir, file);
     let raw;
     try {
-      raw = JSON.parse((0, import_fs7.readFileSync)(full, "utf-8"));
+      raw = JSON.parse((0, import_fs8.readFileSync)(full, "utf-8"));
     } catch (err) {
       errors.push({ file, error: `invalid JSON: ${err instanceof Error ? err.message : String(err)}` });
       continue;
@@ -9167,13 +10738,13 @@ function matchActions(expected, actual, reply = "") {
 }
 
 // src/eval/baseline.ts
-var import_fs8 = require("fs");
-var import_path6 = require("path");
+var import_fs9 = require("fs");
+var import_path8 = require("path");
 var EMPTY_BASELINE = { generatedAt: null, gitSha: null, perScenario: {} };
-function loadBaseline(path7) {
-  if (!(0, import_fs8.existsSync)(path7)) return { ...EMPTY_BASELINE, perScenario: {} };
+function loadBaseline(path9) {
+  if (!(0, import_fs9.existsSync)(path9)) return { ...EMPTY_BASELINE, perScenario: {} };
   try {
-    const raw = JSON.parse((0, import_fs8.readFileSync)(path7, "utf-8"));
+    const raw = JSON.parse((0, import_fs9.readFileSync)(path9, "utf-8"));
     return {
       generatedAt: raw.generatedAt ?? null,
       gitSha: raw.gitSha ?? null,
@@ -9183,9 +10754,9 @@ function loadBaseline(path7) {
     return { ...EMPTY_BASELINE, perScenario: {} };
   }
 }
-function saveBaseline(path7, baseline) {
-  (0, import_fs8.mkdirSync)((0, import_path6.dirname)(path7), { recursive: true });
-  (0, import_fs8.writeFileSync)(path7, `${JSON.stringify(baseline, null, 2)}
+function saveBaseline(path9, baseline) {
+  (0, import_fs9.mkdirSync)((0, import_path8.dirname)(path9), { recursive: true });
+  (0, import_fs9.writeFileSync)(path9, `${JSON.stringify(baseline, null, 2)}
 `, "utf-8");
 }
 function buildBaseline(outcomes, meta) {
@@ -9283,14 +10854,14 @@ function evalCommand() {
       banner();
       const loaded = loadConfig();
       const outputDir = loaded?.outputDir || ".appilots";
-      const scenariosDir = options.dir || loaded?.eval?.scenariosDir || (0, import_path7.join)(outputDir, "scenarios");
+      const scenariosDir = options.dir || loaded?.eval?.scenariosDir || (0, import_path9.join)(outputDir, "scenarios");
       if (options.init) {
-        (0, import_fs9.mkdirSync)(scenariosDir, { recursive: true });
-        const examplePath = (0, import_path7.join)(scenariosDir, "example.json");
-        if ((0, import_fs9.existsSync)(examplePath) && !options.force) {
+        (0, import_fs10.mkdirSync)(scenariosDir, { recursive: true });
+        const examplePath = (0, import_path9.join)(scenariosDir, "example.json");
+        if ((0, import_fs10.existsSync)(examplePath) && !options.force) {
           warn(`${examplePath} already exists \u2014 pass --force to overwrite`);
         } else {
-          (0, import_fs9.writeFileSync)(examplePath, `${JSON.stringify(EXAMPLE_SCENARIO, null, 2)}
+          (0, import_fs10.writeFileSync)(examplePath, `${JSON.stringify(EXAMPLE_SCENARIO, null, 2)}
 `, "utf-8");
           success(`Wrote example scenario to ${examplePath}`);
         }
@@ -9316,7 +10887,7 @@ function evalCommand() {
         ...options.projectId ? { projectId: options.projectId } : {},
         ...options.server ? { serverUrl: options.server } : {}
       };
-      const baselinePath = options.baseline || loaded?.eval?.baselinePath || (0, import_path7.join)(outputDir, "eval-baseline.json");
+      const baselinePath = options.baseline || loaded?.eval?.baselinePath || (0, import_path9.join)(outputDir, "eval-baseline.json");
       const minPassRate = parseRate(
         options.minPassRate,
         loaded?.eval?.minPassRate ?? DEFAULT_MIN_PASS_RATE,