@appilots/cli 0.11.0 → 0.13.0

package/dist/index.js

@@ -1,13 +1,13 @@
 'use strict';
 
 var fs = require('fs/promises');
-var path8 = require('path');
-var traverse4 = require('@babel/traverse');
+var crypto = require('crypto');
+var traverse5 = require('@babel/traverse');
 var BabelTypes = require('@babel/types');
-var glob = require('fast-glob');
+var path2 = require('path');
+var fastGlob = require('fast-glob');
 var parser = require('@babel/parser');
 var fs$1 = require('fs');
-var crypto = require('crypto');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -30,10 +30,10 @@ function _interopNamespace(e) {
 }
 
 var fs__default = /*#__PURE__*/_interopDefault(fs);
-var path8__namespace = /*#__PURE__*/_interopNamespace(path8);
-var traverse4__default = /*#__PURE__*/_interopDefault(traverse4);
+var traverse5__default = /*#__PURE__*/_interopDefault(traverse5);
 var BabelTypes__namespace = /*#__PURE__*/_interopNamespace(BabelTypes);
-var glob__default = /*#__PURE__*/_interopDefault(glob);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var fastGlob__default = /*#__PURE__*/_interopDefault(fastGlob);
 var parser__namespace = /*#__PURE__*/_interopNamespace(parser);
 
 var __defProp = Object.defineProperty;
