@appilots/cli 0.3.0 → 0.4.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import fs, { readFile, mkdir, writeFile } from 'fs/promises';
-import * as path6 from 'path';
-import path6__default, { join, resolve } from 'path';
+import * as path8 from 'path';
+import path8__default, { join, resolve } from 'path';
 import traverse4 from '@babel/traverse';
 import * as BabelTypes from '@babel/types';
 import glob from 'fast-glob';
@@ -392,12 +392,12 @@ var ScreenAnalyzer = class {
         cwd: this.config.rootDir,
         ignore: exclude
       });
-      screenPatternFiles = new Set(matched.map((f) => path6__default.resolve(this.config.rootDir, f)));
+      screenPatternFiles = new Set(matched.map((f) => path8__default.resolve(this.config.rootDir, f)));
     }
     const screens = [];
     this.screensFilteredOut = 0;
     for (const file of files) {
-      const filePath = path6__default.resolve(this.config.rootDir, file);
+      const filePath = path8__default.resolve(this.config.rootDir, file);
       try {
         const descriptor = await this.analyzeFile(filePath);
         if (!descriptor) continue;
@@ -1186,7 +1186,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;
@@ -1201,8 +1201,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;
   }
   /**
@@ -1546,7 +1546,7 @@ var ScreenAnalyzer = class {
    * E.g., /src/screens/ItemListScreen.tsx -> ItemListScreen
    */
   extractScreenName(filePath) {
-    const basename2 = path6__default.basename(filePath);
+    const basename2 = path8__default.basename(filePath);
     return basename2.replace(/\.(tsx?|jsx?)$/, "");
   }
 };
@@ -1601,7 +1601,7 @@ var NavigationAnalyzer = class {
       cwd: this.config.rootDir,
       ignore: excludePatterns
     });
-    return files.map((file) => path6__default.join(this.config.rootDir, file));
+    return files.map((file) => path8__default.join(this.config.rootDir, file));
   }
   /** Parse navigator definitions from a file */
   parseNavigators(content, filePath) {
@@ -1804,7 +1804,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";
@@ -1825,7 +1825,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);
@@ -1910,8 +1910,8 @@ var ComponentAnalyzer = class {
       });
       const components = [];
       traverse4(ast, {
-        JSXElement: (path7) => {
-          const component = this.extractComponentFromJSXElement(path7.node);
+        JSXElement: (path9) => {
+          const component = this.extractComponentFromJSXElement(path9.node);
           if (component) {
             components.push(component);
           }
@@ -2038,13 +2038,13 @@ var FormAnalyzer = class {
       this.inputElements = [];
       this.submitButtons = [];
       traverse4(ast, {
-        CallExpression: (path7) => {
-          this.extractStateVariables(path7.node);
+        CallExpression: (path9) => {
+          this.extractStateVariables(path9.node);
         }
       });
       traverse4(ast, {
-        JSXElement: (path7) => {
-          this.extractFormElements(path7.node);
+        JSXElement: (path9) => {
+          this.extractFormElements(path9.node);
         }
       });
       const validationRules = this.extractValidationRules(ast);
@@ -2144,8 +2144,8 @@ var FormAnalyzer = class {
   extractValidationRules(ast) {
     const rules = {};
     traverse4(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;
@@ -2199,7 +2199,7 @@ var FormAnalyzer = class {
   }
   buildForms(filePath, validationRules) {
     if (this.inputElements.length === 0) return [];
-    const fileName = path6.basename(filePath, path6.extname(filePath));
+    const fileName = path8.basename(filePath, path8.extname(filePath));
     const formId = `${fileName}Form`.replace(/Screen$/, "").toLowerCase();
     const fields = this.inputElements.map((input) => {
       const fieldType = this.inferFieldType(input);
@@ -2277,7 +2277,7 @@ var ReactNativePlatformAnalyzer = class {
       `[ReactNativePlatformAnalyzer] Analyzing components and forms from ${screenFiles.length} files...`
     );
     const enrichmentPromises = screenFiles.map(async (file) => {
-      const filePath = path6__default.resolve(config.rootDir, file);
+      const filePath = path8__default.resolve(config.rootDir, file);
       try {
         const [components, forms] = await Promise.all([
           componentAnalyzer.analyzeFile(filePath),
@@ -2409,6 +2409,1480 @@ var GenericPlatformAnalyzer = class {
   }
 };
 
+// src/ast/jsx/web/classify.ts
+var VIEW_TAGS = /* @__PURE__ */ new Set([
+  "div",
+  "span",
+  "section",
+  "main",
+  "article",
+  "aside",
+  "header",
+  "footer",
+  "nav",
+  "fieldset",
+  "form",
+  "p"
+]);
+var LIST_TAGS = /* @__PURE__ */ new Set(["ul", "ol", "dl", "table", "tbody"]);
+var BUTTON_TAGS = /* @__PURE__ */ new Set(["button"]);
+var INPUT_TAGS = /* @__PURE__ */ new Set(["input", "textarea"]);
+var MODAL_TAGS = /* @__PURE__ */ new Set(["dialog"]);
+var BUTTON_COMPONENTS2 = /* @__PURE__ */ new Set(["Button", "IconButton", "Link", "NavLink"]);
+var INPUT_COMPONENTS2 = /* @__PURE__ */ new Set(["Input", "TextField", "TextArea", "Textarea"]);
+var LIST_COMPONENTS2 = /* @__PURE__ */ new Set(["List", "Table", "DataGrid", "DataTable"]);
+var MODAL_COMPONENTS2 = /* @__PURE__ */ new Set(["Modal", "Dialog", "Drawer", "Popover", "BottomSheet"]);
+var ARIA_ROLE_TO_SEMANTIC = {
+  button: "button",
+  link: "button",
+  tab: "button",
+  menuitem: "button",
+  textbox: "input",
+  searchbox: "input",
+  spinbutton: "input",
+  listbox: "select",
+  combobox: "select",
+  radiogroup: "select",
+  radio: "select",
+  option: "select",
+  checkbox: "toggle",
+  switch: "toggle",
+  dialog: "modal",
+  alertdialog: "modal",
+  list: "list",
+  table: "list",
+  grid: "list",
+  form: "view"
+};
+var INPUT_TYPE_TO_SEMANTIC = {
+  checkbox: "toggle",
+  radio: "select",
+  date: "date",
+  "datetime-local": "date",
+  month: "date",
+  week: "date",
+  time: "date",
+  submit: "button",
+  button: "button",
+  reset: "button",
+  image: "button",
+  hidden: "custom",
+  range: "input",
+  file: "input",
+  color: "input"
+};
+function classifyWebJsxComponent(name, element) {
+  if (element) {
+    const role = getStringAttr(element, "role");
+    if (role && ARIA_ROLE_TO_SEMANTIC[role]) return ARIA_ROLE_TO_SEMANTIC[role];
+  }
+  if (/^[a-z]/.test(name)) {
+    if (name === "input") {
+      const type = element ? getStringAttr(element, "type") : void 0;
+      if (type && INPUT_TYPE_TO_SEMANTIC[type]) return INPUT_TYPE_TO_SEMANTIC[type];
+      return "input";
+    }
+    if (INPUT_TAGS.has(name)) return "input";
+    if (name === "select") return "select";
+    if (BUTTON_TAGS.has(name)) return "button";
+    if (name === "a") {
+      if (element && (hasJsxAttribute(element, "href") || hasJsxAttribute(element, "onClick"))) {
+        return "button";
+      }
+      return "view";
+    }
+    if (LIST_TAGS.has(name)) return "list";
+    if (MODAL_TAGS.has(name)) return "modal";
+    if (VIEW_TAGS.has(name)) return "view";
+    return "custom";
+  }
+  if (LIST_COMPONENTS2.has(name)) return "list";
+  if (MODAL_COMPONENTS2.has(name)) return "modal";
+  if (/date/i.test(name)) return "date";
+  if (/(select|picker|dropdown|radio)/i.test(name)) return "select";
+  if (/(checkbox|switch|toggle)/i.test(name)) return "toggle";
+  if (INPUT_COMPONENTS2.has(name)) return "input";
+  if (BUTTON_COMPONENTS2.has(name)) return "button";
+  if (element) {
+    const hasOptions = hasJsxAttribute(element, "options");
+    const hasValue = hasJsxAttribute(element, "value");
+    const hasChecked = hasJsxAttribute(element, "checked") || hasJsxAttribute(element, "selected");
+    const hasOnChange = hasJsxAttribute(element, "onChange") || hasJsxAttribute(element, "onValueChange");
+    const hasOnClick = hasJsxAttribute(element, "onClick");
+    if (hasOptions && (hasValue || hasOnChange)) return "select";
+    if (hasChecked && hasOnChange) return "toggle";
+    if (hasOnChange && (hasJsxAttribute(element, "label") || hasJsxAttribute(element, "placeholder"))) {
+      return "input";
+    }
+    if (hasOnClick) return "button";
+    if (getStringAttr(element, "open") || getExpressionIdentifierAttr(element, "open") || getExpressionIdentifierAttr(element, "isOpen")) {
+      return "modal";
+    }
+  }
+  return "custom";
+}
+function getJsxElementName(openingElement) {
+  return getJsxName(openingElement.name);
+}
+function getJsxName(name) {
+  if (BabelTypes.isJSXIdentifier(name)) return name.name;
+  if (BabelTypes.isJSXNamespacedName(name)) return `${name.namespace.name}:${name.name.name}`;
+  if (BabelTypes.isJSXMemberExpression(name)) {
+    const objectName = getJsxName(name.object);
+    const propertyName = BabelTypes.isJSXIdentifier(name.property) ? name.property.name : null;
+    return objectName && propertyName ? `${objectName}.${propertyName}` : null;
+  }
+  return null;
+}
+var ROUTERISH_OBJECTS = /^(router|history|navigation)$/;
+function staticRoutePath(node) {
+  if (!node) return void 0;
+  if (BabelTypes.isStringLiteral(node)) return node.value;
+  if (BabelTypes.isTemplateLiteral(node)) {
+    let path9 = "";
+    node.quasis.forEach((quasi, index) => {
+      path9 += quasi.value.cooked ?? quasi.value.raw;
+      const expr = node.expressions[index];
+      if (expr) path9 += `:${paramNameOf(expr)}`;
+    });
+    return path9;
+  }
+  return void 0;
+}
+function paramNameOf(expr) {
+  if (BabelTypes.isIdentifier(expr)) return expr.name;
+  if (BabelTypes.isMemberExpression(expr) && BabelTypes.isIdentifier(expr.property)) return expr.property.name;
+  return "param";
+}
+function extractWebNavigationCalls(ast) {
+  const calls = [];
+  const inspect = (node) => {
+    if (BabelTypes.isCallExpression(node)) {
+      if (BabelTypes.isIdentifier(node.callee) && node.callee.name === "navigate") {
+        const first = node.arguments[0];
+        const targetPath = staticRoutePath(first);
+        if (targetPath !== void 0) {
+          calls.push({
+            method: hasReplaceOption(node.arguments[1]) ? "replace" : "navigate",
+            targetPath
+          });
+        } else if (BabelTypes.isNumericLiteral(first) || BabelTypes.isUnaryExpression(first) && first.operator === "-") {
+          calls.push({ method: "goBack" });
+        }
+        return;
+      }
+      if (BabelTypes.isMemberExpression(node.callee) && BabelTypes.isIdentifier(node.callee.object) && ROUTERISH_OBJECTS.test(node.callee.object.name) && BabelTypes.isIdentifier(node.callee.property)) {
+        const method = node.callee.property.name;
+        const targetPath = staticRoutePath(node.arguments[0]);
+        if ((method === "push" || method === "navigate") && targetPath !== void 0) {
+          calls.push({ method: "navigate", targetPath });
+        } else if (method === "replace" && targetPath !== void 0) {
+          calls.push({ method: "replace", targetPath });
+        } else if (method === "back" || method === "goBack") {
+          calls.push({ method: "goBack" });
+        }
+      }
+      return;
+    }
+    if (BabelTypes.isAssignmentExpression(node) && BabelTypes.isMemberExpression(node.left) && BabelTypes.isIdentifier(node.left.property) && node.left.property.name === "href" && isLocationExpression(node.left.object) && BabelTypes.isStringLiteral(node.right) && node.right.value.startsWith("/")) {
+      calls.push({ method: "navigate", targetPath: node.right.value });
+    }
+  };
+  traverse4(ast, {
+    noScope: !BabelTypes.isFile(ast),
+    enter: (nodePath) => inspect(nodePath.node)
+  });
+  return calls;
+}
+function hasReplaceOption(arg) {
+  if (!arg || !BabelTypes.isObjectExpression(arg)) return false;
+  return arg.properties.some(
+    (prop) => BabelTypes.isObjectProperty(prop) && BabelTypes.isIdentifier(prop.key) && prop.key.name === "replace" && BabelTypes.isBooleanLiteral(prop.value) && prop.value.value === true
+  );
+}
+function isLocationExpression(node) {
+  if (BabelTypes.isIdentifier(node)) return node.name === "location";
+  return BabelTypes.isMemberExpression(node) && BabelTypes.isIdentifier(node.object) && node.object.name === "window" && BabelTypes.isIdentifier(node.property) && node.property.name === "location";
+}
+
+// src/analyzers/web/WebScreenAnalyzer.ts
+var DEFAULT_WEB_SCREEN_PATTERNS = [
+  "**/pages/**/*.{ts,tsx,js,jsx}",
+  "**/routes/**/*.{ts,tsx,js,jsx}",
+  "**/views/**/*.{ts,tsx,js,jsx}",
+  "**/app/**/*.{ts,tsx,js,jsx}",
+  "**/*Page.{ts,tsx,js,jsx}",
+  "**/*Screen.{ts,tsx,js,jsx}",
+  "**/*View.{ts,tsx,js,jsx}"
+];
+var DESTRUCTIVE_VERB2 = /(delete|destroy|remove|discard|wipe|erase|drop|terminate|revoke|deactivate|disable)/i;
+var LISTISH_TAGS = /* @__PURE__ */ new Set(["ul", "ol", "dl", "table", "tbody"]);
+var WebScreenAnalyzer = class {
+  config;
+  verbose = process.env.VERBOSE === "true";
+  screenPatterns;
+  constructor(config, options) {
+    this.config = config;
+    this.screenPatterns = options?.screenPatterns ?? DEFAULT_WEB_SCREEN_PATTERNS;
+  }
+  async analyze() {
+    const {
+      include = ["**/*.tsx", "**/*.ts", "**/*.jsx", "**/*.js"],
+      exclude = ["**/node_modules/**", "**/dist/**", "**/build/**"]
+    } = this.config;
+    const files = await glob(include, { cwd: this.config.rootDir, ignore: exclude });
+    const patternMatches = await glob(this.screenPatterns, {
+      cwd: this.config.rootDir,
+      ignore: exclude
+    });
+    const patternSet = new Set(patternMatches.map((f) => path8__default.resolve(this.config.rootDir, f)));
+    const candidates = [];
+    for (const file of files) {
+      const filePath = path8__default.resolve(this.config.rootDir, file);
+      try {
+        const candidate = await this.analyzeFile(filePath);
+        if (!candidate) continue;
+        candidate.matchesScreenPattern = patternSet.has(filePath);
+        candidates.push(candidate);
+        if (this.verbose) {
+          console.log(`[WebScreenAnalyzer] \u2713 Analyzed: ${candidate.descriptor.name} (${file})`);
+        }
+      } catch (error) {
+        if (this.verbose) {
+          console.warn(
+            `[WebScreenAnalyzer] Failed to parse ${file}:`,
+            error instanceof Error ? error.message : error
+          );
+        }
+      }
+    }
+    return { candidates, analyzedFiles: files.length };
+  }
+  async analyzeFile(filePath) {
+    const source = await fs.readFile(filePath, "utf-8");
+    const ast = parseSource(source, this.config.parserPlugins);
+    const registerScreenMeta = this.extractRegisterScreenMetadata(ast);
+    const componentName = this.extractComponentName(ast);
+    const labelsByHtmlFor = this.collectHtmlForLabels(ast);
+    const handlerBehaviors = this.collectWebHandlerBehaviors(ast);
+    const forms = this.mergeForms(
+      registerScreenMeta?.forms ?? [],
+      this.extractForms(ast, labelsByHtmlFor)
+    );
+    const actions = this.extractActions(ast, registerScreenMeta, handlerBehaviors);
+    const components = this.extractComponents(ast);
+    const collections = this.extractCollections(ast);
+    const navigationTargets = this.extractNavigationTargets(ast);
+    const permissionsFromJsDoc = extractPermissionsFromJsDoc(source);
+    const destructiveTags = extractDestructiveJsDocTargets(source);
+    if (destructiveTags) {
+      for (const action of actions) {
+        if (destructiveTags === "*" || destructiveTags.has(action.id)) {
+          action.destructive = true;
+        }
+      }
+    }
+    const name = registerScreenMeta?.name || componentName || path8__default.basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
+    const descriptor = {
+      name,
+      filePath,
+      title: registerScreenMeta?.title,
+      description: registerScreenMeta?.description,
+      components,
+      forms,
+      actions,
+      navigationTargets,
+      ...collections.length > 0 ? { collections } : {},
+      ...registerScreenMeta?.suggestedPrompts && registerScreenMeta.suggestedPrompts.length > 0 ? { suggestedPrompts: registerScreenMeta.suggestedPrompts } : {},
+      ...permissionsFromJsDoc ? {
+        permissions: permissionsFromJsDoc,
+        ...permissionsFromJsDoc.isPii ? { isPii: true } : {}
+      } : {}
+    };
+    return {
+      descriptor,
+      hasRegisterScreen: registerScreenMeta !== null || this.detectRegisterScreenCall(ast),
+      matchesScreenPattern: false
+    };
+  }
+  // ── registerScreen ────────────────────────────────────────────────
+  detectRegisterScreenCall(ast) {
+    let found = false;
+    traverse4(ast, {
+      CallExpression: (nodePath) => {
+        if (found) return;
+        if (isRegisterScreenCallee(nodePath.node.callee)) {
+          found = true;
+          nodePath.stop();
+        }
+      }
+    });
+    return found;
+  }
+  extractRegisterScreenMetadata(ast) {
+    let plain = null;
+    traverse4(ast, {
+      CallExpression: (nodePath) => {
+        if (!isRegisterScreenCallee(nodePath.node.callee)) return;
+        const arg = nodePath.node.arguments[0];
+        if (BabelTypes.isObjectExpression(arg)) {
+          plain = literalToPlain(arg);
+        }
+      }
+    });
+    if (!plain) return null;
+    const meta = plain;
+    const result = {
+      name: typeof meta.name === "string" ? meta.name : "",
+      actions: [],
+      forms: [],
+      navigationTargets: [],
+      components: []
+    };
+    if (typeof meta.title === "string") result.title = meta.title;
+    if (typeof meta.description === "string") result.description = meta.description;
+    if (Array.isArray(meta.suggestedPrompts)) {
+      const prompts = meta.suggestedPrompts.filter((p) => typeof p === "string").map((p) => p.trim()).filter((p) => p.length > 0);
+      if (prompts.length > 0) result.suggestedPrompts = prompts;
+    }
+    if (Array.isArray(meta.actions)) {
+      result.actions = meta.actions.filter((a) => typeof a === "object" && a !== null).filter((a) => typeof a.id === "string" && a.id.length > 0).map((a) => ({ type: "custom", ...a }));
+    }
+    if (Array.isArray(meta.fields)) {
+      const fields = meta.fields.filter((f) => typeof f === "object" && f !== null).filter((f) => typeof f.id === "string" && f.id.length > 0).map(
+        (f) => ({
+          name: f.id,
+          type: typeof f.type === "string" ? f.type : "text",
+          required: f.required === true,
+          ...typeof f.label === "string" ? { label: f.label } : {},
+          ...typeof f.placeholder === "string" ? { placeholder: f.placeholder } : {},
+          ...f.defaultValue !== void 0 ? { defaultValue: f.defaultValue } : {},
+          ...Array.isArray(f.options) ? { options: f.options } : {}
+        })
+      );
+      if (fields.length > 0) result.forms = [{ id: "default", fields }];
+    }
+    return result;
+  }
+  // ── Component name / structure ────────────────────────────────────
+  /** Default-exported component name, else the first exported capitalized function. */
+  extractComponentName(ast) {
+    let defaultName = "";
+    let firstExported = "";
+    traverse4(ast, {
+      ExportDefaultDeclaration: (nodePath) => {
+        const declaration = nodePath.node.declaration;
+        if (BabelTypes.isFunctionDeclaration(declaration) && declaration.id?.name) {
+          defaultName = declaration.id.name;
+        } else if (BabelTypes.isIdentifier(declaration)) {
+          defaultName = declaration.name;
+        }
+      },
+      ExportNamedDeclaration: (nodePath) => {
+        if (firstExported) return;
+        const declaration = nodePath.node.declaration;
+        if (BabelTypes.isFunctionDeclaration(declaration) && declaration.id && /^[A-Z]/.test(declaration.id.name)) {
+          firstExported = declaration.id.name;
+        } else if (BabelTypes.isVariableDeclaration(declaration)) {
+          for (const declarator of declaration.declarations) {
+            if (BabelTypes.isIdentifier(declarator.id) && /^[A-Z]/.test(declarator.id.name) && (BabelTypes.isArrowFunctionExpression(declarator.init) || BabelTypes.isFunctionExpression(declarator.init))) {
+              firstExported = declarator.id.name;
+              break;
+            }
+          }
+        }
+      }
+    });
+    return defaultName || firstExported;
+  }
+  extractComponents(ast) {
+    const components = [];
+    const seen = /* @__PURE__ */ new Set();
+    traverse4(ast, {
+      JSXOpeningElement: (nodePath) => {
+        const element = nodePath.node;
+        const name = getJsxElementName(element);
+        if (!name || seen.has(name)) return;
+        seen.add(name);
+        const role = classifyWebJsxComponent(name, element);
+        const type = role === "select" || role === "toggle" || role === "date" ? "input" : role === "input" || role === "button" || role === "list" || role === "modal" || role === "view" ? role : "custom";
+        const component = { name, type };
+        const testId = getStringAttr(element, "data-testid") ?? getStringAttr(element, "testID");
+        const ariaLabel = getStringAttr(element, "aria-label");
+        if (testId) component.testID = testId;
+        if (ariaLabel) component.accessibilityLabel = ariaLabel;
+        components.push(component);
+      }
+    });
+    return components;
+  }
+  // ── <label htmlFor> association ───────────────────────────────────
+  collectHtmlForLabels(ast) {
+    const labels = /* @__PURE__ */ new Map();
+    traverse4(ast, {
+      JSXElement: (nodePath) => {
+        const element = nodePath.node;
+        if (getJsxElementName(element.openingElement) !== "label") return;
+        const htmlFor = getStringAttr(element.openingElement, "htmlFor");
+        if (!htmlFor) return;
+        const text = jsxTextContent(element);
+        if (text) labels.set(htmlFor, text);
+      }
+    });
+    return labels;
+  }
+  // ── Forms ─────────────────────────────────────────────────────────
+  extractForms(ast, labelsByHtmlFor) {
+    const formBuckets = /* @__PURE__ */ new Map();
+    const usedIds = /* @__PURE__ */ new Set();
+    let formCount = 0;
+    const uniqueId = (preferred) => {
+      if (!usedIds.has(preferred)) {
+        usedIds.add(preferred);
+        return preferred;
+      }
+      let suffix = 2;
+      while (usedIds.has(`${preferred}-${suffix}`)) suffix += 1;
+      const id = `${preferred}-${suffix}`;
+      usedIds.add(id);
+      return id;
+    };
+    const bucketFor = (formElement) => {
+      let bucket = formBuckets.get(formElement);
+      if (bucket) return bucket;
+      formCount += 1;
+      let preferred = "default";
+      let submitAction;
+      if (formElement) {
+        const opening = formElement.openingElement;
+        preferred = getStringAttr(opening, "id") ?? getStringAttr(opening, "name") ?? getStringAttr(opening, "data-testid") ?? (formCount === 1 ? "default" : `form-${formCount}`);
+        submitAction = this.handlerNameFromAttr(opening, "onSubmit");
+      }
+      bucket = { id: uniqueId(preferred), fields: /* @__PURE__ */ new Map(), submitAction };
+      formBuckets.set(formElement, bucket);
+      return bucket;
+    };
+    traverse4(ast, {
+      JSXElement: (nodePath) => {
+        const element = nodePath.node;
+        const name = getJsxElementName(element.openingElement);
+        if (!name) return;
+        const role = classifyWebJsxComponent(name, element.openingElement);
+        if (!["input", "select", "toggle", "date"].includes(role)) return;
+        if (name === "option") return;
+        const field = this.extractField(element, role, labelsByHtmlFor);
+        if (!field.name) return;
+        const formParent = nodePath.findParent(
+          (p) => p.isJSXElement() && (getJsxElementName(p.node.openingElement) === "form" || getStringAttr(p.node.openingElement, "role") === "form")
+        );
+        const bucket = bucketFor(formParent ? formParent.node : null);
+        if (!bucket.fields.has(field.name)) bucket.fields.set(field.name, field);
+      }
+    });
+    traverse4(ast, {
+      JSXElement: (nodePath) => {
+        const element = nodePath.node;
+        const name = getJsxElementName(element.openingElement);
+        if (!name) return;
+        if (!this.isSubmitElement(name, element.openingElement)) return;
+        const formParent = nodePath.findParent(
+          (p) => p.isJSXElement() && getJsxElementName(p.node.openingElement) === "form"
+        );
+        if (!formParent) return;
+        const bucket = formBuckets.get(formParent.node);
+        if (!bucket) return;
+        const handler = this.handlerNameFromAttr(element.openingElement, "onClick");
+        if (!bucket.submitAction && handler) bucket.submitAction = handler;
+      }
+    });
+    return Array.from(formBuckets.values()).filter((bucket) => bucket.fields.size > 0).map((bucket) => ({
+      id: bucket.id,
+      fields: Array.from(bucket.fields.values()),
+      ...bucket.submitAction && bucket.submitAction !== "anonymous" ? { submitAction: bucket.submitAction } : {}
+    }));
+  }
+  isSubmitElement(name, opening) {
+    const type = getStringAttr(opening, "type");
+    if (name === "button") return type === "submit" || type === void 0;
+    if (name === "input") return type === "submit";
+    return false;
+  }
+  extractField(element, role, labelsByHtmlFor) {
+    const opening = element.openingElement;
+    const componentName = getJsxElementName(opening) ?? void 0;
+    const field = {
+      name: "",
+      type: "text",
+      required: false,
+      sourceComponent: componentName
+    };
+    const appilotsId = getStringAttr(opening, "appilotsId");
+    const dataTestId = getStringAttr(opening, "data-testid");
+    const domId = getStringAttr(opening, "id");
+    const nameAttr = getStringAttr(opening, "name");
+    const ariaLabel = getStringAttr(opening, "aria-label");
+    const placeholder = getStringAttr(opening, "placeholder");
+    if (placeholder) field.placeholder = placeholder;
+    if (ariaLabel) field.label = ariaLabel;
+    if (domId && labelsByHtmlFor.has(domId)) field.label = labelsByHtmlFor.get(domId);
+    if (appilotsId) {
+      field.name = appilotsId;
+      field.locator = mergeLocator(field.locator, {
+        id: appilotsId,
+        appilotsId,
+        source: "appilotsId"
+      });
+    }
+    if (dataTestId) {
+      if (!field.name) field.name = dataTestId.replace(/^(input-|field-|txt-)/, "");
+      field.locator = mergeLocator(field.locator, {
+        ...field.locator?.id ? {} : { id: dataTestId },
+        testID: dataTestId,
+        source: field.locator?.source ?? "data-testid"
+      });
+    }
+    if (nameAttr && !field.name) field.name = nameAttr;
+    if (domId) {
+      if (!field.name) field.name = domId;
+      field.locator = mergeLocator(field.locator, {
+        ...field.locator?.id ? {} : { id: domId },
+        source: field.locator?.source ?? "id"
+      });
+    }
+    if (ariaLabel) {
+      field.locator = mergeLocator(field.locator, {
+        ...field.locator?.id ? {} : { id: slugify(ariaLabel) },
+        accessibilityLabel: ariaLabel,
+        source: field.locator?.source ?? "aria-label"
+      });
+    }
+    for (const attr of opening.attributes) {
+      if (!BabelTypes.isJSXAttribute(attr) || !BabelTypes.isJSXIdentifier(attr.name)) continue;
+      const attrName = attr.name.name;
+      if (attrName === "required") {
+        if (attr.value === null) field.required = true;
+        else if (BabelTypes.isJSXExpressionContainer(attr.value) && BabelTypes.isBooleanLiteral(attr.value.expression)) {
+          field.required = attr.value.expression.value;
+        }
+      }
+      if ((attrName === "value" || attrName === "checked") && attr.value && BabelTypes.isJSXExpressionContainer(attr.value) && BabelTypes.isIdentifier(attr.value.expression)) {
+        field.valueBinding = attr.value.expression.name;
+        if (!field.name) field.name = attr.value.expression.name;
+      }
+    }
+    if (getStringAttr(opening, "aria-required") === "true") field.required = true;
+    if (role === "select") field.type = "select";
+    else if (role === "toggle") field.type = "toggle";
+    else if (role === "date") field.type = "date";
+    else {
+      field.type = this.inferInputType(opening, field);
+    }
+    if (componentName === "select") {
+      const options = this.extractSelectOptions(element);
+      if (options.length > 0) field.options = options;
+    }
+    if (!field.name || isWeakInferredFieldName(field.name)) {
+      const labelish = field.label ?? field.placeholder;
+      if (labelish) field.name = slugify(labelish);
+    }
+    if (!field.locator && field.name) {
+      field.locator = { id: field.name, label: field.label, source: "inferred" };
+    } else if (field.locator && !field.locator.id && field.name) {
+      field.locator = mergeLocator(field.locator, {
+        id: field.name,
+        label: field.label,
+        source: field.locator.source ?? "inferred"
+      });
+    }
+    return field;
+  }
+  inferInputType(opening, field) {
+    const type = getStringAttr(opening, "type");
+    if (type === "email") return "email";
+    if (type === "tel") return "phone";
+    if (type === "number") return "number";
+    if (type === "date" || type === "datetime-local" || type === "month" || type === "week") return "date";
+    const inputMode = getStringAttr(opening, "inputMode") ?? getStringAttr(opening, "inputmode");
+    if (inputMode === "email") return "email";
+    if (inputMode === "tel") return "phone";
+    if (inputMode === "numeric" || inputMode === "decimal") return "number";
+    const combined = `${field.name} ${field.label ?? ""} ${field.placeholder ?? ""}`.toLowerCase();
+    if (combined.includes("email")) return "email";
+    if (combined.includes("phone") || combined.includes("tel")) return "phone";
+    return "text";
+  }
+  extractSelectOptions(selectElement) {
+    const options = [];
+    for (const child of selectElement.children) {
+      if (!BabelTypes.isJSXElement(child)) continue;
+      if (getJsxElementName(child.openingElement) !== "option") continue;
+      const value = getStringAttr(child.openingElement, "value");
+      const label = jsxTextContent(child) || value || "";
+      if (label && value) options.push({ label, value });
+    }
+    return options;
+  }
+  mergeForms(primary, secondary) {
+    const out = primary.map((form) => ({ ...form, fields: [...form.fields] }));
+    for (const form of secondary) {
+      const existing = out.find((candidate) => candidate.id === form.id);
+      if (!existing) {
+        out.push({ ...form, fields: [...form.fields] });
+        continue;
+      }
+      for (const field of form.fields) {
+        const existingField = existing.fields.find((candidate) => candidate.name === field.name);
+        if (!existingField) {
+          existing.fields.push(field);
+          continue;
+        }
+        existingField.label = existingField.label ?? field.label;
+        existingField.placeholder = existingField.placeholder ?? field.placeholder;
+        existingField.options = existingField.options ?? field.options;
+        existingField.locator = existingField.locator ?? field.locator;
+        existingField.sourceComponent = existingField.sourceComponent ?? field.sourceComponent;
+        existingField.valueBinding = existingField.valueBinding ?? field.valueBinding;
+        existingField.required = existingField.required || field.required;
+        if (existingField.type === "text" && field.type !== "text") existingField.type = field.type;
+      }
+      existing.submitAction = existing.submitAction ?? form.submitAction;
+    }
+    return out;
+  }
+  // ── Actions ───────────────────────────────────────────────────────
+  extractActions(ast, registerScreenMeta, handlerBehaviors) {
+    const actions = [...registerScreenMeta?.actions ?? []];
+    const actionIds = new Set(actions.map((a) => a.id));
+    const actionLabels = new Map(
+      actions.filter((a) => a.label).map((a) => [normalizeLabel(a.label), a])
+    );
+    traverse4(ast, {
+      JSXElement: (nodePath) => {
+        const element = nodePath.node;
+        const name = getJsxElementName(element.openingElement);
+        if (!name) return;
+        if (classifyWebJsxComponent(name, element.openingElement) !== "button") return;
+        const action = this.extractActionFromElement(element, nodePath);
+        if (!action) return;
+        const existingByLabel = action.label ? actionLabels.get(normalizeLabel(action.label)) : void 0;
+        if (existingByLabel) {
+          this.mergeActionMetadata(existingByLabel, action);
+          return;
+        }
+        if (action.id && !actionIds.has(action.id)) {
+          actions.push(action);
+          actionIds.add(action.id);
+          if (action.label) actionLabels.set(normalizeLabel(action.label), action);
+        }
+      }
+    });
+    this.enrichActionsFromHandlers(actions, handlerBehaviors);
+    return actions;
+  }
+  extractActionFromElement(element, nodePath) {
+    const opening = element.openingElement;
+    const componentName = getJsxElementName(opening) ?? void 0;
+    const action = { id: "", type: "custom", sourceComponent: componentName };
+    const ariaLabel = getStringAttr(opening, "aria-label");
+    const label = ariaLabel ?? jsxTextContent(element) ?? getStringAttr(opening, "value") ?? getStringAttr(opening, "title");
+    if (label) action.label = label;
+    if (ariaLabel) {
+      action.locator = mergeLocator(action.locator, {
+        accessibilityLabel: ariaLabel,
+        source: "aria-label"
+      });
+    }
+    const appilotsId = getStringAttr(opening, "appilotsId");
+    const dataTestId = getStringAttr(opening, "data-testid");
+    const domId = getStringAttr(opening, "id");
+    if (appilotsId) {
+      action.id = appilotsId;
+      action.locator = mergeLocator(action.locator, {
+        id: appilotsId,
+        appilotsId,
+        source: "appilotsId"
+      });
+    } else if (dataTestId) {
+      action.id = dataTestId;
+      action.locator = mergeLocator(action.locator, {
+        id: dataTestId,
+        testID: dataTestId,
+        source: "data-testid"
+      });
+    } else if (domId) {
+      action.id = domId;
+      action.locator = mergeLocator(action.locator, { id: domId, source: "id" });
+    } else if (action.label) {
+      action.id = slugify(action.label);
+    }
+    if (!action.id) return null;
+    const to = routePathAttr(opening, "to") ?? routePathAttr(opening, "href");
+    if (to && to.startsWith("/")) {
+      action.type = "navigation";
+      action.targetScreen = to;
+    } else if (to && !to.startsWith("/") && !hasJsxAttribute(opening, "onClick")) {
+      return null;
+    }
+    let handlerName;
+    const onClickAttr = opening.attributes.find(
+      (attr) => BabelTypes.isJSXAttribute(attr) && BabelTypes.isJSXIdentifier(attr.name) && attr.name.name === "onClick"
+    );
+    if (onClickAttr?.value && BabelTypes.isJSXExpressionContainer(onClickAttr.value)) {
+      const expr = onClickAttr.value.expression;
+      if (BabelTypes.isIdentifier(expr)) {
+        handlerName = expr.name;
+        action.handler = expr.name;
+      } else if (!BabelTypes.isJSXEmptyExpression(expr)) {
+        const inlineNavCalls = extractWebNavigationCalls(expr);
+        const inlineNav = inlineNavCalls.find((call) => call.targetPath);
+        if (inlineNav?.targetPath) {
+          action.type = "navigation";
+          action.targetScreen = inlineNav.targetPath;
+        } else if (inlineNavCalls.some((call) => call.method === "goBack")) {
+          action.type = "navigation";
+          action.successSignal = {
+            type: "goBack",
+            description: "Action returns to the previous page"
+          };
+          action.appilotsInferred = {
+            ...action.appilotsInferred ?? {},
+            expectedOutcome: "navigation"
+          };
+        }
+        const inlineHandler = firstCalledFunctionName(expr);
+        if (inlineHandler) {
+          handlerName = inlineHandler;
+          action.handler = inlineHandler;
+        }
+      }
+    }
+    if (handlerName) {
+      const lower = handlerName.toLowerCase();
+      if (lower.includes("submit")) action.type = "submit";
+      else if (lower.includes("navigate") && action.type === "custom") action.type = "navigation";
+    }
+    if (componentName && this.isSubmitElement(componentName, opening)) {
+      const formParent = nodePath.findParent(
+        (p) => p.isJSXElement() && getJsxElementName(p.node.openingElement) === "form"
+      );
+      if (formParent) {
+        action.type = "submit";
+        if (!action.handler) {
+          const formHandler = this.handlerNameFromAttr(formParent.node.openingElement, "onSubmit");
+          if (formHandler && formHandler !== "anonymous") {
+            action.handler = formHandler;
+            handlerName = formHandler;
+          }
+        }
+      }
+    }
+    if (hasJsxAttribute(opening, "destructive") || hasJsxAttribute(opening, "aria-destructive")) {
+      const value = getStringAttr(opening, "destructive") ?? getStringAttr(opening, "aria-destructive");
+      action.destructive = value !== "false";
+    } else if (handlerName && DESTRUCTIVE_VERB2.test(handlerName) || DESTRUCTIVE_VERB2.test(action.id)) {
+      action.destructive = true;
+    }
+    if (!action.locator && action.id) {
+      action.locator = {
+        id: action.id,
+        label: action.label,
+        source: action.label ? "label" : "inferred"
+      };
+    }
+    return action;
+  }
+  mergeActionMetadata(target, source) {
+    target.handler = target.handler ?? source.handler;
+    target.targetScreen = target.targetScreen ?? source.targetScreen;
+    target.description = target.description ?? source.description;
+    target.locator = target.locator ?? source.locator;
+    target.nativeConfirmationExpected = target.nativeConfirmationExpected || source.nativeConfirmationExpected || void 0;
+    target.requiresConfirmation = target.requiresConfirmation || source.requiresConfirmation || void 0;
+    target.destructive = target.destructive || source.destructive || void 0;
+    target.effect = target.effect ?? source.effect;
+    target.riskLevel = target.riskLevel ?? source.riskLevel;
+    target.appilotsInferred = target.appilotsInferred ?? source.appilotsInferred;
+  }
+  enrichActionsFromHandlers(actions, behaviors) {
+    for (const action of actions) {
+      const behavior = action.handler ? behaviors.get(action.handler) : void 0;
+      if (!behavior) continue;
+      action.appilotsInferred = {
+        ...action.appilotsInferred ?? {},
+        ...behavior.base.appilotsInferred
+      };
+      if (behavior.nativeConfirmationExpected || behavior.base.nativeConfirmationExpected) {
+        action.nativeConfirmationExpected = true;
+      }
+      if (behavior.targetPath && !action.targetScreen) {
+        action.targetScreen = behavior.targetPath;
+        if (action.type === "custom") action.type = "navigation";
+        action.appilotsInferred = {
+          ...action.appilotsInferred ?? {},
+          expectedOutcome: "navigation"
+        };
+      }
+      if (behavior.base.successSignal && !action.successSignal) {
+        action.successSignal = behavior.base.successSignal;
+      }
+      if (behavior.base.failureSignal && !action.failureSignal) {
+        action.failureSignal = behavior.base.failureSignal;
+      }
+      if (behavior.base.opensModal && !action.opensModal) {
+        action.opensModal = behavior.base.opensModal;
+      }
+      if (behavior.base.destructive || action.destructive === true || action.requiresConfirmation === true || action.effect === "destructive" || action.riskLevel === "high") {
+        action.destructive = true;
+        action.effect = action.effect ?? "destructive";
+        action.riskLevel = action.riskLevel ?? "high";
+        action.requiresConfirmation = action.requiresConfirmation ?? true;
+      }
+    }
+  }
+  /**
+   * Handler behavior via the shared, platform-neutral analyzer
+   * (async/await, `.then`, state setters, toasts, destructive verbs)
+   * plus the web-only signals: React Router navigation targets and
+   * `window.confirm(...)` as the native confirmation dialog.
+   */
+  collectWebHandlerBehaviors(ast) {
+    const handlers = collectFunctions(ast);
+    const out = /* @__PURE__ */ new Map();
+    for (const [name, fn] of handlers) {
+      const base = analyzeFunctionBehavior(name, fn, handlers);
+      const navCalls = fn.body ? extractWebNavigationCalls(fn.body) : [];
+      const firstNav = navCalls.find((call) => call.targetPath);
+      const goesBack = navCalls.some((call) => call.method === "goBack");
+      out.set(name, {
+        base: {
+          ...base,
+          ...goesBack && !base.successSignal ? {
+            successSignal: {
+              type: "goBack",
+              description: "Action returns to the previous page"
+            }
+          } : {}
+        },
+        targetPath: firstNav?.targetPath,
+        nativeConfirmationExpected: fn.body ? containsWindowConfirm(fn.body) : false
+      });
+    }
+    return out;
+  }
+  handlerNameFromAttr(opening, attrName) {
+    const attr = opening.attributes.find(
+      (candidate) => BabelTypes.isJSXAttribute(candidate) && BabelTypes.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
+    );
+    if (!attr?.value || !BabelTypes.isJSXExpressionContainer(attr.value)) return void 0;
+    const expr = attr.value.expression;
+    if (BabelTypes.isIdentifier(expr)) return expr.name;
+    if (BabelTypes.isArrowFunctionExpression(expr) || BabelTypes.isFunctionExpression(expr)) {
+      return firstCalledFunctionName(expr) ?? "anonymous";
+    }
+    return void 0;
+  }
+  // ── Navigation targets (route paths — resolved by the orchestrator) ─
+  extractNavigationTargets(ast) {
+    const targets = /* @__PURE__ */ new Set();
+    for (const call of extractWebNavigationCalls(ast)) {
+      if (call.targetPath && call.targetPath.startsWith("/")) targets.add(call.targetPath);
+    }
+    traverse4(ast, {
+      JSXOpeningElement: (nodePath) => {
+        const element = nodePath.node;
+        const name = getJsxElementName(element);
+        if (name === "Link" || name === "NavLink" || name === "Navigate") {
+          const to = routePathAttr(element, "to");
+          if (to && to.startsWith("/")) targets.add(to);
+        }
+        if (name === "a") {
+          const href = routePathAttr(element, "href");
+          if (href && href.startsWith("/")) targets.add(href);
+        }
+      }
+    });
+    return Array.from(targets).sort();
+  }
+  // ── Collections ───────────────────────────────────────────────────
+  extractCollections(ast) {
+    const collections = [];
+    const seen = /* @__PURE__ */ new Set();
+    traverse4(ast, {
+      JSXExpressionContainer: (nodePath) => {
+        const expr = nodePath.node.expression;
+        if (!BabelTypes.isCallExpression(expr) || !BabelTypes.isMemberExpression(expr.callee) || !BabelTypes.isIdentifier(expr.callee.object) || !BabelTypes.isIdentifier(expr.callee.property) || expr.callee.property.name !== "map") {
+          return;
+        }
+        const callback = expr.arguments[0];
+        if (!BabelTypes.isArrowFunctionExpression(callback) && !BabelTypes.isFunctionExpression(callback)) return;
+        const enclosing = nodePath.findParent((p) => p.isJSXElement());
+        const enclosingName = enclosing ? getJsxElementName(enclosing.node.openingElement) : null;
+        const enclosingRole = enclosing && enclosingName ? classifyWebJsxComponent(enclosingName, enclosing.node.openingElement) : null;
+        const returnsListItem = callbackReturnsTag(callback, /* @__PURE__ */ new Set(["li", "tr"]));
+        if (enclosingName === "select") return;
+        const isListContext = enclosingName !== null && LISTISH_TAGS.has(enclosingName) || enclosingRole === "list" || returnsListItem;
+        if (!isListContext) return;
+        const dataSource = expr.callee.object.name;
+        if (seen.has(dataSource)) return;
+        seen.add(dataSource);
+        const itemNames = collectionItemNames(callback);
+        const displayFields = collectionDisplayFields(callback, itemNames);
+        const keyField = collectionKeyField(callback, itemNames);
+        const rowAction = collectionRowAction(callback);
+        const itemType = inferItemType(dataSource, displayFields);
+        const identityFields = inferIdentityFields(keyField, displayFields);
+        collections.push({
+          id: dataSource,
+          component: enclosingName ?? "list",
+          ...itemType ? { itemType } : {},
+          dataSource,
+          ...keyField ? { keyField } : {},
+          ...displayFields.length > 0 ? { displayFields } : {},
+          ...rowAction ? { rowAction, rowActions: [rowAction] } : {},
+          ...identityFields.length > 0 ? { identityFields } : {}
+        });
+      }
+    });
+    return collections;
+  }
+};
+function isRegisterScreenCallee(callee) {
+  return BabelTypes.isIdentifier(callee) && callee.name === "registerScreen" || BabelTypes.isMemberExpression(callee) && BabelTypes.isIdentifier(callee.property) && callee.property.name === "registerScreen";
+}
+function literalToPlain(node) {
+  if (BabelTypes.isStringLiteral(node) || BabelTypes.isNumericLiteral(node) || BabelTypes.isBooleanLiteral(node)) {
+    return node.value;
+  }
+  if (BabelTypes.isNullLiteral(node)) return null;
+  if (BabelTypes.isArrayExpression(node)) {
+    return node.elements.filter((el) => el !== null && BabelTypes.isExpression(el)).map((el) => literalToPlain(el)).filter((value) => value !== void 0);
+  }
+  if (BabelTypes.isObjectExpression(node)) {
+    const out = {};
+    for (const prop of node.properties) {
+      if (!BabelTypes.isObjectProperty(prop)) continue;
+      const key = BabelTypes.isIdentifier(prop.key) ? prop.key.name : BabelTypes.isStringLiteral(prop.key) ? prop.key.value : void 0;
+      if (!key || !BabelTypes.isExpression(prop.value)) continue;
+      const value = literalToPlain(prop.value);
+      if (value !== void 0) out[key] = value;
+    }
+    return out;
+  }
+  return void 0;
+}
+function jsxTextContent(element) {
+  const parts = [];
+  const walk = (children) => {
+    for (const child of children) {
+      if (BabelTypes.isJSXText(child)) {
+        const trimmed = child.value.replace(/\s+/g, " ").trim();
+        if (trimmed) parts.push(trimmed);
+      } else if (BabelTypes.isJSXExpressionContainer(child) && BabelTypes.isStringLiteral(child.expression)) {
+        parts.push(child.expression.value);
+      } else if (BabelTypes.isJSXElement(child)) {
+        walk(child.children);
+      }
+    }
+  };
+  walk(element.children);
+  const text = parts.join(" ").trim();
+  return text.length > 0 ? text : void 0;
+}
+function firstCalledFunctionName(node) {
+  if (BabelTypes.isIdentifier(node)) return node.name;
+  if (BabelTypes.isArrowFunctionExpression(node) || BabelTypes.isFunctionExpression(node)) {
+    return firstCalledFunctionName(node.body);
+  }
+  if (BabelTypes.isBlockStatement(node)) {
+    for (const statement of node.body) {
+      const handler = firstCalledFunctionName(statement);
+      if (handler) return handler;
+    }
+    return void 0;
+  }
+  if (BabelTypes.isExpressionStatement(node)) return firstCalledFunctionName(node.expression);
+  if (BabelTypes.isReturnStatement(node)) {
+    return node.argument ? firstCalledFunctionName(node.argument) : void 0;
+  }
+  if (BabelTypes.isAwaitExpression(node) || BabelTypes.isUnaryExpression(node)) {
+    return firstCalledFunctionName(node.argument);
+  }
+  if (BabelTypes.isCallExpression(node)) {
+    if (BabelTypes.isIdentifier(node.callee) && !/^(navigate|confirm|alert)$/.test(node.callee.name)) {
+      return node.callee.name;
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function containsWindowConfirm(body) {
+  let found = false;
+  traverse4(body, {
+    noScope: true,
+    CallExpression: (nodePath) => {
+      const callee = nodePath.node.callee;
+      if (BabelTypes.isIdentifier(callee) && callee.name === "confirm") found = true;
+      if (BabelTypes.isMemberExpression(callee) && BabelTypes.isIdentifier(callee.object) && callee.object.name === "window" && BabelTypes.isIdentifier(callee.property) && callee.property.name === "confirm") {
+        found = true;
+      }
+    }
+  });
+  return found;
+}
+function mergeLocator(current, next) {
+  return { ...current ?? {}, ...next };
+}
+function routePathAttr(opening, attrName) {
+  const literal = getStringAttr(opening, attrName);
+  if (literal) return literal;
+  const attr = opening.attributes.find(
+    (candidate) => BabelTypes.isJSXAttribute(candidate) && BabelTypes.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
+  );
+  if (!attr?.value || !BabelTypes.isJSXExpressionContainer(attr.value)) return void 0;
+  return staticRoutePath(attr.value.expression);
+}
+function slugify(label) {
+  return label.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function normalizeLabel(label) {
+  return label.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function isWeakInferredFieldName(name) {
+  return /^(text|value|input|query|search|selected|checked)$/i.test(name);
+}
+function collectionItemNames(callback) {
+  const names = /* @__PURE__ */ new Set(["item"]);
+  const firstParam = callback.params[0];
+  if (BabelTypes.isIdentifier(firstParam)) names.add(firstParam.name);
+  if (BabelTypes.isObjectPattern(firstParam)) {
+    for (const prop of firstParam.properties) {
+      if (BabelTypes.isObjectProperty(prop) && BabelTypes.isIdentifier(prop.key) && BabelTypes.isIdentifier(prop.value)) {
+        names.add(prop.value.name);
+      }
+    }
+  }
+  return names;
+}
+function collectionDisplayFields(callback, itemNames) {
+  const fields = /* @__PURE__ */ new Set();
+  if (!callback.body) return [];
+  traverse4(callback.body, {
+    noScope: true,
+    MemberExpression: (nodePath) => {
+      const node = nodePath.node;
+      if (BabelTypes.isIdentifier(node.object) && itemNames.has(node.object.name) && BabelTypes.isIdentifier(node.property)) {
+        fields.add(node.property.name);
+      }
+    }
+  });
+  return Array.from(fields).sort();
+}
+function collectionKeyField(callback, itemNames) {
+  let keyField;
+  if (!callback.body) return void 0;
+  traverse4(callback.body, {
+    noScope: true,
+    JSXAttribute: (nodePath) => {
+      const attr = nodePath.node;
+      if (!BabelTypes.isJSXIdentifier(attr.name) || attr.name.name !== "key") return;
+      if (!attr.value || !BabelTypes.isJSXExpressionContainer(attr.value)) return;
+      const expr = attr.value.expression;
+      if (BabelTypes.isMemberExpression(expr) && BabelTypes.isIdentifier(expr.object) && itemNames.has(expr.object.name) && BabelTypes.isIdentifier(expr.property)) {
+        keyField = keyField ?? expr.property.name;
+      }
+    }
+  });
+  return keyField;
+}
+function collectionRowAction(callback) {
+  if (!callback.body) return void 0;
+  const navCall = extractWebNavigationCalls(callback.body).find((call) => call.targetPath);
+  if (!navCall?.targetPath) return void 0;
+  return {
+    type: "navigation",
+    // Route path — the orchestrator resolves it to a screen name.
+    targetScreen: navCall.targetPath,
+    description: `Clicking a row opens ${navCall.targetPath}`
+  };
+}
+function callbackReturnsTag(callback, tags) {
+  let found = false;
+  const inspect = (node) => {
+    if (!node || found) return;
+    if (BabelTypes.isJSXElement(node)) {
+      const name = getJsxElementName(node.openingElement);
+      if (name && tags.has(name)) found = true;
+      return;
+    }
+    if (BabelTypes.isBlockStatement(node)) {
+      for (const statement of node.body) {
+        if (BabelTypes.isReturnStatement(statement)) inspect(statement.argument);
+      }
+    }
+    if (BabelTypes.isParenthesizedExpression(node)) inspect(node.expression);
+    if (BabelTypes.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);
+}
+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 promises.readFile(filePath, "utf-8");
+        if (!/createBrowserRouter|createHashRouter|createMemoryRouter|useRoutes|<Route[\s>]/.test(content)) {
+          continue;
+        }
+        const ast = parseSource(content, this.config.parserPlugins);
+        routes.push(...this.extractJsxRoutes(ast));
+        routes.push(...this.extractObjectRoutes(ast));
+      } catch (error) {
+        console.warn(`[WebNavigationAnalyzer] Failed to parse ${filePath}:`, error);
+      }
+    }
+    const deduped = this.dedupeRoutes(routes);
+    return { graph: this.buildGraph(deduped), routes: deduped };
+  }
+  /** Files likely to contain route configuration. */
+  async findRouteFiles() {
+    const patterns = [
+      "**/*{router,routes,Router,Routes}*.{ts,tsx,js,jsx}",
+      "**/App.{ts,tsx,js,jsx}",
+      "**/app.{ts,tsx,js,jsx}",
+      "**/main.{ts,tsx,js,jsx}",
+      "**/index.{ts,tsx,js,jsx}",
+      ...this.navigationInclude
+    ];
+    const ignore = [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      ...this.config.exclude || [],
+      ...this.navigationExclude
+    ];
+    const files = await glob(patterns, { cwd: this.config.rootDir, ignore });
+    return files.map((file) => path8__default.join(this.config.rootDir, file));
+  }
+  // ── JSX <Route> style ────────────────────────────────────────────
+  extractJsxRoutes(ast) {
+    const routes = [];
+    const visitRoute = (element, parentPath) => {
+      const opening = element.openingElement;
+      const name = getJsxElementName(opening);
+      if (name !== "Route") {
+        for (const child of element.children) {
+          if (BabelTypes.isJSXElement(child)) visitRoute(child, parentPath);
+        }
+        return;
+      }
+      const segment = getStringAttr(opening, "path");
+      const isIndex = hasJsxAttribute(opening, "index") && !segment;
+      const fullPath = this.joinPaths(parentPath, segment, isIndex);
+      const componentName = this.componentNameFromElementAttr(opening) ?? void 0;
+      const isLeaf = !element.children.some(
+        (child) => BabelTypes.isJSXElement(child) && getJsxElementName(child.openingElement) === "Route"
+      );
+      if ((segment || isIndex) && (componentName || isLeaf)) {
+        routes.push(this.buildRoute(fullPath, componentName, isIndex, !isLeaf));
+      }
+      for (const child of element.children) {
+        if (BabelTypes.isJSXElement(child)) visitRoute(child, fullPath);
+      }
+    };
+    traverse4(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 (!BabelTypes.isJSXAttribute(attr) || !BabelTypes.isJSXIdentifier(attr.name)) continue;
+      if (attr.name.name === "element" && BabelTypes.isJSXExpressionContainer(attr.value)) {
+        const expr = attr.value.expression;
+        if (BabelTypes.isJSXElement(expr)) return getJsxElementName(expr.openingElement);
+      }
+      if (attr.name.name === "Component" && BabelTypes.isJSXExpressionContainer(attr.value)) {
+        if (BabelTypes.isIdentifier(attr.value.expression)) return attr.value.expression.name;
+      }
+    }
+    return null;
+  }
+  // ── createBrowserRouter([...]) / useRoutes([...]) style ──────────
+  extractObjectRoutes(ast) {
+    const routes = [];
+    const ROUTER_FACTORIES = /* @__PURE__ */ new Set([
+      "createBrowserRouter",
+      "createHashRouter",
+      "createMemoryRouter",
+      "useRoutes"
+    ]);
+    traverse4(ast, {
+      CallExpression: (nodePath) => {
+        const callee = nodePath.node.callee;
+        if (!BabelTypes.isIdentifier(callee) || !ROUTER_FACTORIES.has(callee.name)) return;
+        const first = nodePath.node.arguments[0];
+        if (!BabelTypes.isArrayExpression(first)) return;
+        this.visitRouteObjects(first, "", routes);
+      }
+    });
+    return routes;
+  }
+  visitRouteObjects(arr, parentPath, out) {
+    for (const element of arr.elements) {
+      if (!BabelTypes.isObjectExpression(element)) continue;
+      let segment;
+      let isIndex = false;
+      let componentName;
+      let children;
+      for (const prop of element.properties) {
+        if (!BabelTypes.isObjectProperty(prop) || !BabelTypes.isIdentifier(prop.key)) continue;
+        const key = prop.key.name;
+        if (key === "path" && BabelTypes.isStringLiteral(prop.value)) segment = prop.value.value;
+        if (key === "index" && BabelTypes.isBooleanLiteral(prop.value)) isIndex = prop.value.value;
+        if (key === "element" && BabelTypes.isJSXElement(prop.value)) {
+          componentName = getJsxElementName(prop.value.openingElement) ?? void 0;
+        }
+        if (key === "Component" && BabelTypes.isIdentifier(prop.value)) componentName = prop.value.name;
+        if (key === "children" && BabelTypes.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 });
+    }
+    return params;
+  }
+  /**
+   * One entry per path. When several declarations resolve to the same
+   * path, keep the one that best describes what the user lands on: a
+   * page beats a layout wrapper (an `index` child and its parent layout
+   * share a path), and a resolved component name beats a name derived
+   * from the path.
+   */
+  dedupeRoutes(routes) {
+    const byPath = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      const existing = byPath.get(route.path);
+      if (!existing || routeScore(route) > routeScore(existing)) {
+        byPath.set(route.path, route);
+      }
+    }
+    return Array.from(byPath.values());
+  }
+  buildGraph(routes) {
+    const screens = {};
+    const navigatorName = "router";
+    const screenNames = routes.map((r) => r.screenName);
+    for (const route of routes) {
+      const others = screenNames.filter((name) => name !== route.screenName);
+      screens[route.screenName] = {
+        screenName: route.screenName,
+        // Open-union value — web routes, not a RN stack/tab/drawer.
+        navigatorType: WEB_NAVIGATOR_TYPE,
+        parentNavigator: navigatorName,
+        // Any route is one URL away from any other — both directions,
+        // like the RN analyzer models tab navigators.
+        reachableFrom: others,
+        reachableTo: others,
+        ...route.params ? { params: route.params } : {}
+      };
+    }
+    const initialRoute = routes.find((r) => r.path === "/") ?? routes.find((r) => r.index) ?? routes[0];
+    return {
+      screens,
+      initialScreen: initialRoute?.screenName ?? "",
+      navigators: routes.length > 0 ? [{
+        name: navigatorName,
+        type: WEB_NAVIGATOR_TYPE,
+        screens: screenNames
+      }] : []
+    };
+  }
+};
+function screenNameFromPath(routePath) {
+  if (routePath === "/" || routePath === "") return "Home";
+  return routePath.split("/").filter(Boolean).map((segment) => segment.replace(/^:/, "").replace(/\?$/, "")).map(
+    (segment) => segment.split(/[-_.]/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("")
+  ).join("");
+}
+function routeScore(route) {
+  const isPage = route.layout ? 0 : 2;
+  const hasRealName = route.screenName === screenNameFromPath(route.path) ? 0 : 1;
+  return isPage + hasRealName;
+}
+function resolvePathToScreen(routes, target) {
+  const normalized = `/${target}`.replace(/\/+/g, "/").replace(/\?.*$/, "").replace(/#.*$/, "");
+  const cleaned = normalized.length > 1 ? normalized.replace(/\/$/, "") : normalized;
+  const exact = routes.find((r) => r.path === cleaned);
+  if (exact) return exact.screenName;
+  const targetSegments = cleaned.split("/").filter(Boolean);
+  for (const route of routes) {
+    const routeSegments = route.path.split("/").filter(Boolean);
+    if (routeSegments.length !== targetSegments.length) continue;
+    const matches = routeSegments.every(
+      (seg, i) => seg.startsWith(":") || seg === "*" || seg === targetSegments[i]
+    );
+    if (matches) return route.screenName;
+  }
+  return void 0;
+}
+
+// src/analyzers/web/ReactWebPlatformAnalyzer.ts
+var ReactWebPlatformAnalyzer = class {
+  platform = "web";
+  async analyze(config, options) {
+    const screenAnalyzer = new WebScreenAnalyzer(config, {
+      screenPatterns: options.screenPatterns
+    });
+    const navigationAnalyzer = new WebNavigationAnalyzer(config, {
+      navigationInclude: options.navigationInclude,
+      navigationExclude: options.navigationExclude
+    });
+    console.log("[ReactWebPlatformAnalyzer] Running analyzers...");
+    const [screenAnalysis, navigationResult] = await Promise.all([
+      screenAnalyzer.analyze(),
+      navigationAnalyzer.analyze()
+    ]);
+    const routeScreenNames = new Set(navigationResult.routes.map((route) => route.screenName));
+    const strictScreens = options.strictScreens ?? true;
+    let screensFilteredOut = 0;
+    const included = [];
+    for (const candidate of screenAnalysis.candidates) {
+      if (!strictScreens || this.isScreen(candidate, routeScreenNames)) {
+        included.push(candidate);
+      } else {
+        screensFilteredOut++;
+      }
+    }
+    const screens = included.map(
+      (candidate) => this.resolveRoutePaths(candidate.descriptor, navigationResult.routes)
+    );
+    console.log(
+      `[ReactWebPlatformAnalyzer] Screen and navigation analysis complete. Found ${screens.length} screens, ${navigationResult.routes.length} routes`
+    );
+    return {
+      screens,
+      navigation: navigationResult.graph,
+      analyzedFiles: screenAnalysis.analyzedFiles,
+      ...screensFilteredOut > 0 ? { screensFilteredOut } : {}
+    };
+  }
+  isScreen(candidate, routeScreenNames) {
+    return candidate.hasRegisterScreen || candidate.matchesScreenPattern || routeScreenNames.has(candidate.descriptor.name);
+  }
+  /** Replace route-path references with screen names where the route table resolves them. */
+  resolveRoutePaths(screen, routes) {
+    const resolve2 = (target) => {
+      if (!target || !target.startsWith("/")) return target;
+      return resolvePathToScreen(routes, target) ?? target;
+    };
+    const navigationTargets = Array.from(
+      new Set(
+        screen.navigationTargets.map((target) => resolve2(target)).filter((target) => target !== screen.name)
+      )
+    ).sort();
+    const actions = screen.actions.map((action) => {
+      const resolved = resolve2(action.targetScreen);
+      return resolved === action.targetScreen ? action : { ...action, targetScreen: resolved };
+    });
+    const collections = screen.collections?.map((collection) => {
+      const resolveRow = (row) => {
+        if (!row?.targetScreen) return row;
+        const resolved = resolve2(row.targetScreen);
+        if (resolved === row.targetScreen) return row;
+        return {
+          ...row,
+          targetScreen: resolved,
+          ...row.description ? { description: `Clicking a row opens ${resolved}` } : {}
+        };
+      };
+      const rowAction = resolveRow(collection.rowAction);
+      return {
+        ...collection,
+        ...rowAction ? { rowAction } : {},
+        ...collection.rowActions ? { rowActions: collection.rowActions.map((row) => resolveRow(row)) } : {}
+      };
+    });
+    return {
+      ...screen,
+      navigationTargets,
+      actions,
+      ...collections ? { collections } : {}
+    };
+  }
+};
+
 // ../../node_modules/zod/v3/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -2614,8 +4088,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":
@@ -2887,8 +4361,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
@@ -3004,11 +4478,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() {
@@ -6449,7 +7923,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../shared/dist/chunk-XLOYG3DH.mjs
+// ../shared/dist/chunk-MSOZJNXB.mjs
 var locatorSourceSchema = external_exports.enum([
   "appilotsId",
   "testID",
@@ -6634,7 +8108,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(),
@@ -6681,6 +8167,41 @@ var loginSchema = external_exports.object({
 loginSchema.extend({
   name: external_exports.string().min(2, "Name must be at least 2 characters").max(100)
 });
+external_exports.object({
+  name: external_exports.string().min(2, "Name must be at least 2 characters").max(100).optional(),
+  avatarUrl: external_exports.string().url("Invalid URL").max(2048).nullable().optional()
+}).refine((v) => v.name !== void 0 || v.avatarUrl !== void 0, {
+  message: "At least one field must be provided"
+});
+external_exports.object({
+  currentPassword: external_exports.string().min(1, "Current password is required"),
+  newPassword: external_exports.string().min(8, "Password must be at least 8 characters")
+});
+var totpCodeSchema = external_exports.string().transform((v) => v.replace(/\s/g, "")).pipe(external_exports.string().regex(/^\d{6}$/, "Code must be 6 digits"));
+var recoveryCodeSchema = external_exports.string().transform((v) => v.toUpperCase().replace(/[^A-Z0-9]/g, "")).pipe(external_exports.string().regex(/^[23456789BCDFGHJKMNPQRSTVWXYZ]{10}$/, "Invalid recovery code"));
+external_exports.object({
+  code: totpCodeSchema
+});
+external_exports.object({
+  challengeToken: external_exports.string().min(1, "Challenge token is required"),
+  code: totpCodeSchema.optional(),
+  recoveryCode: recoveryCodeSchema.optional()
+}).refine((v) => Boolean(v.code) !== Boolean(v.recoveryCode), {
+  message: "Provide either a TOTP code or a recovery code",
+  path: ["code"]
+});
+external_exports.object({
+  password: external_exports.string().min(1, "Password is required"),
+  code: totpCodeSchema.optional(),
+  recoveryCode: recoveryCodeSchema.optional()
+}).refine((v) => Boolean(v.code) !== Boolean(v.recoveryCode), {
+  message: "Provide either a TOTP code or a recovery code",
+  path: ["code"]
+});
+external_exports.object({
+  password: external_exports.string().min(1, "Password is required"),
+  code: totpCodeSchema
+});
 var createProjectSchema = external_exports.object({
   name: external_exports.string().min(1).max(100),
   description: external_exports.string().max(500).optional(),
@@ -7344,6 +8865,18 @@ 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(),
@@ -7382,7 +8915,16 @@ external_exports.object({
   /** Hop-by-hop trace. Always at least one entry. */
   trace: external_exports.array(sandboxTraceHopSchema),
   /** True when the run was a no-op (e.g. project has no MCP yet). */
-  warning: external_exports.string().optional()
+  warning: external_exports.string().optional(),
+  /**
+   * SPEC-046 — guard / hallucination telemetry for the run.
+   *
+   * ADDITIVE AND OPTIONAL, permanently: SDK and dashboard consumers
+   * predate it, and older API deployments will not send it. Consumers
+   * must treat an absent block as "no information", never as "no guards
+   * fired".
+   */
+  diagnostics: relayDiagnosticsSchema.optional()
 });
 external_exports.object({
   name: external_exports.string().min(1).max(120),
@@ -7601,7 +9143,7 @@ var manifestSchema = external_exports.object({
   navigation: navigationGraphSchema.partial().optional()
 }).passthrough();
 async function loadManifest(rootDir, manifestPath) {
-  const resolvedPath = path6__default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
+  const resolvedPath = path8__default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
   let raw;
   try {
     raw = await readFile(resolvedPath, "utf-8");
@@ -7886,12 +9428,15 @@ var MCPGenerator = class _MCPGenerator {
   /**
    * Select the `PlatformAnalyzer` implementation for a `.appilotsrc`
    * `platform` value. `'react-native'` (or unset — the existing default)
-   * gets the real Babel/JSX pipeline; anything else gets the no-op
-   * generic analyzer, relying entirely on a declared manifest.
+   * gets the RN Babel/JSX pipeline; `'web'` gets the React web (DOM +
+   * React Router) pipeline; anything else gets the no-op generic
+   * analyzer, relying entirely on a declared manifest. The manifest
+   * still merges on top of every analyzer's output either way.
    */
   static createPlatformAnalyzer(platform) {
     const resolved = platform ?? "react-native";
     if (resolved === "react-native") return new ReactNativePlatformAnalyzer();
+    if (resolved === "web") return new ReactWebPlatformAnalyzer();
     return new GenericPlatformAnalyzer(resolved);
   }
   /** Generate MCP documents from the project */
@@ -7944,13 +9489,13 @@ var MCPGenerator = class _MCPGenerator {
     };
     const serialized = JSON.stringify(document, null, 2);
     const checksum = this.calculateChecksum(serialized);
-    const filePath = path6__default.resolve(
+    const filePath = path8__default.resolve(
       outputDir,
       `mcp-document.${this.options.format}`
     );
     await writeFile(filePath, serialized, "utf-8");
     console.log(`[MCPGenerator] Document written to: ${filePath}`);
-    const checksumFilePath = path6__default.resolve(outputDir, ".appilots-checksum");
+    const checksumFilePath = path8__default.resolve(outputDir, ".appilots-checksum");
     await writeFile(checksumFilePath, checksum, "utf-8");
     console.log(`[MCPGenerator] Checksum written to: ${checksumFilePath}`);
     console.log("[MCPGenerator] Generation complete!");
@@ -7970,7 +9515,7 @@ var MCPGenerator = class _MCPGenerator {
    * after calling `generate()`.
    */
   static async readPreviousChecksum(outputDir) {
-    const checksumFilePath = path6__default.resolve(outputDir, ".appilots-checksum");
+    const checksumFilePath = path8__default.resolve(outputDir, ".appilots-checksum");
     try {
       const content = await readFile(checksumFilePath, "utf-8");
       return content.trim() || null;
@@ -7989,7 +9534,7 @@ var MCPGenerator = class _MCPGenerator {
    */
   async getProjectInfo() {
     try {
-      const packageJsonPath = path6__default.resolve(this.analyzerConfig.rootDir, "package.json");
+      const packageJsonPath = path8__default.resolve(this.analyzerConfig.rootDir, "package.json");
       const packageJsonContent = await readFile(packageJsonPath, "utf-8");
       const packageJson = JSON.parse(packageJsonContent);
       return {
@@ -8375,6 +9920,6 @@ var AppilotsAPIClient = class {
   }
 };
 
-export { AppilotsAPIClient, ComponentAnalyzer, DEFAULT_MANIFEST_FILENAME, FormAnalyzer, GenericPlatformAnalyzer, MCPGenerator, NavigationAnalyzer, ReactNativePlatformAnalyzer, ScreenAnalyzer, formatMetadataWarnings, getConfigPath, getEnvOverrides, lintActionMetadata, loadConfig, loadManifest, mergeManifestNavigation, mergeManifestScreens, saveConfig, validateConfig };
+export { AppilotsAPIClient, ComponentAnalyzer, DEFAULT_MANIFEST_FILENAME, DEFAULT_WEB_SCREEN_PATTERNS, FormAnalyzer, GenericPlatformAnalyzer, MCPGenerator, NavigationAnalyzer, ReactNativePlatformAnalyzer, ReactWebPlatformAnalyzer, ScreenAnalyzer, WebNavigationAnalyzer, WebScreenAnalyzer, formatMetadataWarnings, getConfigPath, getEnvOverrides, lintActionMetadata, loadConfig, loadManifest, mergeManifestNavigation, mergeManifestScreens, resolvePathToScreen, saveConfig, screenNameFromPath, validateConfig };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map