@@ -41,6 +41,350 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var MAX_HOPS = 8;
+function unwrap(path11) {
+  while (path11.isTSAsExpression() || path11.isTSTypeAssertion() || path11.isTSNonNullExpression() || path11.isTSSatisfiesExpression() || path11.isParenthesizedExpression())
+    path11 = path11.get("expression");
+  return path11;
+}
+function constantValue(path11, depth = 0) {
+  if (depth > MAX_HOPS) return void 0;
+  path11 = unwrap(path11);
+  if (!path11.isIdentifier()) return path11;
+  const binding = path11.scope.getBinding(path11.node.name);
+  if (!binding?.constant || !binding.path.isVariableDeclarator()) return path11;
+  const init = binding.path.get("init");
+  const resolved = init.node ? constantValue(init, depth + 1) : void 0;
+  if (resolved?.isObjectExpression() && binding.referencePaths.some(
+    (reference) => !reference.parentPath?.isJSXSpreadAttribute() && !reference.parentPath?.isSpreadElement()
+  ))
+    return void 0;
+  return resolved;
+}
+function propValue(path11, name) {
+  const readObject = (path12) => {
+    const resolved = constantValue(path12);
+    if (!resolved?.isObjectExpression()) return { blocked: true };
+    for (const property of [...resolved.get("properties")].reverse()) {
+      if (property.isSpreadElement()) {
+        const found = readObjectBounded(property.get("argument"));
+        if (found.value || found.blocked) return found;
+      } else if (property.isObjectProperty() || property.isObjectMethod()) {
+        if (property.node.computed) return { blocked: true };
+        const key = property.node.key;
+        if ((BabelTypes__namespace.isIdentifier(key) ? key.name : BabelTypes__namespace.isStringLiteral(key) ? key.value : "") === name)
+          return property.isObjectProperty() ? { value: property.get("value") } : { value: property };
+      }
+    }
+    return {};
+  };
+  let objectBudget = MAX_HOPS;
+  const readObjectBounded = (path12) => objectBudget-- > 0 ? readObject(path12) : { blocked: true };
+  for (const attr of [...path11.get("attributes")].reverse()) {
+    if (attr.isJSXAttribute() && BabelTypes__namespace.isJSXIdentifier(attr.node.name, { name })) {
+      const value = attr.get("value");
+      return value.isJSXExpressionContainer() ? unwrap(value.get("expression")) : value.node ? value : void 0;
+    }
+    if (attr.isJSXSpreadAttribute()) {
+      const found = readObjectBounded(attr.get("argument"));
+      if (found.value || found.blocked) return found.value;
+    }
+  }
+  return void 0;
+}
+function importIdentity(path11, depth = 0) {
+  if (depth > MAX_HOPS) return void 0;
+  path11 = unwrap(path11);
+  if (path11.isIdentifier() || path11.isJSXIdentifier()) {
+    const binding = path11.scope.getBinding(path11.node.name);
+    if (!binding?.constant) return void 0;
+    const declaration = binding.path;
+    if (declaration.parentPath?.isImportDeclaration()) {
+      const module = declaration.parentPath.node.source.value;
+      if (declaration.isImportSpecifier()) {
+        const imported = declaration.node.imported;
+        return { module, imported: BabelTypes__namespace.isIdentifier(imported) ? imported.name : imported.value };
+      }
+      if (declaration.isImportDefaultSpecifier()) return { module, imported: "default" };
+      if (declaration.isImportNamespaceSpecifier()) return { module, imported: "*" };
+    }
+    if (declaration.isVariableDeclarator() && declaration.get("init").node)
+      return importIdentity(declaration.get("init"), depth + 1);
+  }
+  if (path11.isJSXMemberExpression() || path11.isMemberExpression() && !path11.node.computed) {
+    const origin = importIdentity(path11.get("object"), depth + 1);
+    const key = path11.node.property;
+    if (origin && (BabelTypes__namespace.isIdentifier(key) || BabelTypes__namespace.isJSXIdentifier(key)) && (origin.imported === "*" || origin.module === "react" && origin.imported === "default"))
+      return { module: origin.module, imported: key.name };
+  }
+  return void 0;
+}
+function handlerFunction(path11, depth = 0) {
+  if (depth > MAX_HOPS) return void 0;
+  path11 = unwrap(path11);
+  if (path11.isFunction()) return path11;
+  if (path11.isIdentifier()) {
+    const binding = path11.scope.getBinding(path11.node.name);
+    if (!binding?.constant) return void 0;
+    if (binding.path.isFunctionDeclaration()) return binding.path;
+    if (binding.path.isVariableDeclarator() && binding.path.get("init").node)
+      return handlerFunction(binding.path.get("init"), depth + 1);
+  }
+  if (path11.isCallExpression()) {
+    const origin = importIdentity(path11.get("callee"));
+    if (origin?.module === "react" && origin.imported === "useCallback") {
+      const callback = path11.get("arguments")[0];
+      if (callback) return handlerFunction(callback, depth + 1);
+    }
+  }
+  if (path11.isMemberExpression() && !path11.node.computed && BabelTypes__namespace.isThisExpression(path11.node.object)) {
+    const key = path11.node.property;
+    if (!BabelTypes__namespace.isIdentifier(key)) return void 0;
+    const owner = path11.findParent((p) => p.isClassDeclaration() || p.isClassExpression());
+    if (!owner || !(owner.isClassDeclaration() || owner.isClassExpression())) return void 0;
+    for (const member of owner.get("body").get("body")) {
+      if (!(member.isClassMethod() || member.isClassProperty()) || member.node.computed || member.node.static)
+        continue;
+      if (!BabelTypes__namespace.isIdentifier(member.node.key, { name: key.name })) continue;
+      if (member.isClassMethod() && member.node.kind === "method") return member;
+      if (member.isClassProperty() && member.get("value").node)
+        return handlerFunction(member.get("value"), depth + 1);
+    }
+  }
+  return void 0;
+}
+
+// src/extractors/control-evidence.ts
+function symbol(node) {
+  if (BabelTypes__namespace.isTSAsExpression(node) || BabelTypes__namespace.isTSTypeAssertion(node) || BabelTypes__namespace.isTSNonNullExpression(node) || BabelTypes__namespace.isTSSatisfiesExpression(node))
+    return symbol(node.expression);
+  if (BabelTypes__namespace.isIdentifier(node) || BabelTypes__namespace.isJSXIdentifier(node)) return node.name;
+  if (BabelTypes__namespace.isThisExpression(node)) return "this";
+  if (BabelTypes__namespace.isMemberExpression(node) && !node.computed || BabelTypes__namespace.isJSXMemberExpression(node)) {
+    const object = symbol(node.object), property = symbol(node.property);
+    return object && property ? `${object}.${property}` : void 0;
+  }
+  if (BabelTypes__namespace.isUnaryExpression(node) && node.operator === "!") {
+    const value = symbol(node.argument);
+    return value ? `!${value}` : void 0;
+  }
+  return void 0;
+}
+function attribute(node, name) {
+  return node.attributes.find(
+    (a) => BabelTypes__namespace.isJSXAttribute(a) && BabelTypes__namespace.isJSXIdentifier(a.name, { name })
+  );
+}
+var ICON_LIBRARIES = [
+  "lucide-react-native",
+  "lucide-react",
+  "@tamagui/lucide-icons",
+  "@expo/vector-icons",
+  "@react-native-vector-icons/",
+  "react-native-vector-icons/"
+];
+function iconLibrary(module) {
+  return ICON_LIBRARIES.some(
+    (name) => name.endsWith("/") ? module.startsWith(name) : module === name || module.startsWith(name + "/")
+  );
+}
+function add(values, value, max = 12) {
+  if (value && value.length <= 240 && values.length < max && !values.includes(value))
+    values.push(value);
+}
+function iconName(path11, explicitIcon = false) {
+  const origin = importIdentity(path11);
+  if (origin && iconLibrary(origin.module) && origin.imported !== "*")
+    return origin.imported === "default" ? origin.module : `${origin.module}:${origin.imported}`;
+  const name = symbol(path11.node);
+  return name && (explicitIcon || /icon/i.test(name)) ? name : void 0;
+}
+function iconsInElement(path11, explicitIcon = false) {
+  const name = iconName(path11.get("name"), explicitIcon);
+  if (!name) return void 0;
+  const glyph = propValue(path11, "name");
+  const value = glyph && constantValue(glyph);
+  return value?.isStringLiteral() ? `${name}:${value.node.value}` : name;
+}
+function hasInteraction(path11) {
+  return ["onPress", "onLongPress", "onClick"].some(
+    (name) => attribute(path11.node, name) || propValue(path11, name)
+  );
+}
+function collectPresentationIcons(path11, icons) {
+  const namedIconProps = [
+    "icon",
+    "prefix",
+    "suffix",
+    "left",
+    "right",
+    "leadingIcon",
+    "trailingIcon",
+    "startIcon",
+    "endIcon",
+    "renderIcon"
+  ];
+  const props = new Set(namedIconProps);
+  for (const attr of path11.node.attributes)
+    if (BabelTypes__namespace.isJSXAttribute(attr) && BabelTypes__namespace.isJSXIdentifier(attr.name) && !/^on[A-Z]/.test(attr.name.name))
+      props.add(attr.name.name);
+  for (const prop of props) {
+    const icon = propValue(path11, prop);
+    if (icon) {
+      const value = constantValue(icon);
+      if (value?.isStringLiteral()) {
+        if (prop.toLowerCase().includes("icon")) add(icons, value.node.value, 8);
+      } else {
+        const explicitIcon = prop.toLowerCase() === "icon";
+        if (icon.isJSXElement()) {
+          if (hasInteraction(icon.get("openingElement"))) continue;
+          add(icons, iconsInElement(icon.get("openingElement"), explicitIcon), 8);
+        }
+        icon.traverse({
+          JSXAttribute(attr) {
+            if (BabelTypes__namespace.isJSXIdentifier(attr.node.name) && /^on[A-Z]/.test(attr.node.name.name))
+              attr.skip();
+          },
+          JSXElement(child) {
+            const opening = child.get("openingElement");
+            if (hasInteraction(opening)) {
+              child.skip();
+              return;
+            }
+            add(icons, iconsInElement(opening, explicitIcon), 8);
+          }
+        });
+        if (!icons.length && (namedIconProps.includes(prop) || explicitIcon))
+          add(icons, iconName(icon, explicitIcon), 8);
+      }
+    }
+  }
+}
+function collectIcons(path11) {
+  const icons = [];
+  collectPresentationIcons(path11, icons);
+  const jsx = path11.parentPath;
+  if (jsx.isJSXElement())
+    jsx.traverse({
+      // JSX mentioned inside an event callback is not a rendered child icon.
+      JSXAttribute(attr) {
+        attr.skip();
+      },
+      JSXElement(child) {
+        const opening = child.get("openingElement");
+        if (hasInteraction(opening)) {
+          child.skip();
+          return;
+        }
+        add(icons, iconsInElement(opening), 8);
+        collectPresentationIcons(opening, icons);
+      }
+    });
+  return icons;
+}
+function conditionsAt(path11) {
+  const conditions = [];
+  let child = path11;
+  for (let parent = child.parentPath; parent && !parent.isFunction(); child = parent, parent = parent.parentPath) {
+    let test;
+    let negated = false;
+    if (parent.isLogicalExpression() && parent.node.right === child.node) {
+      if (parent.node.operator === "&&") test = parent.node.left;
+      if (parent.node.operator === "||") {
+        test = parent.node.left;
+        negated = true;
+      }
+    } else if (parent.isConditionalExpression() && parent.node.test !== child.node) {
+      test = parent.node.test;
+      negated = parent.node.alternate === child.node;
+    } else if (parent.isIfStatement() && parent.node.test !== child.node) {
+      test = parent.node.test;
+      negated = parent.node.alternate === child.node;
+    }
+    const name = symbol(test);
+    if (name) add(conditions, negated ? name.startsWith("!") ? name.slice(1) : `!${name}` : name);
+  }
+  return conditions;
+}
+function collectHandlerEvidence(expression, evidence) {
+  const seen = /* @__PURE__ */ new Set();
+  let budget = 100;
+  const visit = (path11, depth) => {
+    if (depth > 4 || budget-- <= 0) return;
+    const fn = handlerFunction(path11);
+    if (!fn || seen.has(fn.node)) return;
+    seen.add(fn.node);
+    fn.traverse({
+      // Ignore uncalled helper definitions; inline callbacks remain source evidence.
+      Function(nested) {
+        if (!nested.parentPath.isCallExpression() && !nested.parentPath.isObjectProperty())
+          nested.skip();
+      },
+      CallExpression(call) {
+        if (budget-- <= 0) {
+          call.skip();
+          return;
+        }
+        add(evidence.calls, symbol(call.node.callee));
+        for (const arg of call.node.arguments) add(evidence.argumentBindings, symbol(arg));
+        visit(call.get("callee"), depth + 1);
+        if (!BabelTypes__namespace.isMemberExpression(call.node.callee) || call.node.callee.computed || !BabelTypes__namespace.isIdentifier(call.node.callee.property, { name: "alert" }))
+          return;
+        const callee = call.get("callee");
+        if (!callee.isMemberExpression()) return;
+        const origin = importIdentity(callee.get("object"));
+        if (origin?.module !== "react-native" || origin.imported !== "Alert") return;
+        const options = call.node.arguments[2];
+        const destructiveOption = BabelTypes__namespace.isArrayExpression(options) && options.elements.some(
+          (option) => BabelTypes__namespace.isObjectExpression(option) && option.properties.some(
+            (p) => BabelTypes__namespace.isObjectProperty(p) && !p.computed && symbol(p.key) === "style" && BabelTypes__namespace.isStringLiteral(p.value, { value: "destructive" })
+          )
+        );
+        if (destructiveOption)
+          evidence.nativeConfirmation = {
+            title: symbol(call.node.arguments[0]),
+            destructiveOption
+          };
+      }
+    });
+  };
+  visit(unwrap(expression), 0);
+}
+function extractControlEvidence(ast, source, file) {
+  const candidates = [];
+  const sourceHash = crypto.createHash("sha256").update(source).digest("hex");
+  traverse5__default.default(ast, {
+    JSXOpeningElement(path11) {
+      const node = path11.node;
+      if (attribute(node, "__appilotsControl")) return;
+      const value = propValue(path11, "onPress");
+      if (!value && !attribute(node, "onPress") || value?.isNullLiteral() || value?.isJSXEmptyExpression())
+        return;
+      const icons = collectIcons(path11);
+      if (!icons.length || node.end == null) return;
+      const evidence = {
+        version: 1,
+        siteId: crypto.createHash("sha256").update(`${file}:${sourceHash}:${node.start}`).digest("hex").slice(0, 20),
+        component: symbol(node.name) ?? "unknown",
+        icons,
+        ...value && symbol(value.node) ? { handler: symbol(value.node) } : {},
+        calls: [],
+        argumentBindings: [],
+        conditions: conditionsAt(path11)
+      };
+      if (value) collectHandlerEvidence(value, evidence);
+      candidates.push({ evidence, sourceHash, offset: node.end - (node.selfClosing ? 2 : 1) });
+    }
+  });
+  return candidates;
+}
+function byCodeUnit(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+async function globSorted(patterns, options) {
+  const files = await fastGlob__default.default(patterns, options);
+  return files.sort(byCodeUnit);
+}
 var DEFAULT_PARSER_PLUGINS = [
   "jsx",
   "typescript",
@@ -155,7 +499,7 @@ function classifyJsxComponent(name, element) {
 }
 function collectFunctions(ast) {
   const handlers = /* @__PURE__ */ new Map();
-  traverse4__default.default(ast, {
+  traverse5__default.default(ast, {
     FunctionDeclaration: (nodePath) => {
       if (nodePath.node.id?.name) handlers.set(nodePath.node.id.name, nodePath.node);
     },
@@ -258,7 +602,7 @@ function analyzeFunctionBehavior(name, fn, handlers, seen = /* @__PURE__ */ new
     }
   };
   if (fn.body) {
-    traverse4__default.default(fn.body, {
+    traverse5__default.default(fn.body, {
       noScope: true,
       enter: (nodePath) => inspectNode(nodePath.node)
     });
@@ -286,7 +630,7 @@ function setterToStateName(setterName) {
 }
 function extractNavigationCalls(ast) {
   const calls = [];
-  traverse4__default.default(ast, {
+  traverse5__default.default(ast, {
     noScope: !BabelTypes__namespace.isFile(ast),
     CallExpression: (nodePath) => {
       const node = nodePath.node;
@@ -425,14 +769,26 @@ var ScreenAnalyzer = class {
   strictScreens;
   /** Glob patterns that identify screen files in strict mode */
   screenPatterns;
+  /**
+   * Arquivos que uma ROTA monta (`component={…}` resolvido pelo
+   * `NavigationAnalyzer`). Passam pelo filtro estrito sem depender de
+   * convenção de nome, porque um componente que uma rota monta É uma tela por
+   * definição — não é heurística, é o que o app declarou.
+   *
+   * É isto que resolve o caso `rocketchat`, cujas telas se chamam `*View.tsx`
+   * em `app/views/`, e o `coopcycle`, que não tem diretório `screens/` nenhum.
+   */
+  routeTargetFiles;
   /** §D: Count of screens filtered out in strict mode (available after analyze()) */
   screensFilteredOut = 0;
+  controlEvidenceFiles = {};
   constructor(config, options) {
     this.config = config;
+    this.routeTargetFiles = options?.routeTargetFiles ?? /* @__PURE__ */ new Set();
     this.strictScreens = options?.strictScreens ?? false;
     this.screenPatterns = options?.screenPatterns ?? [
-      "**/*Screen.{ts,tsx}",
-      "**/screens/**/*.{ts,tsx}"
+      "**/*Screen.{ts,tsx,js,jsx}",
+      "**/screens/**/*.{ts,tsx,js,jsx}"
     ];
   }
   /** Analyze all screens in the project */
@@ -444,7 +800,7 @@ var ScreenAnalyzer = class {
         console.log(`[ScreenAnalyzer] Strict mode ON \u2014 screen patterns:`, this.screenPatterns);
       }
     }
-    const files = await glob__default.default(include, {
+    const files = await globSorted(include, {
       cwd: this.config.rootDir,
       ignore: exclude
     });
@@ -453,23 +809,24 @@ var ScreenAnalyzer = class {
     }
     let screenPatternFiles = null;
     if (this.strictScreens) {
-      const matched = await glob__default.default(this.screenPatterns, {
+      const matched = await globSorted(this.screenPatterns, {
         cwd: this.config.rootDir,
         ignore: exclude
       });
-      screenPatternFiles = new Set(matched.map((f) => path8__namespace.default.resolve(this.config.rootDir, f)));
+      screenPatternFiles = new Set(matched.map((f) => path2__namespace.default.resolve(this.config.rootDir, f)));
     }
     const screens = [];
     this.screensFilteredOut = 0;
     for (const file of files) {
-      const filePath = path8__namespace.default.resolve(this.config.rootDir, file);
+      const filePath = path2__namespace.default.resolve(this.config.rootDir, file);
       try {
         const descriptor = await this.analyzeFile(filePath);
         if (!descriptor) continue;
         if (this.strictScreens) {
           const hasRegisterScreen = descriptor.__hasRegisterScreen === true;
           const matchesPattern = screenPatternFiles?.has(filePath) ?? false;
-          if (!hasRegisterScreen && !matchesPattern) {
+          const isRouteTarget = this.routeTargetFiles.has(filePath);
+          if (!hasRegisterScreen && !matchesPattern && !isRouteTarget) {
             this.screensFilteredOut++;
             if (this.verbose) {
               console.log(`[ScreenAnalyzer] \u2717 Filtered (strict): ${file}`);
@@ -525,6 +882,11 @@ var ScreenAnalyzer = class {
       title: registerScreenMeta?.title,
       description: registerScreenMeta?.description,
       components,
+      controlCandidates: extractControlEvidence(
+        ast,
+        source,
+        path2__namespace.default.relative(this.config.rootDir, filePath)
+      ),
       forms,
       actions,
       navigationTargets,
@@ -535,6 +897,8 @@ var ScreenAnalyzer = class {
         ...permissionsFromJsDoc.isPii ? { isPii: true } : {}
       } : {}
     };
+    if (descriptor.controlCandidates?.length)
+      this.controlEvidenceFiles[path2__namespace.default.relative(this.config.rootDir, filePath).split(path2__namespace.default.sep).join("/")] = descriptor.controlCandidates;
     descriptor.__hasRegisterScreen = hasRegisterScreenCall;
     return descriptor;
   }
@@ -544,7 +908,7 @@ var ScreenAnalyzer = class {
    */
   detectRegisterScreenCall(ast) {
     let found = false;
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       CallExpression: (nodePath) => {
         if (found) return;
         const callee = nodePath.node.callee;
@@ -561,7 +925,7 @@ var ScreenAnalyzer = class {
    */
   extractRegisterScreenMetadata(ast) {
     let metadata = null;
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       CallExpression: (nodePath) => {
         const callee = nodePath.node.callee;
         if (BabelTypes__namespace.isIdentifier(callee) && callee.name === "registerScreen" || BabelTypes__namespace.isMemberExpression(callee) && BabelTypes__namespace.isIdentifier(callee.property) && callee.property.name === "registerScreen") {
@@ -677,6 +1041,8 @@ var ScreenAnalyzer = class {
         action.riskLevel = value.value;
       } else if (key === "nativeConfirmationExpected" && BabelTypes__namespace.isBooleanLiteral(value)) {
         action.nativeConfirmationExpected = value.value;
+      } else if (key === "asyncBudgetMs" && BabelTypes__namespace.isNumericLiteral(value) && Number.isInteger(value.value) && value.value > 0) {
+        action.asyncBudgetMs = value.value;
       } else if (key === "appilotsInferred" && BabelTypes__namespace.isObjectExpression(value)) {
         action.appilotsInferred = this.parseAppilotsInferredObject(value);
       }
@@ -856,7 +1222,7 @@ var ScreenAnalyzer = class {
    */
   extractDefaultComponentName(ast) {
     let componentName = "";
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       ExportDefaultDeclaration: (nodePath) => {
         const declaration = nodePath.node.declaration;
         if (BabelTypes__namespace.isFunctionDeclaration(declaration) && declaration.id?.name) {
@@ -881,7 +1247,7 @@ var ScreenAnalyzer = class {
    */
   extractNavigationTargets(ast) {
     const targets = /* @__PURE__ */ new Set();
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       CallExpression: (nodePath) => {
         const callee = nodePath.node.callee;
         if (BabelTypes__namespace.isMemberExpression(callee) && BabelTypes__namespace.isIdentifier(callee.object) && callee.object.name === "navigation" && BabelTypes__namespace.isIdentifier(callee.property) && callee.property.name === "navigate") {
@@ -900,7 +1266,7 @@ var ScreenAnalyzer = class {
   extractForms(ast) {
     const forms = [];
     const fields = /* @__PURE__ */ new Map();
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         if (BabelTypes__namespace.isJSXIdentifier(element.name)) {
@@ -1021,7 +1387,7 @@ var ScreenAnalyzer = class {
   extractComponents(ast) {
     const components = [];
     const seen = /* @__PURE__ */ new Set();
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         if (BabelTypes__namespace.isJSXIdentifier(element.name)) {
@@ -1085,7 +1451,7 @@ var ScreenAnalyzer = class {
     const actionLabels = new Map(
       actions.filter((a) => a.label).map((a) => [this.normalizeLabel(a.label), a])
     );
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         if (BabelTypes__namespace.isJSXIdentifier(element.name)) {
@@ -1154,7 +1520,7 @@ var ScreenAnalyzer = class {
   }
   collectButtonHandlersByLabel(ast) {
     const out = /* @__PURE__ */ new Map();
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         if (!BabelTypes__namespace.isJSXIdentifier(element.name)) return;
@@ -1236,7 +1602,7 @@ var ScreenAnalyzer = class {
       }
     };
     if (fn.body) {
-      traverse4__default.default(
+      traverse5__default.default(
         fn.body,
         {
           noScope: true,
@@ -1433,7 +1799,7 @@ var ScreenAnalyzer = class {
   extractCollections(ast) {
     const renderItemFns = this.collectRenderItemFunctions(ast);
     const collections = [];
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         if (!BabelTypes__namespace.isJSXIdentifier(element.name)) return;
@@ -1470,7 +1836,7 @@ var ScreenAnalyzer = class {
   }
   collectRenderItemFunctions(ast) {
     const out = /* @__PURE__ */ new Map();
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       VariableDeclarator: (nodePath) => {
         if (!BabelTypes__namespace.isIdentifier(nodePath.node.id)) return;
         const init = nodePath.node.init;
@@ -1513,7 +1879,7 @@ var ScreenAnalyzer = class {
   }
   extractRowAction(fn) {
     let action;
-    traverse4__default.default(
+    traverse5__default.default(
       fn.body,
       {
         noScope: true,
@@ -1566,7 +1932,7 @@ var ScreenAnalyzer = class {
     } else if (BabelTypes__namespace.isIdentifier(firstParam)) {
       itemNames.add(firstParam.name);
     }
-    traverse4__default.default(
+    traverse5__default.default(
       fn.body,
       {
         noScope: true,
@@ -1608,7 +1974,7 @@ var ScreenAnalyzer = class {
   inferSearchField(ast, dataSource) {
     if (!dataSource) return void 0;
     let queryBinding;
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       CallExpression: (nodePath) => {
         const node = nodePath.node;
         if (!BabelTypes__namespace.isMemberExpression(node.callee)) return;
@@ -1619,7 +1985,7 @@ var ScreenAnalyzer = class {
         const fn = node.arguments[0];
         if (!BabelTypes__namespace.isArrowFunctionExpression(fn) && !BabelTypes__namespace.isFunctionExpression(fn))
           return;
-        traverse4__default.default(
+        traverse5__default.default(
           fn.body,
           {
             noScope: true,
@@ -1656,43 +2022,871 @@ var ScreenAnalyzer = class {
    * E.g., /src/screens/ItemListScreen.tsx -> ItemListScreen
    */
   extractScreenName(filePath) {
-    const basename2 = path8__namespace.default.basename(filePath);
+    const basename2 = path2__namespace.default.basename(filePath);
     return basename2.replace(/\.(tsx?|jsx?)$/, "");
   }
 };
+var EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
+var MAX_HOPS2 = 8;
+var ModuleGraph = class {
+  asts = /* @__PURE__ */ new Map();
+  resolved = /* @__PURE__ */ new Map();
+  /** `@src/*` → `<root>/src/*`, lido do tsconfig do app. */
+  aliases;
+  /** `uniswap` → `<repo>/packages/uniswap`, lido do workspace do monorepo. */
+  workspacePackages;
+  constructor(rootDir) {
+    this.aliases = rootDir ? readTsconfigAliases(rootDir) : [];
+    this.workspacePackages = rootDir ? readWorkspacePackages(rootDir) : [];
+  }
+  /** AST de um arquivo, memoizada. `null` quando não parseia. */
+  parse(file) {
+    const cached = this.asts.get(file);
+    if (cached !== void 0) return cached;
+    let ast = null;
+    try {
+      ast = parser__namespace.parse(fs$1.readFileSync(file, "utf-8"), {
+        sourceType: "module",
+        plugins: ["jsx", "typescript"]
+      });
+    } catch {
+      ast = null;
+    }
+    this.asts.set(file, ast);
+    return ast;
+  }
+  /**
+   * `./account/Home` a partir de `src/navigation/index.tsx` → caminho absoluto.
+   * Só resolve caminho relativo: import de pacote (`@react-navigation/native`)
+   * é de terceiro e não tem tela nossa dentro.
+   */
+  resolve(fromFile, spec) {
+    const key = `${fromFile} ${spec}`;
+    const cached = this.resolved.get(key);
+    if (cached !== void 0) return cached;
+    let base = null;
+    if (spec.startsWith(".")) {
+      base = path2__namespace.default.resolve(path2__namespace.default.dirname(fromFile), spec);
+    } else {
+      for (const { prefix, target } of this.aliases) {
+        if (spec === prefix || spec.startsWith(prefix + "/")) {
+          base = path2__namespace.default.join(target, spec.slice(prefix.length));
+          break;
+        }
+      }
+      if (!base) {
+        for (const pkg of this.workspacePackages) {
+          if (spec === pkg.name || spec.startsWith(pkg.name + "/")) {
+            base = path2__namespace.default.join(pkg.dir, spec.slice(pkg.name.length));
+            break;
+          }
+        }
+      }
+    }
+    if (!base) {
+      this.resolved.set(key, null);
+      return null;
+    }
+    const candidates = [
+      base,
+      ...EXTENSIONS.map((e) => base + e),
+      ...EXTENSIONS.map((e) => path2__namespace.default.join(base, "index" + e))
+    ];
+    let found = null;
+    for (const c of candidates) {
+      try {
+        if (fs$1.existsSync(c) && fs$1.statSync(c).isFile()) {
+          found = c;
+          break;
+        }
+      } catch {
+      }
+    }
+    this.resolved.set(key, found);
+    return found;
+  }
+  /** `import`s do arquivo, por nome local. */
+  imports(file) {
+    const out = /* @__PURE__ */ new Map();
+    const ast = this.parse(file);
+    if (!ast) return out;
+    for (const stmt of ast.program.body) {
+      if (!BabelTypes__namespace.isImportDeclaration(stmt)) continue;
+      const source = stmt.source.value;
+      for (const spec of stmt.specifiers) {
+        if (BabelTypes__namespace.isImportDefaultSpecifier(spec)) {
+          out.set(spec.local.name, { source, imported: "default" });
+        } else if (BabelTypes__namespace.isImportNamespaceSpecifier(spec)) {
+          out.set(spec.local.name, { source, imported: "*" });
+        } else if (BabelTypes__namespace.isImportSpecifier(spec)) {
+          const imported = BabelTypes__namespace.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+          out.set(spec.local.name, { source, imported });
+        }
+      }
+    }
+    return out;
+  }
+  /** `const X = <init>` no topo do arquivo, incluindo `export const`. */
+  topLevelInit(file, name) {
+    const ast = this.parse(file);
+    if (!ast) return null;
+    for (const stmt of ast.program.body) {
+      const decl = BabelTypes__namespace.isExportNamedDeclaration(stmt) ? stmt.declaration : stmt;
+      if (!BabelTypes__namespace.isVariableDeclaration(decl)) continue;
+      for (const d of decl.declarations) {
+        if (BabelTypes__namespace.isIdentifier(d.id) && d.id.name === name && d.init) {
+          return BabelTypes__namespace.isTSAsExpression(d.init) ? d.init.expression : d.init;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Onde `name` é DEFINIDO — segue import e reexport de barrel.
+   * Devolve o arquivo e o nome sob o qual ele é definido lá.
+   */
+  resolveBinding(file, name, hops = 0) {
+    if (hops > MAX_HOPS2) return null;
+    if (this.topLevelInit(file, name) !== null) return { file, name };
+    const binding = this.imports(file).get(name);
+    if (binding) {
+      const target = this.resolve(file, binding.source);
+      if (!target) return null;
+      const next = binding.imported === "default" || binding.imported === "*" ? name : binding.imported;
+      const deeper = this.resolveBinding(target, next, hops + 1);
+      return deeper ?? { file: target, name: next };
+    }
+    const ast = this.parse(file);
+    if (ast) {
+      for (const stmt of ast.program.body) {
+        if (!BabelTypes__namespace.isExportNamedDeclaration(stmt) || !stmt.source) continue;
+        for (const spec of stmt.specifiers) {
+          if (!BabelTypes__namespace.isExportSpecifier(spec)) continue;
+          const exported = BabelTypes__namespace.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value;
+          if (exported !== name) continue;
+          const target = this.resolve(file, stmt.source.value);
+          if (!target) return null;
+          const local = spec.local.name;
+          return this.resolveBinding(target, local, hops + 1) ?? { file: target, name: local };
+        }
+      }
+    }
+    if (ast) {
+      for (const stmt of ast.program.body) {
+        if (!BabelTypes__namespace.isExportAllDeclaration(stmt)) continue;
+        const target = this.resolve(file, stmt.source.value);
+        if (!target || target === file) continue;
+        const deeper = this.resolveBinding(target, name, hops + 1);
+        if (deeper) return deeper;
+      }
+    }
+    if (ast) {
+      for (const stmt of ast.program.body) {
+        if (!BabelTypes__namespace.isExportDefaultDeclaration(stmt)) continue;
+        if (BabelTypes__namespace.isIdentifier(stmt.declaration)) {
+          const local = stmt.declaration.name;
+          if (local === name) return null;
+          return this.resolveBinding(file, local, hops + 1) ?? { file, name: local };
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * O valor string de uma expressão de nome de rota, ou `null`.
+   *
+   * Cobre `"Chat"`, `ROUTES.CHAT`, `ROUTES.ONBOARDING.SPLASH` e `SOME_CONST` —
+   * seguindo import quando o objeto vem de outro arquivo. NÃO cobre template
+   * com interpolação nem valor calculado, de propósito.
+   */
+  stringConstant(file, node, hops = 0) {
+    if (!node || hops > MAX_HOPS2) return null;
+    if (BabelTypes__namespace.isStringLiteral(node)) return node.value;
+    if (BabelTypes__namespace.isTemplateLiteral(node)) {
+      return node.expressions.length === 0 ? node.quasis[0]?.value.cooked ?? null : null;
+    }
+    if (BabelTypes__namespace.isTSAsExpression(node)) return this.stringConstant(file, node.expression, hops + 1);
+    const chain = memberChain(node);
+    if (!chain) return null;
+    const origin = this.resolveBinding(file, chain.root);
+    if (!origin) return null;
+    let current = this.topLevelInit(origin.file, origin.name);
+    if (!current) return null;
+    for (const key of chain.path) {
+      if (!BabelTypes__namespace.isObjectExpression(current)) return null;
+      const prop = objectProperty(current, key);
+      if (!prop) return null;
+      current = BabelTypes__namespace.isTSAsExpression(prop) ? prop.expression : prop;
+    }
+    return BabelTypes__namespace.isStringLiteral(current) ? current.value : null;
+  }
+  /**
+   * O ARQUIVO onde vive o componente de uma rota, ou `null`.
+   *
+   * Aceita as três formas que o corpus mostrou: identificador
+   * (`component={Home}`), membro de barrel (`component={screens.AccountHome}`)
+   * e componente embrulhado em HOC (`component={gestureHandlerRootHOC(Chat)}`,
+   * que é como o `pocketpal` monta todas as telas do Drawer).
+   */
+  componentFile(file, node, hops = 0) {
+    if (!node || hops > MAX_HOPS2) return null;
+    if (BabelTypes__namespace.isCallExpression(node)) {
+      for (const arg of node.arguments) {
+        if (BabelTypes__namespace.isIdentifier(arg) || BabelTypes__namespace.isMemberExpression(arg)) {
+          const inner = this.componentFile(file, arg, hops + 1);
+          if (inner) return inner;
+        }
+      }
+      return null;
+    }
+    if (BabelTypes__namespace.isTSAsExpression(node)) return this.componentFile(file, node.expression, hops + 1);
+    const chain = memberChain(node);
+    if (!chain) return null;
+    const origin = this.resolveBinding(file, chain.root);
+    if (!origin) return null;
+    if (chain.path.length === 0) return origin.file;
+    const init = this.topLevelInit(origin.file, origin.name);
+    if (init && BabelTypes__namespace.isObjectExpression(init)) {
+      const prop = objectProperty(init, chain.path[0]);
+      if (prop) return this.componentFile(origin.file, prop, hops + 1);
+    }
+    const viaExport = this.resolveBinding(origin.file, chain.path[0], hops + 1);
+    return viaExport?.file ?? null;
+  }
+  /**
+   * Os arquivos DO PROJETO que este arquivo renderiza como JSX.
+   *
+   * `<ChatView …/>` em `ChatScreen.tsx` → `components/ChatView/ChatView.tsx`.
+   * Import de pacote devolve `null` no `resolve` e fica de fora: componente de
+   * terceiro não tem tela nossa dentro.
+   *
+   * Ignora `<X.Screen>` e `<X.Navigator>` de propósito — navegação é outro
+   * extractor, e um navegador não é conteúdo de tela.
+   */
+  renderedComponentFiles(file) {
+    const ast = this.parse(file);
+    if (!ast) return [];
+    const names = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      if (!node || typeof node !== "object") return;
+      if (BabelTypes__namespace.isJSXOpeningElement(node) && BabelTypes__namespace.isJSXIdentifier(node.name)) {
+        const n = node.name.name;
+        if (/^[A-Z]/.test(n)) names.add(n);
+      }
+      for (const key of Object.keys(node)) {
+        const value = node[key];
+        if (Array.isArray(value)) {
+          for (const item of value) visit(item);
+        } else if (value && typeof value === "object" && "type" in value) {
+          visit(value);
+        }
+      }
+    };
+    visit(ast.program);
+    const out = /* @__PURE__ */ new Set();
+    for (const name of names) {
+      const origin = this.resolveBinding(file, name);
+      if (origin && origin.file !== file) out.add(origin.file);
+    }
+    return [...out];
+  }
+};
+function memberChain(node) {
+  const chain = [];
+  let current = node;
+  while (BabelTypes__namespace.isMemberExpression(current)) {
+    if (current.computed) {
+      if (!BabelTypes__namespace.isStringLiteral(current.property)) return null;
+      chain.unshift(current.property.value);
+    } else if (BabelTypes__namespace.isIdentifier(current.property)) {
+      chain.unshift(current.property.name);
+    } else {
+      return null;
+    }
+    current = current.object;
+  }
+  return BabelTypes__namespace.isIdentifier(current) ? { root: current.name, path: chain } : null;
+}
+function objectProperty(obj, key) {
+  for (const prop of obj.properties) {
+    if (!BabelTypes__namespace.isObjectProperty(prop)) continue;
+    const name = BabelTypes__namespace.isIdentifier(prop.key) ? prop.key.name : BabelTypes__namespace.isStringLiteral(prop.key) ? prop.key.value : null;
+    if (name === key && BabelTypes__namespace.isExpression(prop.value)) return prop.value;
+  }
+  return null;
+}
+function readTsconfigAliases(rootDir) {
+  const file = path2__namespace.default.join(rootDir, "tsconfig.json");
+  if (!fs$1.existsSync(file)) return [];
+  let parsed;
+  try {
+    const raw = stripJsonComments(fs$1.readFileSync(file, "utf-8")).replace(/,(\s*[}\]])/g, "$1");
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const paths = parsed.compilerOptions?.paths;
+  if (!paths) return [];
+  const baseUrl = path2__namespace.default.resolve(rootDir, parsed.compilerOptions?.baseUrl ?? ".");
+  const out = [];
+  for (const [pattern, targets] of Object.entries(paths)) {
+    const first = targets[0];
+    if (typeof first !== "string") continue;
+    out.push({
+      prefix: pattern.replace(/\/?\*$/, ""),
+      target: path2__namespace.default.resolve(baseUrl, first.replace(/\/?\*$/, ""))
+    });
+  }
+  return out.sort((a, b) => b.prefix.length - a.prefix.length);
+}
+function stripJsonComments(text) {
+  let out = "";
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (inString) {
+      out += c;
+      if (escaped) escaped = false;
+      else if (c === "\\") escaped = true;
+      else if (c === '"') inString = false;
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      out += c;
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      out += "\n";
+      continue;
+    }
+    if (c === "/" && text[i + 1] === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
+      i++;
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+function readWorkspacePackages(rootDir) {
+  const start = path2__namespace.default.resolve(rootDir);
+  let dir = start;
+  for (let i = 0; i < 6; i++) {
+    const globs = workspaceGlobs(dir);
+    if (globs.length > 0) {
+      const packages = expandWorkspaceGlobs(dir, globs);
+      const containsApp = packages.some(
+        (p) => start === p.dir || start.startsWith(p.dir + path2__namespace.default.sep)
+      );
+      return containsApp ? packages : [];
+    }
+    const parent = path2__namespace.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return [];
+}
+function workspaceGlobs(dir) {
+  const pnpm = path2__namespace.default.join(dir, "pnpm-workspace.yaml");
+  if (fs$1.existsSync(pnpm)) {
+    try {
+      const lines = fs$1.readFileSync(pnpm, "utf-8").split(/\r?\n/);
+      const out = [];
+      let inPackages = false;
+      for (const line of lines) {
+        if (/^packages:/.test(line)) {
+          inPackages = true;
+          continue;
+        }
+        if (inPackages) {
+          const m = /^\s*-\s*["']?([^"'#]+?)["']?\s*$/.exec(line);
+          if (m) out.push(m[1].trim());
+          else if (/^\S/.test(line)) break;
+        }
+      }
+      if (out.length) return out;
+    } catch {
+    }
+  }
+  const pkgPath = path2__namespace.default.join(dir, "package.json");
+  if (!fs$1.existsSync(pkgPath)) return [];
+  try {
+    const pkg = JSON.parse(fs$1.readFileSync(pkgPath, "utf-8"));
+    const ws = pkg.workspaces;
+    if (Array.isArray(ws)) return ws;
+    if (ws && Array.isArray(ws.packages)) return ws.packages;
+  } catch {
+  }
+  return [];
+}
+function expandWorkspaceGlobs(root, globs) {
+  const out = [];
+  const add2 = (dir) => {
+    const pkgPath = path2__namespace.default.join(dir, "package.json");
+    if (!fs$1.existsSync(pkgPath)) return;
+    try {
+      const name = JSON.parse(fs$1.readFileSync(pkgPath, "utf-8")).name;
+      if (name) out.push({ name, dir });
+    } catch {
+    }
+  };
+  for (const glob of globs) {
+    if (glob.endsWith("/*")) {
+      const parent = path2__namespace.default.join(root, glob.slice(0, -2));
+      let entries = [];
+      try {
+        entries = fs$1.readdirSync(parent);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        const dir = path2__namespace.default.join(parent, entry);
+        try {
+          if (fs$1.statSync(dir).isDirectory()) add2(dir);
+        } catch {
+        }
+      }
+    } else if (!glob.includes("*")) {
+      add2(path2__namespace.default.join(root, glob));
+    }
+  }
+  return out.sort((a, b) => b.name.length - a.name.length);
+}
+var ROUTE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+var PLATFORM_SUFFIXES = [".ios", ".android", ".native", ".web"];
+var ROUTE_DIR_CANDIDATES = ["app", "src/app"];
+function baseName(file) {
+  let name = file;
+  for (const ext of ROUTE_EXTENSIONS) {
+    if (name.endsWith(ext)) {
+      name = name.slice(0, -ext.length);
+      break;
+    }
+  }
+  for (const suffix of PLATFORM_SUFFIXES) {
+    if (name.endsWith(suffix)) return name.slice(0, -suffix.length);
+  }
+  return name;
+}
+function isRouteFile(file) {
+  return ROUTE_EXTENSIONS.some((ext) => file.endsWith(ext));
+}
+function isSpecial(base) {
+  if (base === "_layout") return true;
+  if (base.startsWith("+")) return base !== "+not-found";
+  return base.startsWith("_");
+}
+function layoutType(file) {
+  try {
+    const src = fs$1.readFileSync(file, "utf-8");
+    if (/<(?:Native)?Tabs\b/.test(src)) return "tab";
+    if (/<Drawer\b/.test(src)) return "drawer";
+  } catch {
+  }
+  return "stack";
+}
+function findLayout(dir) {
+  for (const ext of ROUTE_EXTENSIONS) {
+    const candidate = path2__namespace.default.join(dir, "_layout" + ext);
+    if (fs$1.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function analyzeExpoRouter(appRoot) {
+  let routeDir = null;
+  for (const candidate of ROUTE_DIR_CANDIDATES) {
+    const full = path2__namespace.default.join(appRoot, candidate);
+    if (fs$1.existsSync(full) && findLayout(full)) {
+      routeDir = full;
+      break;
+    }
+  }
+  if (!routeDir) return null;
+  const routes = [];
+  const navigators = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (dir, segments, navigator) => {
+    const layout = findLayout(dir);
+    const current = layout ? segments.join("/") || "/" : navigator;
+    if (layout && !navigators.has(current)) navigators.set(current, layoutType(layout));
+    let entries;
+    try {
+      entries = fs$1.readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort()) {
+      const full = path2__namespace.default.join(dir, entry);
+      let isDir = false;
+      try {
+        isDir = fs$1.statSync(full).isDirectory();
+      } catch {
+        continue;
+      }
+      if (isDir) {
+        if (entry === "node_modules" || entry.startsWith(".")) continue;
+        walk(full, [...segments, entry], current);
+        continue;
+      }
+      if (!isRouteFile(entry)) continue;
+      const base = baseName(entry);
+      if (isSpecial(base)) continue;
+      const routeSegments = base === "index" ? segments : [...segments, base];
+      const name = "/" + routeSegments.join("/");
+      if (seen.has(name)) continue;
+      seen.add(name);
+      routes.push({
+        name,
+        componentFile: full,
+        navigatorName: current,
+        navigatorType: navigators.get(current) ?? "stack",
+        params: routeSegments.filter((s) => s.startsWith("[") && s.endsWith("]")).map((s) => s.slice(1, -1).replace(/^\.\.\./, ""))
+      });
+    }
+  };
+  walk(routeDir, [], "/");
+  return {
+    routeDir: path2__namespace.default.relative(appRoot, routeDir),
+    routes,
+    navigators: [...navigators.entries()].map(([name, type]) => ({ name, type }))
+  };
+}
+
+// src/analyzers/NavigationAnalyzer.ts
+var NAVIGATOR_FACTORIES = {
+  createStackNavigator: "stack",
+  createNativeStackNavigator: "stack",
+  createBottomTabNavigator: "tab",
+  createTabNavigator: "tab",
+  createMaterialTopTabNavigator: "tab",
+  createMaterialBottomTabNavigator: "tab",
+  createDrawerNavigator: "drawer"
+};
+var CUSTOM_FACTORY = /^create[A-Za-z0-9]*(Navigator|Stack|Tabs?|Drawer)$/;
+function unwrapStaticScreen(value) {
+  if (BabelTypes__namespace.isCallExpression(value)) {
+    const arg = value.arguments[0];
+    return arg ? unwrapStaticScreen(arg) : null;
+  }
+  if (BabelTypes__namespace.isObjectExpression(value)) {
+    for (const prop of value.properties) {
+      if (!BabelTypes__namespace.isObjectProperty(prop)) continue;
+      const key = BabelTypes__namespace.isIdentifier(prop.key) ? prop.key.name : null;
+      if (key === "screen" && BabelTypes__namespace.isExpression(prop.value)) return prop.value;
+    }
+    return null;
+  }
+  return BabelTypes__namespace.isExpression(value) ? value : null;
+}
+function inferNavigatorType(factoryName) {
+  if (/drawer/i.test(factoryName)) return "drawer";
+  if (/tab/i.test(factoryName)) return "tab";
+  return "stack";
+}
+var NAVIGATION_EVIDENCE = new RegExp(
+  // `\.Navigator`/`\.Screen` entram porque o JSX pode estar num arquivo que
+  // não menciona fábrica nenhuma: `comapeo` declara `RootStack` em
+  // `Stack/RootStack.ts` e escreve todas as 120 rotas em `Stack/index.tsx`,
+  // que não cita `createNativeStackNavigator` uma vez sequer. Sem isto a
+  // junção entre arquivos nunca chega a ser tentada.
+  // Sem `\\b` depois da palavra — `createNativeStackNavigatorWithAuth` não tem
+  // fronteira ali, e exigi-la fecharia o portão para o arquivo que declara os
+  // seis navegadores do `bluesky`.
+  `create[A-Za-z0-9]*(?:Navigator|Stack|Tabs?|Drawer)|ParamList|\\.Navigator\\b|\\.Screen\\b`
+);
 var NavigationAnalyzer = class {
   config;
   /** Extra glob patterns for navigation file discovery (added to defaults) */
   navigationInclude;
   /** Extra glob patterns to exclude from navigation analysis */
   navigationExclude;
+  /** Exposto para a composição reusar o cache de AST em vez de reparsear a árvore. */
+  graph;
+  /**
+   * Rota → arquivo do componente que ela monta. É a única ligação entre o grafo
+   * de navegação e a árvore de telas; sem ela as duas metades do documento
+   * falam de coisas diferentes. Populada por `analyze()`.
+   */
+  routeTargets = /* @__PURE__ */ new Map();
+  /**
+   * Arquivos que DECLARAM uma fábrica de navegador.
+   *
+   * Um navegador aninhado é montado como `component=` de uma rota — no
+   * `apps/example-app`, `<Stack.Screen name="Main" component={MainTabNavigator} />`.
+   * Promover esse arquivo a tela criaria seis "telas" sem uma única ação, que é
+   * exatamente o falso positivo que o corpus existe para não repetir. Um
+   * navegador é um contêiner de rotas; a tela está um nível abaixo.
+   *
+   * Entram aqui os dois lados: o arquivo que CHAMA a fábrica e o arquivo que
+   * RENDERIZA `<X.Navigator>`. Não são o mesmo — `bluewallet` declara
+   * `DetailViewStack` num arquivo e escreve o JSX em
+   * `navigation/DetailViewScreensStack.tsx`, e checar só o primeiro deixava o
+   * segundo entrar como tela.
+   */
+  navigatorFiles = /* @__PURE__ */ new Set();
+  /** Preenchido por `analyze()`. Vazio antes disso. */
+  diagnostics = {
+    filesScanned: 0,
+    filesWithEvidence: 0,
+    navigatorsDeclared: 0,
+    navigatorsWithJsx: 0,
+    routes: 0,
+    routesLinkedToFile: 0
+  };
   constructor(config, options) {
     this.config = config;
+    this.graph = new ModuleGraph(config.rootDir);
     this.navigationInclude = options?.navigationInclude ?? [];
     this.navigationExclude = options?.navigationExclude ?? [];
   }
   /** Build the full navigation graph */
   async analyze() {
     const navigationFiles = await this.findNavigationFiles();
-    const parsedNavigators = [];
     const typeExports = [];
+    this.routeTargets.clear();
+    const declarations = /* @__PURE__ */ new Map();
+    const evidenceFiles = [];
+    this.navigatorFiles.clear();
     for (const filePath of navigationFiles) {
       try {
         const content = await fs$1.promises.readFile(filePath, "utf-8");
-        const navigators = this.parseNavigators(content, filePath);
-        const types = this.parseParamTypes(content, filePath);
-        parsedNavigators.push(...navigators);
-        typeExports.push(...types);
+        if (!NAVIGATION_EVIDENCE.test(content)) continue;
+        evidenceFiles.push(filePath);
+        for (const decl of this.collectDeclarations(filePath)) {
+          declarations.set(`${decl.file}#${decl.name}`, decl);
+          if (decl.confident) this.navigatorFiles.add(decl.file);
+        }
+        typeExports.push(...this.parseParamTypes(content, filePath));
       } catch (error) {
         console.warn(`Failed to parse ${filePath}:`, error);
       }
     }
+    const parsedNavigators = [];
+    for (const filePath of evidenceFiles) {
+      try {
+        parsedNavigators.push(...this.parseNavigatorUsages(filePath, declarations));
+      } catch (error) {
+        console.warn(`Failed to parse navigators in ${filePath}:`, error);
+      }
+    }
+    let detachedScreens = 0;
+    for (const filePath of evidenceFiles) {
+      try {
+        for (const detached of this.parseDetachedScreens(filePath, declarations)) {
+          const existing = parsedNavigators.find(
+            (nav) => nav.name === detached.name && nav.type === detached.type
+          );
+          if (!existing) {
+            parsedNavigators.push(detached);
+            detachedScreens += detached.screens.length;
+            continue;
+          }
+          const seen = new Set(existing.screens.map((screen) => screen.name));
+          for (const screen of detached.screens) {
+            if (seen.has(screen.name)) continue;
+            seen.add(screen.name);
+            existing.screens.push(screen);
+            detachedScreens++;
+          }
+        }
+      } catch (error) {
+        console.warn(`Failed to parse detached screens in ${filePath}:`, error);
+      }
+    }
+    const expo = analyzeExpoRouter(this.config.rootDir);
+    if (expo) {
+      console.log(
+        `[NavigationAnalyzer] expo-router em "${expo.routeDir}": ${expo.routes.length} rotas, ${expo.navigators.length} layouts`
+      );
+      this.diagnostics.fileBasedRouter = {
+        kind: "expo-router",
+        routeDir: expo.routeDir,
+        routes: expo.routes.length
+      };
+      const byNavigator = /* @__PURE__ */ new Map();
+      for (const nav of expo.navigators) {
+        byNavigator.set(nav.name, { name: nav.name, type: nav.type, screens: [] });
+      }
+      for (const route of expo.routes) {
+        const navigator = byNavigator.get(route.navigatorName) ?? byNavigator.set(route.navigatorName, {
+          name: route.navigatorName,
+          type: route.navigatorType,
+          screens: []
+        }).get(route.navigatorName);
+        navigator.screens.push({
+          name: route.name,
+          navigatorName: route.navigatorName,
+          navigatorType: route.navigatorType,
+          componentFile: route.componentFile,
+          ...route.params.length ? {
+            params: route.params.map((name) => ({ name, type: "string", required: true }))
+          } : {}
+        });
+        this.routeTargets.set(route.name, route.componentFile);
+      }
+      parsedNavigators.push(...byNavigator.values());
+    }
+    let staticOnly = 0;
+    for (const decl of declarations.values()) {
+      if (!decl.confident || !decl.staticScreens?.length) continue;
+      const existing = parsedNavigators.find((n) => n.name === decl.name && n.type === decl.type);
+      if (existing) {
+        const seen = new Set(existing.screens.map((s) => s.name));
+        for (const screen of decl.staticScreens) {
+          if (!seen.has(screen.name)) existing.screens.push(screen);
+        }
+        continue;
+      }
+      parsedNavigators.push({ name: decl.name, type: decl.type, screens: decl.staticScreens });
+      staticOnly++;
+    }
+    const confidentDeclarations = [...declarations.values()].filter((d) => d.confident).length;
+    const uniqueRoutes = new Set(
+      parsedNavigators.flatMap((nav) => nav.screens.map((screen) => screen.name))
+    );
+    this.diagnostics = {
+      ...this.diagnostics,
+      filesScanned: navigationFiles.length,
+      filesWithEvidence: evidenceFiles.length,
+      navigatorsDeclared: confidentDeclarations,
+      navigatorsWithJsx: parsedNavigators.length,
+      routes: uniqueRoutes.size,
+      // `routeTargets` é indexado por nome de rota, e uma rota pode ter sido
+      // registrada por um navegador que não sobreviveu. O mínimo evita a
+      // cobertura acima de 100% que a medição do corpus expôs no `coopcycle`.
+      routesLinkedToFile: Math.min(this.routeTargets.size, uniqueRoutes.size)
+    };
+    console.log(
+      `[NavigationAnalyzer] ${staticOnly} navegador(es) s\xF3 de config est\xE1tica \xB7 ${detachedScreens} rota(s) fora de um <X.Navigator> \xB7 ${navigationFiles.length} arquivos varridos, ${evidenceFiles.length} com evid\xEAncia, ${confidentDeclarations} navegadores declarados, ${parsedNavigators.length} com JSX, ${this.routeTargets.size} rotas ligadas a um arquivo`
+    );
     this.attachParamsToNavigators(parsedNavigators, typeExports);
     return this.buildNavigationGraph(parsedNavigators);
   }
-  /** Find all navigation-related files */
+  /** Fase 1: as fábricas `create*Navigator()` atribuídas a um nome neste arquivo. */
+  collectDeclarations(filePath) {
+    const ast = this.graph.parse(filePath);
+    if (!ast) return [];
+    const out = /* @__PURE__ */ new Map();
+    traverse5__default.default(ast, {
+      CallExpression: (nodePath) => {
+        const callee = nodePath.node.callee;
+        if (!BabelTypes__namespace.isIdentifier(callee)) return;
+        const known = NAVIGATOR_FACTORIES[callee.name] ?? (CUSTOM_FACTORY.test(callee.name) ? inferNavigatorType(callee.name) : null);
+        const type = known ?? inferNavigatorType(callee.name);
+        const confident = known !== null;
+        let up = nodePath.parentPath;
+        for (let i = 0; i < 4 && up; i++) {
+          if (BabelTypes__namespace.isVariableDeclarator(up.node)) break;
+          if (!BabelTypes__namespace.isMemberExpression(up.node) && !BabelTypes__namespace.isCallExpression(up.node)) {
+            up = null;
+            break;
+          }
+          up = up.parentPath;
+        }
+        const declarator = up?.node;
+        if (!declarator || !BabelTypes__namespace.isVariableDeclarator(declarator) || !BabelTypes__namespace.isIdentifier(declarator.id)) {
+          return;
+        }
+        const name = declarator.id.name;
+        if (out.get(name)?.confident) return;
+        const staticScreens = confident ? this.parseStaticScreens(filePath, nodePath.node.arguments[0], name, type) : [];
+        out.set(name, {
+          file: filePath,
+          name,
+          type,
+          confident,
+          ...staticScreens.length ? { staticScreens } : {}
+        });
+      }
+    });
+    return [...out.values()];
+  }
+  /**
+   * As rotas de `createXNavigator({ screens: { … } })`.
+   *
+   * Quatro formas no corpus, todas em `rocketchat`:
+   *   `NewServerView`                                  — shorthand, nome = componente
+   *   `LoginView: createNativeStackScreen({ screen })` — embrulho da própria lib
+   *   `SelectListView: SelectListViewScreen`           — identificador direto
+   *   `ChatsStackNavigator: ChatsStack`                — navegador aninhado
+   *
+   * `groups: { G: { screens: { … } } }` também entra: faz parte da API estática
+   * e agrupar rotas não muda o que elas são.
+   */
+  parseStaticScreens(filePath, config, navigatorName, navigatorType, depth = 0) {
+    if (!config || !BabelTypes__namespace.isObjectExpression(config) || depth > 4) return [];
+    const out = [];
+    for (const prop of config.properties) {
+      if (!BabelTypes__namespace.isObjectProperty(prop)) continue;
+      const key = BabelTypes__namespace.isIdentifier(prop.key) ? prop.key.name : BabelTypes__namespace.isStringLiteral(prop.key) ? prop.key.value : null;
+      if (!key) continue;
+      if (key === "groups" && BabelTypes__namespace.isObjectExpression(prop.value)) {
+        for (const group of prop.value.properties) {
+          if (!BabelTypes__namespace.isObjectProperty(group) || !BabelTypes__namespace.isExpression(group.value)) continue;
+          out.push(
+            ...this.parseStaticScreens(
+              filePath,
+              group.value,
+              navigatorName,
+              navigatorType,
+              depth + 1
+            )
+          );
+        }
+        continue;
+      }
+      if (key !== "screens" || !BabelTypes__namespace.isObjectExpression(prop.value)) continue;
+      for (const entry of prop.value.properties) {
+        if (!BabelTypes__namespace.isObjectProperty(entry)) continue;
+        const routeName = BabelTypes__namespace.isIdentifier(entry.key) ? entry.key.name : BabelTypes__namespace.isStringLiteral(entry.key) ? entry.key.value : null;
+        if (!routeName) continue;
+        const componentExpr = unwrapStaticScreen(entry.value);
+        const componentFile = componentExpr ? this.graph.componentFile(filePath, componentExpr) : null;
+        if (componentFile) this.routeTargets.set(routeName, componentFile);
+        out.push({
+          name: routeName,
+          navigatorName,
+          navigatorType,
+          ...componentFile ? { componentFile } : {}
+        });
+      }
+    }
+    return out;
+  }
+  /**
+   * Todo arquivo-fonte do projeto — não os que ficam num diretório com o nome
+   * certo.
+   *
+   * POR QUE ISTO MUDOU. A lista anterior era `**\/navigation/**`,
+   * `**\/navigator*` e `**\/routes*`, o que fazia da descoberta de navegação uma
+   * convenção de caminho. Medido contra 20 apps React Native de terceiros
+   * (`qa/eval-corpus`), o filtro errava por motivos que nada têm a ver com o
+   * app não ter navegação:
+   *
+   *   - `pocketpal` declara 4 navegadores em `App.tsx` e dentro de `src/screens/`;
+   *   - `comapeo` usa `src/frontend/Navigation/` — `N` maiúsculo, e o glob é
+   *     sensível a caixa;
+   *   - `abacus` usa `src/routes/index.tsx` — `routes` é o DIRETÓRIO, e o glob
+   *     pedia um arquivo chamado `routes*`;
+   *   - `discourse` declara em `js/Discourse.js` — o glob só aceitava `.ts`/`.tsx`;
+   *   - `rainbow` tem 11 arquivos com navegador e o glob alcançava 1.
+   *
+   * Varrer tudo não custa uma varredura nova: `ReactNativePlatformAnalyzer` já
+   * globa e parseia a árvore inteira para `ComponentAnalyzer` e `FormAnalyzer`.
+   * O que segura o custo aqui é o portão por evidência em `analyze()`, que só
+   * parseia arquivo cujo texto menciona uma fábrica de navegador.
+   *
+   * Os globs antigos continuam na lista: se um projeto restringir `include`, o
+   * que era encontrado antes continua sendo.
+   */
   async findNavigationFiles() {
     const patterns = [
+      ...this.config.include ?? ["**/*.{ts,tsx,js,jsx}"],
+      // Piso de compatibilidade — nunca encontrar MENOS que a versão anterior.
       "**/navigation/**/*.{ts,tsx}",
       "**/navigator*.{ts,tsx}",
       "**/routes*.{ts,tsx}",
@@ -1703,91 +2897,188 @@ var NavigationAnalyzer = class {
       "**/node_modules/**",
       "**/dist/**",
       "**/build/**",
+      // Um navegador declarado dentro de um teste é fixture, não a navegação
+      // do app. Isto passou a importar quando a varredura deixou de ser por
+      // caminho: em `expensify`, os únicos arquivos que o glob antigo
+      // alcançava eram três de `tests/`.
+      "**/__tests__/**",
+      "**/test/**",
+      "**/tests/**",
+      "**/*.test.{ts,tsx,js,jsx}",
+      "**/*.tests.{ts,tsx,js,jsx}",
+      "**/*.spec.{ts,tsx,js,jsx}",
+      // Sufixo `Test` sem ponto: `expensify` chama os fixtures dele de
+      // `LegalNameStepTest.tsx`, e cada um monta um `<Stack.Screen>` próprio.
+      // Auditando as 144 rotas lidas dele contra `SCREENS.ts`, 2 vinham daqui —
+      // destinos que existem no teste e não no app, para os quais o agente
+      // tentaria navegar.
+      "**/*Test.{ts,tsx,js,jsx}",
+      "**/*Tests.{ts,tsx,js,jsx}",
       ...this.config.exclude || [],
       // §5: Add user-configured navigation excludes
       ...this.navigationExclude
     ];
-    const files = await glob__default.default(patterns, {
+    const files = await globSorted(patterns, {
       cwd: this.config.rootDir,
       ignore: excludePatterns
     });
-    return files.map((file) => path8__namespace.default.join(this.config.rootDir, file));
+    return files.map((file) => path2__namespace.default.join(this.config.rootDir, file));
   }
-  /** Parse navigator definitions from a file */
-  parseNavigators(content, filePath) {
-    const navigators = [];
-    try {
-      const ast = parser__namespace.parse(content, {
-        sourceType: "module",
-        plugins: [
-          "jsx",
-          "typescript",
-          ...this.config.parserPlugins || []
-        ]
-      });
-      const navigatorCalls = /* @__PURE__ */ new Map();
-      const screensByNavigator = /* @__PURE__ */ new Map();
-      traverse4__default.default(ast, {
-        // Detect createStackNavigator / createTabNavigator / createDrawerNavigator calls
-        CallExpression: (nodePath) => {
-          const { node } = nodePath;
-          const callee = node.callee;
-          let navigatorType = null;
-          if (BabelTypes__namespace.isIdentifier(callee) && callee.name === "createNativeStackNavigator") {
-            navigatorType = "stack";
-          } else if (BabelTypes__namespace.isIdentifier(callee) && callee.name === "createStackNavigator") {
-            navigatorType = "stack";
-          } else if (BabelTypes__namespace.isIdentifier(callee) && callee.name === "createBottomTabNavigator") {
-            navigatorType = "tab";
-          } else if (BabelTypes__namespace.isIdentifier(callee) && callee.name === "createTabNavigator") {
-            navigatorType = "tab";
-          } else if (BabelTypes__namespace.isIdentifier(callee) && callee.name === "createDrawerNavigator") {
-            navigatorType = "drawer";
-          }
-          if (navigatorType) {
-            const parent = nodePath.parent;
-            if (BabelTypes__namespace.isVariableDeclarator(parent) && BabelTypes__namespace.isIdentifier(parent.id)) {
-              const varName = parent.id.name;
-              navigatorCalls.set(varName, {
-                name: varName,
-                type: navigatorType,
-                screens: []
-              });
-            }
-          }
-        },
-        // Detect Stack.Navigator / Tab.Navigator JSX elements
-        JSXElement: (nodePath) => {
-          const { node } = nodePath;
-          const openingElement = node.openingElement;
-          if (BabelTypes__namespace.isJSXMemberExpression(openingElement.name) && BabelTypes__namespace.isJSXIdentifier(openingElement.name.object)) {
-            const objectName = openingElement.name.object.name;
-            const propertyName = BabelTypes__namespace.isJSXIdentifier(openingElement.name.property) ? openingElement.name.property.name : null;
-            if (propertyName === "Navigator") {
-              const navigator = navigatorCalls.get(objectName);
-              if (navigator) {
-                const initialRouteAttr = openingElement.attributes.find(
-                  (attr) => BabelTypes__namespace.isJSXAttribute(attr) && BabelTypes__namespace.isJSXIdentifier(attr.name) && attr.name.name === "initialRouteName"
-                );
-                if (BabelTypes__namespace.isJSXAttribute(initialRouteAttr) && BabelTypes__namespace.isStringLiteral(initialRouteAttr.value)) {
-                  navigator.initialRouteName = initialRouteAttr.value.value;
-                }
-                const screens = this.extractScreensFromNavigator(node, objectName, navigator.type);
-                screensByNavigator.set(objectName, screens);
-              }
-            }
-          }
+  /**
+   * Fase 2: o JSX `<X.Navigator>` deste arquivo, ligado à declaração de `X` —
+   * que pode estar aqui ou em qualquer arquivo que este importe.
+   */
+  parseNavigatorUsages(filePath, declarations) {
+    const ast = this.graph.parse(filePath);
+    if (!ast) return [];
+    const found = /* @__PURE__ */ new Map();
+    traverse5__default.default(ast, {
+      JSXElement: (nodePath) => {
+        const { node } = nodePath;
+        const openingElement = node.openingElement;
+        if (!BabelTypes__namespace.isJSXMemberExpression(openingElement.name) || !BabelTypes__namespace.isJSXIdentifier(openingElement.name.object)) {
+          return;
         }
-      });
-      navigatorCalls.forEach((navigator) => {
-        const screens = screensByNavigator.get(navigator.name) || [];
-        navigator.screens = screens;
-        navigators.push(navigator);
-      });
-    } catch (error) {
-      console.warn(`Failed to parse navigators in ${filePath}:`, error);
+        const objectName = openingElement.name.object.name;
+        const propertyName = BabelTypes__namespace.isJSXIdentifier(openingElement.name.property) ? openingElement.name.property.name : null;
+        if (propertyName !== "Navigator") return;
+        const decl = this.resolveNavigator(filePath, objectName, declarations);
+        if (!decl) return;
+        const navigator = found.get(objectName) ?? {
+          name: objectName,
+          type: decl.type,
+          screens: []
+        };
+        const initialRouteAttr = openingElement.attributes.find(
+          (attr) => BabelTypes__namespace.isJSXAttribute(attr) && BabelTypes__namespace.isJSXIdentifier(attr.name) && attr.name.name === "initialRouteName"
+        );
+        if (BabelTypes__namespace.isJSXAttribute(initialRouteAttr)) {
+          const initial = this.attributeString(filePath, initialRouteAttr);
+          if (initial) navigator.initialRouteName = initial;
+        }
+        this.navigatorFiles.add(filePath);
+        this.navigatorFiles.add(decl.file);
+        navigator.screens = this.extractScreensFromNavigator(filePath, node, objectName, decl.type);
+        found.set(objectName, navigator);
+      }
+    });
+    return [...found.values()];
+  }
+  /**
+   * Rotas declaradas FORA de qualquer `<X.Navigator>`.
+   *
+   * O CASO. A fase 2 desce a partir do `<X.Navigator>` e lê as `<X.Screen>`
+   * que estão DENTRO dele. Dois alvos do corpus não escrevem assim, e entre os
+   * dois são 171 rotas invisíveis:
+   *
+   *   `bluesky`  — `function commonScreens(Stack: typeof Flat) { return (<>
+   *                 <Stack.Screen name="NotFound" … /> … </>) }`, chamada de
+   *                dentro de seis navegadores diferentes. 70 rotas.
+   *   `comapeo`  — `export const createAppScreens = ({intl}) => (<>
+   *                 <RootStack.Group><RootStack.Screen … /></RootStack.Group></>)`,
+   *                num arquivo sem `<RootStack.Navigator>` nenhum. 101 rotas.
+   *
+   * A REGRA. Uma `<X.Screen name="…">` sem `<Y.Navigator>` ancestral é rota do
+   * navegador ao qual `X` se resolve. Não há palpite em jogo: o nome da rota é
+   * literal do fonte (ou constante que o resolvedor segue), e `X` precisa
+   * chegar a uma declaração de navegador que já existe. O que não resolve não
+   * vira nada.
+   *
+   * O ancestral é o que evita contar duas vezes — dentro do `<X.Navigator>` a
+   * fase 2 já leu, e somar aqui duplicaria cada rota do corpus inteiro.
+   *
+   * DUAS FORMAS DE RESOLVER `X`, e a segunda é o que o `bluesky` exige. A
+   * primeira é a de sempre (declaração local, ou `import` seguido até a
+   * origem) e resolve o `comapeo`. A segunda lê a ANOTAÇÃO DE TIPO do
+   * parâmetro: em `commonScreens(Stack: typeof Flat)`, quem diz que `Stack` é
+   * o navegador `Flat` é o próprio app, no fonte.
+   *
+   * O QUE ISTO NÃO FAZ. As 70 do `bluesky` ficam atribuídas a `Flat` — que as
+   * contém de fato (`{commonScreens(Flat, numUnread)}`) — e não aos outros
+   * cinco stacks que também chamam a mesma função. Seguir os seis pontos de
+   * chamada é análise interprocedural, e o ganho seria só de atribuição: o nome
+   * da rota e o arquivo da tela, que é o que o agente usa, já saem certos.
+   */
+  parseDetachedScreens(filePath, declarations) {
+    const ast = this.graph.parse(filePath);
+    if (!ast) return [];
+    const byNavigator = /* @__PURE__ */ new Map();
+    const resolved = /* @__PURE__ */ new Map();
+    traverse5__default.default(ast, {
+      JSXElement: (nodePath) => {
+        const name = nodePath.node.openingElement.name;
+        if (!BabelTypes__namespace.isJSXMemberExpression(name) || !BabelTypes__namespace.isJSXIdentifier(name.object)) return;
+        if (!BabelTypes__namespace.isJSXIdentifier(name.property) || name.property.name !== "Screen") return;
+        const insideNavigator = nodePath.findParent((parent) => {
+          if (!parent.isJSXElement()) return false;
+          const parentName = parent.node.openingElement.name;
+          return BabelTypes__namespace.isJSXMemberExpression(parentName) && BabelTypes__namespace.isJSXIdentifier(parentName.property) && parentName.property.name === "Navigator";
+        });
+        if (insideNavigator) return;
+        const local = name.object.name;
+        if (!resolved.has(local)) {
+          resolved.set(
+            local,
+            this.resolveDetachedNavigator(filePath, local, nodePath, declarations)
+          );
+        }
+        const decl = resolved.get(local);
+        if (!decl) return;
+        const screen = this.parseScreenElement(filePath, nodePath.node, decl.name, decl.type);
+        if (!screen) return;
+        const nav = byNavigator.get(decl.name) ?? {
+          name: decl.name,
+          type: decl.type,
+          screens: []
+        };
+        if (!nav.screens.some((existing) => existing.name === screen.name))
+          nav.screens.push(screen);
+        byNavigator.set(decl.name, nav);
+      }
+    });
+    return [...byNavigator.values()];
+  }
+  /**
+   * De um `X` usado como `<X.Screen>` até a declaração do navegador.
+   *
+   * Além do caminho normal — declaração local ou `import` seguido até a origem
+   * — aceita `X` como PARÂMETRO anotado com `typeof Y`. É o idioma do
+   * `bluesky`, e a anotação é declaração do app: nada aqui é inferido do nome.
+   */
+  resolveDetachedNavigator(filePath, localName, nodePath, declarations) {
+    const direct = this.resolveNavigator(filePath, localName, declarations);
+    if (direct) return direct;
+    const binding = nodePath.scope.getBinding(localName);
+    if (!binding || binding.kind !== "param") return null;
+    const param = binding.path.node;
+    if (!BabelTypes__namespace.isIdentifier(param) || !BabelTypes__namespace.isTSTypeAnnotation(param.typeAnnotation)) return null;
+    const annotation = param.typeAnnotation.typeAnnotation;
+    if (!BabelTypes__namespace.isTSTypeQuery(annotation) || !BabelTypes__namespace.isIdentifier(annotation.exprName)) return null;
+    return this.resolveNavigator(filePath, annotation.exprName.name, declarations);
+  }
+  /**
+   * De `<X.Navigator>` até a declaração de `X`.
+   *
+   * Primeiro no próprio arquivo; se não estiver, segue o `import` até onde `X`
+   * é definido. Resolver pelo import é o que torna a junção entre arquivos
+   * segura: dois `Stack` de arquivos diferentes nunca colidem, porque a chave
+   * é o arquivo de DEFINIÇÃO.
+   */
+  resolveNavigator(filePath, localName, declarations) {
+    const local = declarations.get(`${filePath}#${localName}`);
+    if (local) return local;
+    const origin = this.graph.resolveBinding(filePath, localName);
+    if (!origin) return null;
+    return declarations.get(`${origin.file}#${origin.name}`) ?? null;
+  }
+  /** O valor string de um atributo JSX, resolvendo constante importada. */
+  attributeString(filePath, attr) {
+    const value = attr.value;
+    if (BabelTypes__namespace.isStringLiteral(value)) return value.value;
+    if (BabelTypes__namespace.isJSXExpressionContainer(value) && BabelTypes__namespace.isExpression(value.expression)) {
+      return this.graph.stringConstant(filePath, value.expression);
     }
-    return navigators;
+    return null;
   }
   /**
    * Is this JSX element `<navigatorVarName.MEMBER …>`?
@@ -1882,22 +3173,48 @@ var NavigationAnalyzer = class {
     return found;
   }
   /** Extract screens from a navigator JSX element */
-  extractScreensFromNavigator(navigatorElement, navigatorVarName, navigatorType) {
+  extractScreensFromNavigator(filePath, navigatorElement, navigatorVarName, navigatorType) {
     const screens = [];
     if (!navigatorElement.children) return screens;
     const seen = /* @__PURE__ */ new Set();
     for (const element of this.collectScreenElements(navigatorElement.children, navigatorVarName)) {
-      const screenName = this.extractAttributeValue(element.openingElement.attributes, "name");
-      if (!screenName || seen.has(screenName)) continue;
-      seen.add(screenName);
-      screens.push({
-        name: screenName,
-        navigatorName: navigatorVarName,
-        navigatorType
-      });
+      const screen = this.parseScreenElement(filePath, element, navigatorVarName, navigatorType);
+      if (!screen || seen.has(screen.name)) continue;
+      seen.add(screen.name);
+      screens.push(screen);
     }
     return screens;
   }
+  /**
+   * Uma `<X.Screen>` isolada até a rota que ela declara.
+   *
+   * Separado de `extractScreensFromNavigator` porque a MESMA leitura serve para
+   * a `<X.Screen>` que mora dentro do `<X.Navigator>` e para a que mora fora
+   * dele — só a forma de chegar até o elemento muda.
+   */
+  parseScreenElement(filePath, element, navigatorName, navigatorType) {
+    const attrs = element.openingElement.attributes;
+    const nameAttr = attrs.find(
+      (a) => BabelTypes__namespace.isJSXAttribute(a) && BabelTypes__namespace.isJSXIdentifier(a.name) && a.name.name === "name"
+    );
+    const screenName = BabelTypes__namespace.isJSXAttribute(nameAttr) ? this.attributeString(filePath, nameAttr) : null;
+    if (!screenName) return null;
+    const componentAttr = attrs.find(
+      (a) => BabelTypes__namespace.isJSXAttribute(a) && BabelTypes__namespace.isJSXIdentifier(a.name) && a.name.name === "component"
+    );
+    let componentFile = null;
+    if (BabelTypes__namespace.isJSXAttribute(componentAttr) && BabelTypes__namespace.isJSXExpressionContainer(componentAttr.value)) {
+      const expr = componentAttr.value.expression;
+      if (BabelTypes__namespace.isExpression(expr)) componentFile = this.graph.componentFile(filePath, expr);
+    }
+    if (componentFile) this.routeTargets.set(screenName, componentFile);
+    return {
+      name: screenName,
+      navigatorName,
+      navigatorType,
+      ...componentFile ? { componentFile } : {}
+    };
+  }
   /** Extract string attribute value from JSX attributes */
   extractAttributeValue(attributes, attrName) {
     const attr = attributes.find(
@@ -1920,7 +3237,7 @@ var NavigationAnalyzer = class {
           ...this.config.parserPlugins || []
         ]
       });
-      traverse4__default.default(ast, {
+      traverse5__default.default(ast, {
         TSTypeAliasDeclaration: (nodePath) => {
           const { node } = nodePath;
           const typeName = node.id.name;
@@ -1993,7 +3310,7 @@ var NavigationAnalyzer = class {
     if (type.type === "TSUndefinedKeyword") return "undefined";
     if (type.type === "TSNullKeyword") return "null";
     if (type.type === "TSUnionType") {
-      return type.types.map((t12) => this.typeToString(t12)).join(" | ");
+      return type.types.map((t15) => this.typeToString(t15)).join(" | ");
     }
     if (type.type === "TSTypeLiteral") {
       return "object";
@@ -2014,7 +3331,7 @@ var NavigationAnalyzer = class {
   /** Attach parsed type params to navigator screens */
   attachParamsToNavigators(navigators, types) {
     for (const navigator of navigators) {
-      const matchingType = types.find((t12) => t12.type === navigator.type);
+      const matchingType = types.find((t15) => t15.type === navigator.type);
       if (matchingType) {
         for (const screen of navigator.screens) {
           const screenParams = matchingType.paramEntries.get(screen.name);
@@ -2103,9 +3420,9 @@ var ComponentAnalyzer = class {
         plugins: ["jsx", "typescript", ["decorators", { decoratorsBeforeExport: true }]]
       });
       const components = [];
-      traverse4__default.default(ast, {
-        JSXElement: (path9) => {
-          const component = this.extractComponentFromJSXElement(path9.node);
+      traverse5__default.default(ast, {
+        JSXElement: (path11) => {
+          const component = this.extractComponentFromJSXElement(path11.node);
           if (component) {
             components.push(component);
           }
@@ -2231,14 +3548,14 @@ var FormAnalyzer = class {
       this.stateVariables.clear();
       this.inputElements = [];
       this.submitButtons = [];
-      traverse4__default.default(ast, {
-        CallExpression: (path9) => {
-          this.extractStateVariables(path9.node);
+      traverse5__default.default(ast, {
+        CallExpression: (path11) => {
+          this.extractStateVariables(path11.node);
         }
       });
-      traverse4__default.default(ast, {
-        JSXElement: (path9) => {
-          this.extractFormElements(path9.node);
+      traverse5__default.default(ast, {
+        JSXElement: (path11) => {
+          this.extractFormElements(path11.node);
         }
       });
       const validationRules = this.extractValidationRules(ast);
@@ -2272,23 +3589,23 @@ var FormAnalyzer = class {
     for (const attr of openingElement.attributes) {
       if (BabelTypes__namespace.isJSXAttribute(attr) && BabelTypes__namespace.isJSXIdentifier(attr.name)) {
         const propName = attr.name.name;
-        const propValue = this.extractAttributeValue(attr.value);
+        const propValue2 = this.extractAttributeValue(attr.value);
         switch (propName) {
           case "label":
-            info.label = propValue;
+            info.label = propValue2;
             break;
           case "placeholder":
-            info.placeholder = propValue;
+            info.placeholder = propValue2;
             break;
           case "keyboardType":
-            info.keyboardType = propValue;
+            info.keyboardType = propValue2;
             break;
           case "testID":
-            info.testID = propValue;
+            info.testID = propValue2;
             break;
           case "appilotsId":
-            info.appilotsId = propValue;
-            if (propValue) info.varName = propValue;
+            info.appilotsId = propValue2;
+            if (propValue2) info.varName = propValue2;
             break;
           case "value":
             if (attr.value && BabelTypes__namespace.isJSXExpressionContainer(attr.value) && BabelTypes__namespace.isIdentifier(attr.value.expression)) {
@@ -2337,9 +3654,9 @@ var FormAnalyzer = class {
   }
   extractValidationRules(ast) {
     const rules = {};
-    traverse4__default.default(ast, {
-      IfStatement: (path9) => {
-        const test = path9.node.test;
+    traverse5__default.default(ast, {
+      IfStatement: (path11) => {
+        const test = path11.node.test;
         const rule = this.extractRuleFromCondition(test);
         if (rule) {
           const { field, description } = rule;
@@ -2393,7 +3710,7 @@ var FormAnalyzer = class {
   }
   buildForms(filePath, validationRules) {
     if (this.inputElements.length === 0) return [];
-    const fileName = path8__namespace.basename(filePath, path8__namespace.extname(filePath));
+    const fileName = path2__namespace.basename(filePath, path2__namespace.extname(filePath));
     const formId = `${fileName}Form`.replace(/Screen$/, "").toLowerCase();
     const fields = this.inputElements.map((input) => {
       const fieldType = this.inferFieldType(input);
@@ -2442,13 +3759,105 @@ var FormAnalyzer = class {
     return rule !== void 0 && rule.includes("required");
   }
 };
+
+// src/pipeline/composition.ts
+var MAX_DEPTH = 3;
+var MAX_VISITED_PER_SCREEN = 60;
+var MAX_FAN_IN = 3;
+var ADDRESSABLE = /* @__PURE__ */ new Set(["testID", "appilotsId", "accessibilityLabel", "label"]);
+function descendants(graph, from, screenFiles) {
+  const seen = /* @__PURE__ */ new Set([from]);
+  const out = [];
+  let frontier = [from];
+  for (let depth = 0; depth < MAX_DEPTH && frontier.length > 0; depth++) {
+    const next = [];
+    for (const file of frontier) {
+      for (const child of graph.renderedComponentFiles(file)) {
+        if (seen.has(child)) continue;
+        seen.add(child);
+        if (screenFiles.has(child)) continue;
+        out.push(child);
+        next.push(child);
+        if (out.length >= MAX_VISITED_PER_SCREEN) return out;
+      }
+    }
+    frontier = next;
+  }
+  return out;
+}
+function addressable(locator) {
+  if (!locator || typeof locator !== "object") return false;
+  const l = locator;
+  if (typeof l["source"] === "string" && ADDRESSABLE.has(l["source"])) return true;
+  return typeof l["testID"] === "string" && l["testID"].length > 0;
+}
+async function composeAffordances(options) {
+  const { screens, graph, analyzeFile, screenFiles } = options;
+  const byScreen = /* @__PURE__ */ new Map();
+  const fanIn = /* @__PURE__ */ new Map();
+  for (const screen of screens) {
+    if (!screen.filePath) continue;
+    const children = descendants(graph, screen.filePath, screenFiles);
+    byScreen.set(screen, children);
+    for (const child of children) fanIn.set(child, (fanIn.get(child) ?? 0) + 1);
+  }
+  const analyzed = /* @__PURE__ */ new Map();
+  let screensEnriched = 0;
+  let filesMerged = 0;
+  for (const [screen, children] of byScreen) {
+    const exclusive = children.filter((c) => (fanIn.get(c) ?? 0) <= MAX_FAN_IN);
+    if (exclusive.length === 0) continue;
+    const actionIds = new Set(screen.actions.map((a) => a.id));
+    const targetIds = new Set((screen.targets ?? []).map((t15) => t15.id));
+    const formIds = new Set(screen.forms.map((f) => f.id));
+    let gained = false;
+    for (const file of exclusive) {
+      if (!analyzed.has(file)) {
+        try {
+          analyzed.set(file, await analyzeFile(file));
+        } catch {
+          analyzed.set(file, null);
+        }
+      }
+      const child = analyzed.get(file);
+      if (!child) continue;
+      let merged = false;
+      for (const action of child.actions) {
+        if (!addressable(action.locator)) continue;
+        if (actionIds.has(action.id)) continue;
+        actionIds.add(action.id);
+        screen.actions.push(action);
+        merged = true;
+      }
+      for (const target of child.targets ?? []) {
+        if (!addressable(target.locator)) continue;
+        if (targetIds.has(target.id)) continue;
+        targetIds.add(target.id);
+        (screen.targets ??= []).push(target);
+        merged = true;
+      }
+      for (const form of child.forms) {
+        if (form.fields.length === 0) continue;
+        const id = formIds.has(form.id) ? `${form.id}:${child.name}` : form.id;
+        if (formIds.has(id)) continue;
+        formIds.add(id);
+        screen.forms.push({ ...form, id });
+        merged = true;
+      }
+      if (merged) {
+        filesMerged++;
+        gained = true;
+      }
+    }
+    if (gained) screensEnriched++;
+  }
+  return { screens, screensEnriched, filesMerged };
+}
+
+// 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
@@ -2456,14 +3865,31 @@ var ReactNativePlatformAnalyzer = class {
     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()
-    ]);
+    const navigation = await navigationAnalyzer.analyze();
+    const screenAnalyzer = new ScreenAnalyzer(config, {
+      strictScreens: options.strictScreens ?? true,
+      screenPatterns: options.screenPatterns,
+      // Menos os arquivos que declaram navegador: ver `navigatorFiles`.
+      routeTargetFiles: new Set(
+        [...navigationAnalyzer.routeTargets.values()].filter(
+          (file) => !navigationAnalyzer.navigatorFiles.has(file)
+        )
+      )
+    });
+    const screens = await screenAnalyzer.analyze();
+    const composed = await composeAffordances({
+      screens,
+      graph: navigationAnalyzer.graph,
+      analyzeFile: (file) => screenAnalyzer.analyzeFile(file),
+      screenFiles: new Set(screens.map((s) => s.filePath).filter(Boolean))
+    });
+    console.log(
+      `[ReactNativePlatformAnalyzer] Composi\xE7\xE3o: ${composed.filesMerged} componente(s) exclusivo(s) fundido(s) em ${composed.screensEnriched} tela(s)`
+    );
     console.log(
       `[ReactNativePlatformAnalyzer] Screen and navigation analysis complete. Found ${screens.length} screens`
     );
-    const screenFiles = await glob__default.default(config.include || ["**/*.tsx", "**/*.ts"], {
+    const screenFiles = await globSorted(config.include || ["**/*.tsx", "**/*.ts"], {
       cwd: config.rootDir,
       ignore: config.exclude || ["**/node_modules/**"]
     });
@@ -2471,7 +3897,7 @@ var ReactNativePlatformAnalyzer = class {
       `[ReactNativePlatformAnalyzer] Analyzing components and forms from ${screenFiles.length} files...`
     );
     const enrichmentPromises = screenFiles.map(async (file) => {
-      const filePath = path8__namespace.default.resolve(config.rootDir, file);
+      const filePath = path2__namespace.default.resolve(config.rootDir, file);
       try {
         const [components, forms] = await Promise.all([
           componentAnalyzer.analyzeFile(filePath),
@@ -2524,9 +3950,11 @@ var ReactNativePlatformAnalyzer = class {
     });
     return {
       screens: enrichedScreens,
+      controlEvidenceFiles: screenAnalyzer.controlEvidenceFiles,
       navigation,
       analyzedFiles: screenFiles.length,
-      ...screenAnalyzer.screensFilteredOut > 0 ? { screensFilteredOut: screenAnalyzer.screensFilteredOut } : {}
+      ...screenAnalyzer.screensFilteredOut > 0 ? { screensFilteredOut: screenAnalyzer.screensFilteredOut } : {},
+      diagnostics: { navigation: navigationAnalyzer.diagnostics }
     };
   }
   mergeForm(target, source) {
@@ -2544,9 +3972,12 @@ var ReactNativePlatformAnalyzer = class {
   findEquivalentField(fields, incoming) {
     return fields.find((field) => {
       if (field.name && incoming.name && field.name === incoming.name) return true;
-      if (field.valueBinding && incoming.valueBinding && field.valueBinding === incoming.valueBinding) return true;
-      if (field.locator?.id && incoming.locator?.id && field.locator.id === incoming.locator.id) return true;
-      if (field.placeholder && incoming.placeholder && field.placeholder === incoming.placeholder) return true;
+      if (field.valueBinding && incoming.valueBinding && field.valueBinding === incoming.valueBinding)
+        return true;
+      if (field.locator?.id && incoming.locator?.id && field.locator.id === incoming.locator.id)
+        return true;
+      if (field.placeholder && incoming.placeholder && field.placeholder === incoming.placeholder)
+        return true;
       if (field.locator?.accessibilityLabel && incoming.locator?.accessibilityLabel && field.locator.accessibilityLabel === incoming.locator.accessibilityLabel) {
         return true;
       }
@@ -2579,7 +4010,9 @@ var ReactNativePlatformAnalyzer = class {
     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;
+      const overlap = incoming.fields.filter(
+        (field) => this.findEquivalentField(form.fields, field)
+      ).length;
       if (overlap > 0 && (!best || overlap > best.overlap)) {
         best = { form, overlap };
       }
@@ -2733,13 +4166,13 @@ function staticRoutePath(node) {
   if (!node) return void 0;
   if (BabelTypes__namespace.isStringLiteral(node)) return node.value;
   if (BabelTypes__namespace.isTemplateLiteral(node)) {
-    let path9 = "";
+    let path11 = "";
     node.quasis.forEach((quasi, index) => {
-      path9 += quasi.value.cooked ?? quasi.value.raw;
+      path11 += quasi.value.cooked ?? quasi.value.raw;
       const expr = node.expressions[index];
-      if (expr) path9 += `:${paramNameOf(expr)}`;
+      if (expr) path11 += `:${paramNameOf(expr)}`;
     });
-    return path9;
+    return path11;
   }
   return void 0;
 }
@@ -2782,7 +4215,7 @@ function extractWebNavigationCalls(ast) {
       calls.push({ method: "navigate", targetPath: node.right.value });
     }
   };
-  traverse4__default.default(ast, {
+  traverse5__default.default(ast, {
     noScope: !BabelTypes__namespace.isFile(ast),
     enter: (nodePath) => inspect(nodePath.node)
   });
@@ -2824,17 +4257,17 @@ var WebScreenAnalyzer = class {
       include = ["**/*.tsx", "**/*.ts", "**/*.jsx", "**/*.js"],
       exclude = ["**/node_modules/**", "**/dist/**", "**/build/**"]
     } = this.config;
-    const files = (await glob__default.default(include, { cwd: this.config.rootDir, ignore: exclude })).filter(
+    const files = (await globSorted(include, { cwd: this.config.rootDir, ignore: exclude })).filter(
       (file) => !file.endsWith(".d.ts")
     );
-    const patternMatches = await glob__default.default(this.screenPatterns, {
+    const patternMatches = await globSorted(this.screenPatterns, {
       cwd: this.config.rootDir,
       ignore: exclude
     });
-    const patternSet = new Set(patternMatches.map((f) => path8__namespace.default.resolve(this.config.rootDir, f)));
+    const patternSet = new Set(patternMatches.map((f) => path2__namespace.default.resolve(this.config.rootDir, f)));
     const candidates = [];
     for (const file of files) {
-      const filePath = path8__namespace.default.resolve(this.config.rootDir, file);
+      const filePath = path2__namespace.default.resolve(this.config.rootDir, file);
       try {
         const candidate = await this.analyzeFile(filePath);
         if (!candidate) continue;
@@ -2878,7 +4311,7 @@ var WebScreenAnalyzer = class {
         }
       }
     }
-    const name = registerScreenMeta?.name || componentName || path8__namespace.default.basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
+    const name = registerScreenMeta?.name || componentName || path2__namespace.default.basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
     const descriptor = {
       name,
       filePath,
@@ -2904,7 +4337,7 @@ var WebScreenAnalyzer = class {
   // ── registerScreen ────────────────────────────────────────────────
   detectRegisterScreenCall(ast) {
     let found = false;
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       CallExpression: (nodePath) => {
         if (found) return;
         if (isRegisterScreenCallee(nodePath.node.callee)) {
@@ -2917,7 +4350,7 @@ var WebScreenAnalyzer = class {
   }
   extractRegisterScreenMetadata(ast) {
     let plain = null;
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       CallExpression: (nodePath) => {
         if (!isRegisterScreenCallee(nodePath.node.callee)) return;
         const arg = nodePath.node.arguments[0];
@@ -2965,7 +4398,7 @@ var WebScreenAnalyzer = class {
   extractComponentName(ast) {
     let defaultName = "";
     let firstExported = "";
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       ExportDefaultDeclaration: (nodePath) => {
         const declaration = nodePath.node.declaration;
         if (BabelTypes__namespace.isFunctionDeclaration(declaration) && declaration.id?.name) {
@@ -2994,7 +4427,7 @@ var WebScreenAnalyzer = class {
   extractComponents(ast) {
     const components = [];
     const seen = /* @__PURE__ */ new Set();
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         const name = getJsxElementName(element);
@@ -3015,7 +4448,7 @@ var WebScreenAnalyzer = class {
   // ── <label htmlFor> association ───────────────────────────────────
   collectHtmlForLabels(ast) {
     const labels = /* @__PURE__ */ new Map();
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXElement: (nodePath) => {
         const element = nodePath.node;
         if (getJsxElementName(element.openingElement) !== "label") return;
@@ -3058,7 +4491,7 @@ var WebScreenAnalyzer = class {
       formBuckets.set(formElement, bucket);
       return bucket;
     };
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXElement: (nodePath) => {
         const element = nodePath.node;
         const name = getJsxElementName(element.openingElement);
@@ -3075,7 +4508,7 @@ var WebScreenAnalyzer = class {
         if (!bucket.fields.has(field.name)) bucket.fields.set(field.name, field);
       }
     });
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXElement: (nodePath) => {
         const element = nodePath.node;
         const name = getJsxElementName(element.openingElement);
@@ -3253,7 +4686,7 @@ var WebScreenAnalyzer = class {
     const actionLabels = new Map(
       actions.filter((a) => a.label).map((a) => [normalizeLabel(a.label), a])
     );
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXElement: (nodePath) => {
         const element = nodePath.node;
         const name = getJsxElementName(element.openingElement);
@@ -3484,7 +4917,7 @@ var WebScreenAnalyzer = class {
     for (const call of extractWebNavigationCalls(ast)) {
       if (call.targetPath && call.targetPath.startsWith("/")) targets.add(call.targetPath);
     }
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXOpeningElement: (nodePath) => {
         const element = nodePath.node;
         const name = getJsxElementName(element);
@@ -3504,7 +4937,7 @@ var WebScreenAnalyzer = class {
   extractCollections(ast) {
     const collections = [];
     const seen = /* @__PURE__ */ new Set();
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXExpressionContainer: (nodePath) => {
         const expr = nodePath.node.expression;
         if (!BabelTypes__namespace.isCallExpression(expr) || !BabelTypes__namespace.isMemberExpression(expr.callee) || !BabelTypes__namespace.isIdentifier(expr.callee.object) || !BabelTypes__namespace.isIdentifier(expr.callee.property) || expr.callee.property.name !== "map") {
@@ -3616,7 +5049,7 @@ function firstCalledFunctionName(node) {
 }
 function containsWindowConfirm(body) {
   let found = false;
-  traverse4__default.default(
+  traverse5__default.default(
     body,
     {
       noScope: true,
@@ -3668,7 +5101,7 @@ function collectionItemNames(callback) {
 function collectionDisplayFields(callback, itemNames) {
   const fields = /* @__PURE__ */ new Set();
   if (!callback.body) return [];
-  traverse4__default.default(
+  traverse5__default.default(
     callback.body,
     {
       noScope: true,
@@ -3685,7 +5118,7 @@ function collectionDisplayFields(callback, itemNames) {
 function collectionKeyField(callback, itemNames) {
   let keyField;
   if (!callback.body) return void 0;
-  traverse4__default.default(
+  traverse5__default.default(
     callback.body,
     {
       noScope: true,
@@ -3767,7 +5200,9 @@ var WebNavigationAnalyzer = class {
     for (const filePath of files) {
       try {
         const content = await fs$1.promises.readFile(filePath, "utf-8");
-        if (!/createBrowserRouter|createHashRouter|createMemoryRouter|useRoutes|<Route[\s>]/.test(content)) {
+        if (!/createBrowserRouter|createHashRouter|createMemoryRouter|useRoutes|<Route[\s>]/.test(
+          content
+        )) {
           continue;
         }
         const ast = parseSource(content, this.config.parserPlugins);
@@ -3797,8 +5232,8 @@ var WebNavigationAnalyzer = class {
       ...this.config.exclude || [],
       ...this.navigationExclude
     ];
-    const files = await glob__default.default(patterns, { cwd: this.config.rootDir, ignore });
-    return files.map((file) => path8__namespace.default.join(this.config.rootDir, file));
+    const files = await globSorted(patterns, { cwd: this.config.rootDir, ignore });
+    return files.map((file) => path2__namespace.default.join(this.config.rootDir, file));
   }
   // ── JSX <Route> style ────────────────────────────────────────────
   extractJsxRoutes(ast) {
@@ -3826,7 +5261,7 @@ var WebNavigationAnalyzer = class {
         if (BabelTypes__namespace.isJSXElement(child)) visitRoute(child, fullPath);
       }
     };
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       JSXElement: (nodePath) => {
         const name = getJsxElementName(nodePath.node.openingElement);
         if (name !== "Routes" && name !== "Route") return;
@@ -3865,7 +5300,7 @@ var WebNavigationAnalyzer = class {
       "createMemoryRouter",
       "useRoutes"
     ]);
-    traverse4__default.default(ast, {
+    traverse5__default.default(ast, {
       CallExpression: (nodePath) => {
         const callee = nodePath.node.callee;
         if (!BabelTypes__namespace.isIdentifier(callee) || !ROUTER_FACTORIES.has(callee.name)) return;
@@ -3970,11 +5405,13 @@ var WebNavigationAnalyzer = class {
     return {
       screens,
       initialScreen: initialRoute?.screenName ?? "",
-      navigators: routes.length > 0 ? [{
-        name: navigatorName,
-        type: WEB_NAVIGATOR_TYPE,
-        screens: screenNames
-      }] : []
+      navigators: routes.length > 0 ? [
+        {
+          name: navigatorName,
+          type: WEB_NAVIGATOR_TYPE,
+          screens: screenNames
+        }
+      ] : []
     };
   }
 };
@@ -4296,8 +5733,8 @@ var ZodParsedType = util.arrayToEnum([
   "set"
 ]);
 var getParsedType = (data) => {
-  const t12 = typeof data;
-  switch (t12) {
+  const t15 = typeof data;
+  switch (t15) {
     case "undefined":
       return ZodParsedType.undefined;
     case "string":
@@ -4569,8 +6006,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path9, errorMaps, issueData } = params;
-  const fullPath = [...path9, ...issueData.path || []];
+  const { data, path: path11, errorMaps, issueData } = params;
+  const fullPath = [...path11, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -4686,11 +6123,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path9, key) {
+  constructor(parent, value, path11, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path9;
+    this._path = path11;
     this._key = key;
   }
   get path() {
@@ -8131,7 +9568,36 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../shared/dist/chunk-MKT45LRA.mjs
+// ../shared/dist/chunk-SWQOZWHP.mjs
+var SAFE_IMAGE_URL_RE = /^(?:https?:\/\/|data:image\/(?:png|jpe?g|gif|webp);base64,)/i;
+var HAS_SCHEME_RE = /^[\s\u0000-\u001f]*[a-z][a-z0-9+.-]*:/i;
+function isSafeImageUrl(value) {
+  if (value === null || value === void 0) return true;
+  const trimmed = value.trim();
+  if (trimmed === "") return true;
+  if (!HAS_SCHEME_RE.test(trimmed)) return true;
+  return SAFE_IMAGE_URL_RE.test(trimmed);
+}
+
+// ../shared/dist/chunk-KUMPS6RH.mjs
+var SUPPORTED_APPILOTS_LOCALES = ["pt-BR", "en", "es", "fr"];
+
+// ../shared/dist/chunk-2GTRKNPJ.mjs
+var symbols = external_exports.array(external_exports.string().max(240)).max(12);
+var controlEvidenceSchema = external_exports.object({
+  version: external_exports.literal(1),
+  siteId: external_exports.string().regex(/^[a-f0-9]{20}$/),
+  component: external_exports.string().max(240),
+  icons: symbols,
+  handler: external_exports.string().max(240).optional(),
+  calls: symbols,
+  argumentBindings: symbols,
+  conditions: symbols,
+  nativeConfirmation: external_exports.object({
+    title: external_exports.string().max(240).optional(),
+    destructiveOption: external_exports.boolean()
+  }).optional()
+});
 var locatorSourceSchema = external_exports.enum([
   "appilotsId",
   "testID",
@@ -8310,6 +9776,23 @@ var actionDescriptorSchema = external_exports.object({
   effect: external_exports.enum(["read", "write", "destructive"]).or(external_exports.string()).optional(),
   riskLevel: external_exports.enum(["low", "medium", "high"]).or(external_exports.string()).optional(),
   requiresConfirmation: external_exports.boolean().optional(),
+  /**
+   * How long this action's work is expected to take, in milliseconds,
+   * DECLARED by the app — not inferred (that is `appilotsInferred`).
+   *
+   * The SDK's post-action wait was a constant: 6s, or 10s when the
+   * generator could prove the handler awaits something. No constant
+   * fits, because app operations run from ~100ms to minutes, and the
+   * failure is silent in both directions — too short and the agent
+   * photographs a loading screen with no controls on it, too long and
+   * every fast press pays for the slowest one. Only the app knows.
+   *
+   * Absent means absent: the SDK keeps its current defaults, so a
+   * document generated before this field existed behaves exactly as it
+   * did. The SDK also clamps the value to its own safety ceiling — a
+   * declared budget is a request, not a licence to hang the session.
+   */
+  asyncBudgetMs: external_exports.number().int().positive().optional(),
   appilotsInferred: appilotsInferredActionSchema.optional()
 }).passthrough();
 var screenPermissionDescriptorSchema = external_exports.object({
@@ -8492,7 +9975,7 @@ external_exports.object({
   version: external_exports.string().default("1.0"),
   content: external_exports.record(external_exports.unknown())
 });
-var apiKeyScopeSchema = external_exports.enum(["sdk", "operator"]);
+var apiKeyScopeSchema = external_exports.enum(["sdk", "operator", "publish"]);
 var apiKeyEnvironmentSchema = external_exports.enum(["test", "live"]);
 external_exports.object({
   name: external_exports.string().min(1).max(100),
@@ -8503,8 +9986,8 @@ external_exports.object({
   scope: apiKeyScopeSchema.default("sdk"),
   environment: apiKeyEnvironmentSchema.optional(),
   expiresAt: external_exports.string().datetime().optional()
-}).refine((v) => v.scope !== "sdk" || !!v.projectId, {
-  message: 'projectId is required for scope "sdk"',
+}).refine((v) => v.scope === "operator" || !!v.projectId, {
+  message: "projectId is required for SDK and publishing keys",
   path: ["projectId"]
 });
 var boundedString = (max) => external_exports.string().max(max);
@@ -8529,10 +10012,21 @@ var snapshotInputSchema = external_exports.object({
   type: boundedString(40).optional(),
   required: external_exports.boolean().optional(),
   invalid: external_exports.boolean().optional(),
+  /**
+   * Whether the field holds anything, as its own fact rather than an
+   * inference over `value`. The value is the user's and is the first
+   * thing a privacy policy withholds; the existence of a value is the
+   * agent's and is what stops it filling the same field twice.
+   */
+  filled: external_exports.boolean().optional(),
+  /** This input has keyboard focus right now. */
+  focused: external_exports.boolean().optional(),
   inModal: external_exports.boolean().optional()
 }).passthrough();
 var snapshotButtonSchema = external_exports.object({
+  controlEvidence: controlEvidenceSchema.optional(),
   id: boundedString(160).optional(),
+  dispatchable: external_exports.boolean().optional(),
   provenance: identityProvenanceSchema.optional(),
   /**
    * False when the control is mounted but currently OUTSIDE the window —
@@ -8593,7 +10087,36 @@ var snapshotListSchema = external_exports.object({
    */
   source: boundedString(40).optional(),
   itemCount: external_exports.number().int().optional(),
+  /**
+   * Size of the whole collection when the app declared it, for a list
+   * that is a WINDOW onto more data than it holds.
+   *
+   * `itemCount` is how many rows the list is rendering from and
+   * `visibleItemCount` how many of those are mounted; neither can
+   * express "there are 36 and you are looking at the first 20",
+   * because a paginated list's `data` is the page. Absent means
+   * unknown — never "same as itemCount".
+   */
+  totalItemCount: external_exports.number().int().optional(),
   visibleItemCount: external_exports.number().int().optional(),
+  viewportItemCount: external_exports.number().int().nonnegative().optional(),
+  exploration: external_exports.object({
+    revision: external_exports.number().int().nonnegative(),
+    observedItemCount: external_exports.number().int().min(0).max(5e3),
+    observedRanges: external_exports.array(
+      external_exports.object({
+        start: external_exports.number().int().nonnegative(),
+        end: external_exports.number().int().nonnegative()
+      })
+    ).max(32),
+    rangesTruncated: external_exports.boolean(),
+    coverage: external_exports.enum(["partial", "all-loaded"]),
+    pagination: external_exports.enum(["possible", "not-declared"]),
+    scrollSteps: external_exports.number().int().nonnegative(),
+    remainingScrollSteps: external_exports.number().int().nonnegative(),
+    consecutiveNoProgress: external_exports.number().int().nonnegative(),
+    lastScroll: external_exports.enum(["moved", "no-progress", "boundary", "unverified"]).optional()
+  }).optional(),
   refreshing: external_exports.boolean().optional(),
   empty: external_exports.boolean().optional(),
   label: boundedString(300).optional(),
@@ -8641,6 +10164,7 @@ var snapshotChoiceGroupSchema = external_exports.object({
 }).passthrough();
 var snapshotElementSchema = external_exports.object({
   id: boundedString(160).optional(),
+  dispatchable: external_exports.boolean().optional(),
   role: boundedString(40).optional(),
   label: boundedString(300).optional(),
   texts: external_exports.array(boundedString(500)).max(50).optional(),
@@ -8684,6 +10208,34 @@ var agentSnapshotSchema = external_exports.object({
    * it. Optional: older SDKs never clamp and never send it.
    */
   truncated: external_exports.boolean().optional(),
+  /**
+   * What moved since the previous observation, computed on the device
+   * because that is the only side holding both snapshots.
+   *
+   * Shape only — counts, booleans, and ids the app declared itself — so
+   * it survives an observation whose content was withheld. ABSENT means
+   * there was no previous observation to compare against; `unchanged:
+   * true` means we compared and nothing moved, which is the strongest
+   * evidence available that an action did nothing. The two must not be
+   * collapsed, for the same reason `truncated` exists.
+   */
+  delta: external_exports.object({
+    routeChanged: external_exports.boolean().optional(),
+    modalOpened: external_exports.boolean().optional(),
+    modalClosed: external_exports.boolean().optional(),
+    loadingStarted: external_exports.boolean().optional(),
+    loadingFinished: external_exports.boolean().optional(),
+    textsAdded: external_exports.number().int().nonnegative().optional(),
+    textsRemoved: external_exports.number().int().nonnegative().optional(),
+    buttonsAddedIndices: external_exports.array(external_exports.number().int().nonnegative()).max(12).optional(),
+    buttonsRemoved: external_exports.number().int().nonnegative().optional(),
+    visibleRowsDelta: external_exports.number().int().optional(),
+    totalRowsDelta: external_exports.number().int().optional(),
+    fieldsNewlyFilled: external_exports.array(boundedString(160)).max(12).optional(),
+    fieldsCleared: external_exports.array(boundedString(160)).max(12).optional(),
+    invalidAppeared: external_exports.boolean().optional(),
+    unchanged: external_exports.boolean().optional()
+  }).passthrough().optional(),
   /**
    * How many of this screen's controls the client could name, split by
    * `identityProvenance`. Diagnostic only — the relay never grounds an
@@ -8702,6 +10254,10 @@ var agentSnapshotSchema = external_exports.object({
   }).passthrough().optional()
 }).passthrough();
 var agentContextSchema = external_exports.object({
+  missionProtocol: external_exports.literal(1).optional(),
+  missionId: boundedString(160).optional(),
+  /** Preferred supported device language, reported by the SDK independently of map/UI labels. */
+  deviceLocale: external_exports.enum(SUPPORTED_APPILOTS_LOCALES).optional(),
   /**
    * Client platform this observation was captured on. Optional and
    * additive (see `clientPlatformSchema`) — absent means
@@ -8717,7 +10273,19 @@ var agentContextSchema = external_exports.object({
     rootRouteNames: external_exports.array(boundedString(200)).max(200).optional(),
     currentRouteNames: external_exports.array(boundedString(200)).max(200).optional(),
     routeNames: external_exports.array(boundedString(200)).max(500).optional(),
-    canGoBack: external_exports.boolean().optional()
+    canGoBack: external_exports.boolean().optional(),
+    /**
+     * The stack a back press pops through, oldest first, ending on
+     * the current screen. `canGoBack` says a back exists; this says
+     * where it goes.
+     */
+    backStack: external_exports.array(boundedString(200)).max(50).optional(),
+    /**
+     * Screens the session has been on, oldest first. Names only —
+     * params carry record ids and often personal data, and a route
+     * name is structure.
+     */
+    visited: external_exports.array(boundedString(200)).max(8).optional()
   }).passthrough().optional(),
   screenMetadata: external_exports.object({
     name: boundedString(200).optional(),
@@ -8823,7 +10391,7 @@ var formFillPayloadSchema = external_exports.object({
   submitAfterFill: external_exports.boolean().optional()
 }).passthrough();
 var uiInteractionPayloadSchema = external_exports.object({
-  action: external_exports.enum(["press", "longPress", "scroll", "swipe", "focus", "set_value"]).default("press").optional(),
+  action: external_exports.enum(["press", "longPress", "toggle", "scroll", "swipe", "focus", "set_value"]).default("press").optional(),
   // `targetId` is the canonical server/LLM field. SDK runtimes still
   // accept `componentId` as a compatibility alias.
   targetId: external_exports.string().min(1),
@@ -8940,6 +10508,12 @@ var actionDiagnoseSchema = external_exports.object({
   requiresUserInput: external_exports.boolean().optional()
 });
 var actionResultSchema = external_exports.object({
+  nativeConfirmation: external_exports.object({
+    title: external_exports.string().max(300),
+    message: external_exports.string().max(1e3).optional(),
+    buttonLabel: external_exports.string().max(160).optional(),
+    handlerCompleted: external_exports.boolean()
+  }).optional(),
   actionId: external_exports.string(),
   type: external_exports.string(),
   success: external_exports.boolean(),
@@ -8991,8 +10565,15 @@ external_exports.object({
   // issue #169 — the observation the server grounds targets against, now
   // validated + bounded at the border instead of z.record(z.unknown()).
   context: agentContextSchema.optional(),
-  /** Hop counter — server enforces a cap to prevent runaway loops */
-  hop: external_exports.number().int().min(1).max(10).optional()
+  /**
+   * Hop counter — server enforces a cap to prevent runaway loops.
+   * The max here must stay ABOVE the server's `MAX_AGENT_HOPS` (10 since
+   * #503, apps/api/src/modules/agents/routes.ts): the first over-budget
+   * hop has to get through validation so the route can answer it with
+   * the friendly automation-limit message instead of a 422. The +3
+   * headroom mirrors what 7/10 was before the recalibration.
+   */
+  hop: external_exports.number().int().min(1).max(13).optional()
 });
 var agentAccessLevelSchema = external_exports.enum(["read", "write", "none"]);
 var screenPermissionSchema = external_exports.object({
@@ -9060,7 +10641,7 @@ external_exports.object({
   /** null = remove webhook, undefined = leave unchanged. */
   budgetWebhookUrl: external_exports.string().url().nullable().optional()
 }).strict();
-var localeSchema = external_exports.enum(["pt-BR", "en", "es"]);
+var localeSchema = external_exports.enum(SUPPORTED_APPILOTS_LOCALES);
 var hexColorSchema = external_exports.string().regex(/^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
   message: "Must be a hex color like #6366f1"
 });
@@ -9098,15 +10679,18 @@ var themeTokensSchema = external_exports.object({
    */
   mode: external_exports.enum(["auto", "light", "dark"]).optional()
 }).strict();
+var imageSourceField = external_exports.string().max(500).refine(isSafeImageUrl, {
+  message: "Only http(s) URLs, base64 image data URIs, emoji or asset ids are allowed here"
+});
 external_exports.object({
   /** Tone / persona instructions appended to the system prompt. */
   personaPrompt: external_exports.string().max(2048).nullable(),
   /** Display name in the chat header (e.g. "Aria"). */
   assistantName: external_exports.string().max(60).nullable(),
   /** URL or remote asset id for the avatar shown next to assistant turns. */
-  assistantAvatar: external_exports.string().max(500).nullable(),
+  assistantAvatar: imageSourceField.nullable(),
   /** Emoji or image URL for the empty-state icon. Auto-detected by prefix. */
-  emptyStateIcon: external_exports.string().max(500).nullable(),
+  emptyStateIcon: imageSourceField.nullable(),
   /** First-message text shown in the empty state. */
   welcomeMessage: external_exports.string().max(500).nullable(),
   /** Title rendered at the top of the chat. */
@@ -9120,20 +10704,20 @@ external_exports.object({
   /** Chat-open FAB background color. Null falls back to theme.colors.primary. */
   triggerButtonColor: hexColorSchema.nullable(),
   /** Image URL rendered inside the FAB instead of the default chat-bubble icon. */
-  triggerButtonImageUrl: external_exports.string().max(500).nullable()
+  triggerButtonImageUrl: imageSourceField.nullable()
 });
 external_exports.object({
   personaPrompt: external_exports.string().max(2048).nullable().optional(),
   assistantName: external_exports.string().max(60).nullable().optional(),
-  assistantAvatar: external_exports.string().max(500).nullable().optional(),
-  emptyStateIcon: external_exports.string().max(500).nullable().optional(),
+  assistantAvatar: imageSourceField.nullable().optional(),
+  emptyStateIcon: imageSourceField.nullable().optional(),
   welcomeMessage: external_exports.string().max(500).nullable().optional(),
   chatTitle: external_exports.string().max(60).nullable().optional(),
   poweredByVisible: external_exports.boolean().optional(),
   theme: themeTokensSchema.nullable().optional(),
   defaultLocale: localeSchema.nullable().optional(),
   triggerButtonColor: hexColorSchema.nullable().optional(),
-  triggerButtonImageUrl: external_exports.string().max(500).nullable().optional()
+  triggerButtonImageUrl: imageSourceField.nullable().optional()
 }).strict();
 var sandboxObservationSchema = external_exports.object({
   route: external_exports.string().max(200).optional(),
@@ -9153,7 +10737,19 @@ var sandboxObservationSchema = external_exports.object({
       type: external_exports.string().max(40).optional(),
       placeholder: external_exports.string().max(200).optional(),
       /** Inline validation state (SDK snapshot field). */
-      invalid: external_exports.boolean().optional()
+      invalid: external_exports.boolean().optional(),
+      /**
+       * Whether the field holds anything, as its own fact rather than
+       * an inference over `value`.
+       *
+       * Here because the eval posts through this schema: a fact the
+       * SDK produces and this contract has no word for is a fact the
+       * corpus can never grade the agent on. `invalid` and `required`
+       * were already here; these two were the half that was missing.
+       */
+      filled: external_exports.boolean().optional(),
+      /** This input has keyboard focus right now. */
+      focused: external_exports.boolean().optional()
     })
   ).max(100).optional(),
   buttons: external_exports.array(
@@ -9632,7 +11228,7 @@ var manifestSchema = external_exports.object({
   navigation: navigationGraphSchema.partial().optional()
 }).passthrough();
 async function loadManifest(rootDir, manifestPath) {
-  const resolvedPath = path8__namespace.default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
+  const resolvedPath = path2__namespace.default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
   let raw;
   try {
     raw = await fs.readFile(resolvedPath, "utf-8");
@@ -9715,6 +11311,12 @@ function mergeManifestNavigation(analyzerNavigation, manifestNavigation) {
   };
 }
 
+// src/generators/checksum.ts
+function serializeForChecksum(document) {
+  const { generatedAt: _generatedAt, ...content } = document;
+  return JSON.stringify(content, null, 2);
+}
+
 // src/pipeline/enrichment.ts
 function enrichScreenForAgent(screen) {
   const targets = mergeTargets([
@@ -9791,7 +11393,10 @@ function mergeTargets(targets) {
   for (const target of targets) {
     if (!target.id) continue;
     const existing = byId.get(target.id);
-    byId.set(target.id, existing ? { ...target, ...existing, locator: existing.locator ?? target.locator } : target);
+    byId.set(
+      target.id,
+      existing ? { ...target, ...existing, locator: existing.locator ?? target.locator } : target
+    );
   }
   return Array.from(byId.values()).sort((a, b) => a.id.localeCompare(b.id));
 }
@@ -9836,7 +11441,10 @@ function synthesizeFlows(screen, targets) {
         intent: "destructive_action",
         steps: [
           { type: "press", target: action.id, label: action.label },
-          { type: "confirm", description: "Wait for native or custom confirmation before continuing" },
+          {
+            type: "confirm",
+            description: "Wait for native or custom confirmation before continuing"
+          },
           { type: "wait", description: describeWait(action) }
         ],
         waitPolicy: waitPolicyForAction(action),
@@ -9851,10 +11459,19 @@ function synthesizeFlows(screen, targets) {
         title: `Act on an item in ${collection.id}`,
         intent: "list_action",
         steps: [
-          { type: "choose-list-item", target: collection.id, description: "Resolve the user reference to a visible or searchable row" },
-          { type: "press", description: collection.rowAction?.description ?? "Open the row action" }
+          {
+            type: "choose-list-item",
+            target: collection.id,
+            description: "Resolve the user reference to a visible or searchable row"
+          },
+          {
+            type: "press",
+            description: collection.rowAction?.description ?? "Open the row action"
+          }
         ],
-        waitPolicy: { expectedOutcome: collection.rowAction?.targetScreen ? "navigation" : "inline-feedback" }
+        waitPolicy: {
+          expectedOutcome: collection.rowAction?.targetScreen ? "navigation" : "inline-feedback"
+        }
       });
     }
   }
@@ -9862,25 +11479,32 @@ function synthesizeFlows(screen, targets) {
 }
 function waitPolicyForAction(action) {
   const expectedOutcome = action.successSignal?.type === "goBack" ? "goBack" : action.appilotsInferred?.expectedOutcome ?? (action.targetScreen ? "navigation" : void 0);
-  const signals = [action.successSignal, action.failureSignal].filter(Boolean);
+  const signals = [action.successSignal, action.failureSignal].filter(
+    Boolean
+  );
+  const maxMs = action.asyncBudgetMs ?? (action.appilotsInferred?.isAsyncTrigger ? 1e4 : void 0);
   return {
     ...expectedOutcome ? { expectedOutcome } : {},
     ...signals && signals.length > 0 ? { signals } : {},
-    ...action.appilotsInferred?.isAsyncTrigger ? { maxMs: 1e4 } : {}
+    ...maxMs !== void 0 ? { maxMs } : {}
   };
 }
 function describeWait(action) {
   if (action.successSignal?.description) return action.successSignal.description;
-  if (action.successSignal?.type === "goBack") return "Wait for the app to return to the previous screen";
+  if (action.successSignal?.type === "goBack")
+    return "Wait for the app to return to the previous screen";
   if (action.targetScreen) return `Wait for navigation to ${action.targetScreen}`;
-  if (action.appilotsInferred?.expectedOutcome) return `Wait for ${action.appilotsInferred.expectedOutcome}`;
+  if (action.appilotsInferred?.expectedOutcome)
+    return `Wait for ${action.appilotsInferred.expectedOutcome}`;
   return "Wait for the UI to settle";
 }
 function synthesizeAgentHints(screen, targets, flows) {
   const preferredTargets = targets.filter((target) => ["submit", "button", "list"].includes(target.role)).slice(0, 8).map((target) => target.id);
   const commonTasks = flows.slice(0, 6).map((flow) => flow.title);
   const safetyNotes = screen.actions.filter((action) => action.destructive || action.requiresConfirmation).map((action) => `${action.id} requires confirmation`);
-  const firstAsyncAction = screen.actions.find((action) => action.appilotsInferred?.isAsyncTrigger);
+  const firstAsyncAction = screen.actions.find(
+    (action) => action.appilotsInferred?.isAsyncTrigger || action.asyncBudgetMs !== void 0
+  );
   const hints = {
     primaryGoal: synthesizePrimaryGoal(screen),
     commonTasks,
@@ -9907,7 +11531,9 @@ function synthesizePrimaryGoal(screen) {
   }
   const fieldCount = uniqueFields.size;
   if (fieldCount > 0) {
-    const requiredCount = Array.from(uniqueFields.values()).filter((field) => field.required).length;
+    const requiredCount = Array.from(uniqueFields.values()).filter(
+      (field) => field.required
+    ).length;
     const fieldLabel = fieldCount === 1 ? "field" : "fields";
     goals.push(
       requiredCount > 0 ? `Complete a form with ${fieldCount} ${fieldLabel} (${requiredCount} required)` : `Complete a form with ${fieldCount} ${fieldLabel}`
@@ -9921,7 +11547,9 @@ function synthesizePrimaryGoal(screen) {
   if (submitCount > 0) {
     goals.push(`Submit ${submitCount === 1 ? "the primary form" : `${submitCount} forms/actions`}`);
   }
-  const asyncCount = screen.actions.filter((action) => action.appilotsInferred?.isAsyncTrigger).length;
+  const asyncCount = screen.actions.filter(
+    (action) => action.appilotsInferred?.isAsyncTrigger
+  ).length;
   if (asyncCount > 0) {
     goals.push(`Wait for ${asyncCount === 1 ? "async feedback" : "async action feedback"}`);
   }
@@ -9996,7 +11624,7 @@ var MCPGenerator = class _MCPGenerator {
     const agentReadyScreens = mergedScreens.map(
       (screen) => enrichScreenForAgent({
         ...screen,
-        filePath: screen.filePath ? path8__namespace.default.relative(this.generatorConfig.rootDir, screen.filePath) : screen.filePath
+        filePath: screen.filePath ? path2__namespace.default.relative(this.generatorConfig.rootDir, screen.filePath) : screen.filePath
       })
     );
     const projectInfo = await this.getProjectInfo();
@@ -10020,19 +11648,33 @@ var MCPGenerator = class _MCPGenerator {
       }
     };
     const serialized = JSON.stringify(document, null, 2);
-    const checksum = this.calculateChecksum(serialized);
-    const filePath = path8__namespace.default.resolve(outputDir, `mcp-document.${this.options.format}`);
+    const checksum = this.calculateChecksum(serializeForChecksum(document));
+    const filePath = path2__namespace.default.resolve(outputDir, `mcp-document.${this.options.format}`);
     await fs.writeFile(filePath, serialized, "utf-8");
     console.log(`[MCPGenerator] Document written to: ${filePath}`);
-    const checksumFilePath = path8__namespace.default.resolve(outputDir, ".appilots-checksum");
+    const controlFiles = analyzed.controlEvidenceFiles ?? {};
+    await fs.writeFile(
+      path2__namespace.default.resolve(outputDir, "control-evidence.json"),
+      JSON.stringify({ version: 1, files: controlFiles }, null, 2),
+      "utf-8"
+    );
+    const checksumFilePath = path2__namespace.default.resolve(outputDir, ".appilots-checksum");
     await fs.writeFile(checksumFilePath, checksum, "utf-8");
     console.log(`[MCPGenerator] Checksum written to: ${checksumFilePath}`);
+    const evidenceCount = Object.values(controlFiles).reduce(
+      (sum, entries) => sum + entries.length,
+      0
+    );
+    console.log(
+      `[MCPGenerator] Source evidence: ${evidenceCount} icon controls across ${Object.keys(controlFiles).length} files (runtime binding required)`
+    );
     console.log("[MCPGenerator] Generation complete!");
     return {
       document,
       filePath,
       format: this.options.format,
-      checksum
+      checksum,
+      ...analyzed.diagnostics ? { diagnostics: analyzed.diagnostics } : {}
     };
   }
   /**
@@ -10044,7 +11686,7 @@ var MCPGenerator = class _MCPGenerator {
    * after calling `generate()`.
    */
   static async readPreviousChecksum(outputDir) {
-    const checksumFilePath = path8__namespace.default.resolve(outputDir, ".appilots-checksum");
+    const checksumFilePath = path2__namespace.default.resolve(outputDir, ".appilots-checksum");
     try {
       const content = await fs.readFile(checksumFilePath, "utf-8");
       return content.trim() || null;
@@ -10063,7 +11705,7 @@ var MCPGenerator = class _MCPGenerator {
    */
   async getProjectInfo() {
     try {
-      const packageJsonPath = path8__namespace.default.resolve(this.analyzerConfig.rootDir, "package.json");
+      const packageJsonPath = path2__namespace.default.resolve(this.analyzerConfig.rootDir, "package.json");
       const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
       const packageJson = JSON.parse(packageJsonContent);
       return {
@@ -10091,7 +11733,8 @@ var KNOWN_CONFIG_KEYS = [
   "navigationExclude",
   "platform",
   "manifestPath",
-  "eval"
+  "eval",
+  "knowledge"
 ];
 var KEY_ALIASES = {
   apiUrl: "serverUrl",
@@ -10146,12 +11789,12 @@ function getEnvOverrides(env = process.env) {
     return trimmed ? trimmed : void 0;
   };
   return {
-    apiKey: clean(env.APPILOTS_API_KEY),
+    apiKey: clean(env.APPILOTS_PUBLISH_KEY) ?? clean(env.APPILOTS_API_KEY),
     projectId: clean(env.APPILOTS_PROJECT_ID),
     serverUrl: clean(env.APPILOTS_SERVER_URL)
   };
 }
-function loadConfig(onWarn) {
+function loadConfig(onWarn, options = {}) {
   const configPath = getConfigPath();
   const env = getEnvOverrides();
   let fileConfig = {};
@@ -10190,6 +11833,10 @@ function loadConfig(onWarn) {
   };
   const validation = validateConfig(merged);
   validation.warnings.unshift(...legacyWarnings);
+  if (options.requireApiKey === false) {
+    validation.errors = validation.errors.filter((e) => !e.startsWith("apiKey"));
+    validation.valid = validation.errors.length === 0;
+  }
   if (fileConfig.serverUrl === void 0 && env.serverUrl === void 0) {
     for (const key of Object.keys(fileConfig)) {
       if (KNOWN_CONFIG_KEYS.includes(key)) continue;
@@ -10219,7 +11866,7 @@ function loadConfig(onWarn) {
   return merged;
 }
 function saveConfig(dir, config) {
-  const configPath = path8.join(dir, ".appilotsrc");
+  const configPath = path2.join(dir, ".appilotsrc");
   const existingConfig = getConfigPath() ? loadConfig() : null;
   const mergedConfig = {
     apiKey: config.apiKey || existingConfig?.apiKey || "",
@@ -10235,7 +11882,8 @@ function saveConfig(dir, config) {
     navigationExclude: config.navigationExclude || existingConfig?.navigationExclude,
     platform: config.platform || existingConfig?.platform,
     manifestPath: config.manifestPath || existingConfig?.manifestPath,
-    eval: config.eval || existingConfig?.eval
+    eval: config.eval || existingConfig?.eval,
+    knowledge: config.knowledge || existingConfig?.knowledge
   };
   try {
     fs$1.writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2), "utf-8");
@@ -10246,19 +11894,19 @@ function saveConfig(dir, config) {
   }
 }
 function getConfigPath() {
-  let currentDir = path8.resolve(process.cwd());
-  const root = path8.resolve("/");
+  let currentDir = path2.resolve(process.cwd());
+  const root = path2.resolve("/");
   while (currentDir !== root) {
-    const configPath = path8.join(currentDir, ".appilotsrc");
+    const configPath = path2.join(currentDir, ".appilotsrc");
     try {
       if (fs$1.existsSync(configPath) && fs$1.statSync(configPath).isFile()) {
         return configPath;
       }
     } catch {
     }
-    currentDir = path8.resolve(currentDir, "..");
+    currentDir = path2.resolve(currentDir, "..");
   }
-  const rootConfigPath = path8.join(root, ".appilotsrc");
+  const rootConfigPath = path2.join(root, ".appilotsrc");
   try {
     if (fs$1.existsSync(rootConfigPath) && fs$1.statSync(rootConfigPath).isFile()) {
       return rootConfigPath;
@@ -10328,6 +11976,19 @@ function validateConfig(config) {
   if (config.manifestPath !== void 0 && typeof config.manifestPath !== "string") {
     errors.push("manifestPath must be a string");
   }
+  if (config.knowledge !== void 0) {
+    if (typeof config.knowledge !== "object" || config.knowledge === null || Array.isArray(config.knowledge)) {
+      errors.push("knowledge must be an object");
+    } else {
+      const kc = config.knowledge;
+      for (const field of ["sources", "exclude"]) {
+        const value = kc[field];
+        if (value !== void 0 && (!Array.isArray(value) || !value.every((item) => typeof item === "string"))) {
+          errors.push(`knowledge.${field} must be an array of strings`);
+        }
+      }
+    }
+  }
   if (config.eval !== void 0) {
     if (typeof config.eval !== "object" || config.eval === null || Array.isArray(config.eval)) {
       errors.push("eval must be an object");
@@ -10604,6 +12265,48 @@ var AppilotsAPIClient = class {
       };
     }
   }
+  /**
+   * Syncs knowledge documents with the Appilots backend.
+   *
+   * @param documents Array of documents to sync (filename, base64 content, mimeType, checksum)
+   * @returns KnowledgeSyncResult with counts of uploaded, skipped, and errored docs
+   */
+  async knowledgeSync(documents) {
+    try {
+      const response = await this.request(`${this.baseUrl}/cli/knowledge/sync`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ documents })
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        return {
+          success: false,
+          uploaded: 0,
+          skipped: 0,
+          errors: 0,
+          error: describeApiError(errorData, `HTTP ${response.status}: ${response.statusText}`)
+        };
+      }
+      const json = await response.json();
+      const inner = json.data ?? json;
+      return {
+        success: true,
+        ...inner
+      };
+    } catch (error) {
+      return {
+        success: false,
+        uploaded: 0,
+        skipped: 0,
+        errors: 0,
+        error: error instanceof Error ? error.message : "Failed to sync knowledge with Appilots API"
+      };
+    }
+  }
   /**
    * Checks if the Appilots API server is healthy
    *
@@ -10622,7 +12325,7 @@ var AppilotsAPIClient = class {
 };
 
 // src/version.ts
-var CLI_VERSION = "0.11.0";
+var CLI_VERSION = "0.13.0";
 
 exports.AppilotsAPIClient = AppilotsAPIClient;
 exports.CLI_VERSION = CLI_VERSION;