@appilots/cli 0.11.0 → 0.11.3

package/dist/index.mjs

@@ -1,12 +1,12 @@
 import fs, { readFile, mkdir, writeFile } from 'fs/promises';
-import * as path8 from 'path';
-import path8__default, { join, resolve } from 'path';
+import * as path2 from 'path';
+import path2__default, { join, resolve } from 'path';
 import traverse4 from '@babel/traverse';
 import * as BabelTypes from '@babel/types';
-import glob from 'fast-glob';
+import fastGlob from 'fast-glob';
 import * as parser from '@babel/parser';
 import { parse } from '@babel/parser';
-import { promises, readFileSync, writeFileSync, existsSync, statSync } from 'fs';
+import { promises, readFileSync, writeFileSync, existsSync, statSync, readdirSync } from 'fs';
 import { createHash } from 'crypto';
 
 var __defProp = Object.defineProperty;
@@ -14,6 +14,13 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+function byCodeUnit(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+async function globSorted(patterns, options) {
+  const files = await fastGlob(patterns, options);
+  return files.sort(byCodeUnit);
+}
 var DEFAULT_PARSER_PLUGINS = [
   "jsx",
   "typescript",
@@ -398,14 +405,25 @@ 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;
   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 */
@@ -417,7 +435,7 @@ var ScreenAnalyzer = class {
         console.log(`[ScreenAnalyzer] Strict mode ON \u2014 screen patterns:`, this.screenPatterns);
       }
     }
-    const files = await glob(include, {
+    const files = await globSorted(include, {
       cwd: this.config.rootDir,
       ignore: exclude
     });
@@ -426,23 +444,24 @@ var ScreenAnalyzer = class {
     }
     let screenPatternFiles = null;
     if (this.strictScreens) {
-      const matched = await glob(this.screenPatterns, {
+      const matched = await globSorted(this.screenPatterns, {
         cwd: this.config.rootDir,
         ignore: exclude
       });
-      screenPatternFiles = new Set(matched.map((f) => path8__default.resolve(this.config.rootDir, f)));
+      screenPatternFiles = new Set(matched.map((f) => path2__default.resolve(this.config.rootDir, f)));
     }
     const screens = [];
     this.screensFilteredOut = 0;
     for (const file of files) {
-      const filePath = path8__default.resolve(this.config.rootDir, file);
+      const filePath = path2__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}`);
@@ -650,6 +669,8 @@ var ScreenAnalyzer = class {
         action.riskLevel = value.value;
       } else if (key === "nativeConfirmationExpected" && BabelTypes.isBooleanLiteral(value)) {
         action.nativeConfirmationExpected = value.value;
+      } else if (key === "asyncBudgetMs" && BabelTypes.isNumericLiteral(value) && Number.isInteger(value.value) && value.value > 0) {
+        action.asyncBudgetMs = value.value;
       } else if (key === "appilotsInferred" && BabelTypes.isObjectExpression(value)) {
         action.appilotsInferred = this.parseAppilotsInferredObject(value);
       }
@@ -1629,43 +1650,871 @@ var ScreenAnalyzer = class {
    * E.g., /src/screens/ItemListScreen.tsx -> ItemListScreen
    */
   extractScreenName(filePath) {
-    const basename2 = path8__default.basename(filePath);
+    const basename2 = path2__default.basename(filePath);
     return basename2.replace(/\.(tsx?|jsx?)$/, "");
   }
 };
+var EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".cjs"];
+var MAX_HOPS = 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.parse(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__default.resolve(path2__default.dirname(fromFile), spec);
+    } else {
+      for (const { prefix, target } of this.aliases) {
+        if (spec === prefix || spec.startsWith(prefix + "/")) {
+          base = path2__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__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__default.join(base, "index" + e))
+    ];
+    let found = null;
+    for (const c of candidates) {
+      try {
+        if (existsSync(c) && 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.isImportDeclaration(stmt)) continue;
+      const source = stmt.source.value;
+      for (const spec of stmt.specifiers) {
+        if (BabelTypes.isImportDefaultSpecifier(spec)) {
+          out.set(spec.local.name, { source, imported: "default" });
+        } else if (BabelTypes.isImportNamespaceSpecifier(spec)) {
+          out.set(spec.local.name, { source, imported: "*" });
+        } else if (BabelTypes.isImportSpecifier(spec)) {
+          const imported = BabelTypes.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.isExportNamedDeclaration(stmt) ? stmt.declaration : stmt;
+      if (!BabelTypes.isVariableDeclaration(decl)) continue;
+      for (const d of decl.declarations) {
+        if (BabelTypes.isIdentifier(d.id) && d.id.name === name && d.init) {
+          return BabelTypes.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_HOPS) 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.isExportNamedDeclaration(stmt) || !stmt.source) continue;
+        for (const spec of stmt.specifiers) {
+          if (!BabelTypes.isExportSpecifier(spec)) continue;
+          const exported = BabelTypes.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.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.isExportDefaultDeclaration(stmt)) continue;
+        if (BabelTypes.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_HOPS) return null;
+    if (BabelTypes.isStringLiteral(node)) return node.value;
+    if (BabelTypes.isTemplateLiteral(node)) {
+      return node.expressions.length === 0 ? node.quasis[0]?.value.cooked ?? null : null;
+    }
+    if (BabelTypes.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.isObjectExpression(current)) return null;
+      const prop = objectProperty(current, key);
+      if (!prop) return null;
+      current = BabelTypes.isTSAsExpression(prop) ? prop.expression : prop;
+    }
+    return BabelTypes.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_HOPS) return null;
+    if (BabelTypes.isCallExpression(node)) {
+      for (const arg of node.arguments) {
+        if (BabelTypes.isIdentifier(arg) || BabelTypes.isMemberExpression(arg)) {
+          const inner = this.componentFile(file, arg, hops + 1);
+          if (inner) return inner;
+        }
+      }
+      return null;
+    }
+    if (BabelTypes.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.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.isJSXOpeningElement(node) && BabelTypes.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.isMemberExpression(current)) {
+    if (current.computed) {
+      if (!BabelTypes.isStringLiteral(current.property)) return null;
+      chain.unshift(current.property.value);
+    } else if (BabelTypes.isIdentifier(current.property)) {
+      chain.unshift(current.property.name);
+    } else {
+      return null;
+    }
+    current = current.object;
+  }
+  return BabelTypes.isIdentifier(current) ? { root: current.name, path: chain } : null;
+}
+function objectProperty(obj, key) {
+  for (const prop of obj.properties) {
+    if (!BabelTypes.isObjectProperty(prop)) continue;
+    const name = BabelTypes.isIdentifier(prop.key) ? prop.key.name : BabelTypes.isStringLiteral(prop.key) ? prop.key.value : null;
+    if (name === key && BabelTypes.isExpression(prop.value)) return prop.value;
+  }
+  return null;
+}
+function readTsconfigAliases(rootDir) {
+  const file = path2__default.join(rootDir, "tsconfig.json");
+  if (!existsSync(file)) return [];
+  let parsed;
+  try {
+    const raw = stripJsonComments(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__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__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__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__default.sep)
+      );
+      return containsApp ? packages : [];
+    }
+    const parent = path2__default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return [];
+}
+function workspaceGlobs(dir) {
+  const pnpm = path2__default.join(dir, "pnpm-workspace.yaml");
+  if (existsSync(pnpm)) {
+    try {
+      const lines = 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__default.join(dir, "package.json");
+  if (!existsSync(pkgPath)) return [];
+  try {
+    const pkg = JSON.parse(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 add = (dir) => {
+    const pkgPath = path2__default.join(dir, "package.json");
+    if (!existsSync(pkgPath)) return;
+    try {
+      const name = JSON.parse(readFileSync(pkgPath, "utf-8")).name;
+      if (name) out.push({ name, dir });
+    } catch {
+    }
+  };
+  for (const glob of globs) {
+    if (glob.endsWith("/*")) {
+      const parent = path2__default.join(root, glob.slice(0, -2));
+      let entries = [];
+      try {
+        entries = readdirSync(parent);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        const dir = path2__default.join(parent, entry);
+        try {
+          if (statSync(dir).isDirectory()) add(dir);
+        } catch {
+        }
+      }
+    } else if (!glob.includes("*")) {
+      add(path2__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 = 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__default.join(dir, "_layout" + ext);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function analyzeExpoRouter(appRoot) {
+  let routeDir = null;
+  for (const candidate of ROUTE_DIR_CANDIDATES) {
+    const full = path2__default.join(appRoot, candidate);
+    if (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 = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort()) {
+      const full = path2__default.join(dir, entry);
+      let isDir = false;
+      try {
+        isDir = 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__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.isCallExpression(value)) {
+    const arg = value.arguments[0];
+    return arg ? unwrapStaticScreen(arg) : null;
+  }
+  if (BabelTypes.isObjectExpression(value)) {
+    for (const prop of value.properties) {
+      if (!BabelTypes.isObjectProperty(prop)) continue;
+      const key = BabelTypes.isIdentifier(prop.key) ? prop.key.name : null;
+      if (key === "screen" && BabelTypes.isExpression(prop.value)) return prop.value;
+    }
+    return null;
+  }
+  return BabelTypes.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 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();
+    traverse4(ast, {
+      CallExpression: (nodePath) => {
+        const callee = nodePath.node.callee;
+        if (!BabelTypes.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.isVariableDeclarator(up.node)) break;
+          if (!BabelTypes.isMemberExpression(up.node) && !BabelTypes.isCallExpression(up.node)) {
+            up = null;
+            break;
+          }
+          up = up.parentPath;
+        }
+        const declarator = up?.node;
+        if (!declarator || !BabelTypes.isVariableDeclarator(declarator) || !BabelTypes.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.isObjectExpression(config) || depth > 4) return [];
+    const out = [];
+    for (const prop of config.properties) {
+      if (!BabelTypes.isObjectProperty(prop)) continue;
+      const key = BabelTypes.isIdentifier(prop.key) ? prop.key.name : BabelTypes.isStringLiteral(prop.key) ? prop.key.value : null;
+      if (!key) continue;
+      if (key === "groups" && BabelTypes.isObjectExpression(prop.value)) {
+        for (const group of prop.value.properties) {
+          if (!BabelTypes.isObjectProperty(group) || !BabelTypes.isExpression(group.value)) continue;
+          out.push(
+            ...this.parseStaticScreens(
+              filePath,
+              group.value,
+              navigatorName,
+              navigatorType,
+              depth + 1
+            )
+          );
+        }
+        continue;
+      }
+      if (key !== "screens" || !BabelTypes.isObjectExpression(prop.value)) continue;
+      for (const entry of prop.value.properties) {
+        if (!BabelTypes.isObjectProperty(entry)) continue;
+        const routeName = BabelTypes.isIdentifier(entry.key) ? entry.key.name : BabelTypes.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}",
@@ -1676,91 +2525,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(patterns, {
+    const files = await globSorted(patterns, {
       cwd: this.config.rootDir,
       ignore: excludePatterns
     });
-    return files.map((file) => path8__default.join(this.config.rootDir, file));
+    return files.map((file) => path2__default.join(this.config.rootDir, file));
   }
-  /** Parse navigator definitions from a file */
-  parseNavigators(content, filePath) {
-    const navigators = [];
-    try {
-      const ast = parser.parse(content, {
-        sourceType: "module",
-        plugins: [
-          "jsx",
-          "typescript",
-          ...this.config.parserPlugins || []
-        ]
-      });
-      const navigatorCalls = /* @__PURE__ */ new Map();
-      const screensByNavigator = /* @__PURE__ */ new Map();
-      traverse4(ast, {
-        // Detect createStackNavigator / createTabNavigator / createDrawerNavigator calls
-        CallExpression: (nodePath) => {
-          const { node } = nodePath;
-          const callee = node.callee;
-          let navigatorType = null;
-          if (BabelTypes.isIdentifier(callee) && callee.name === "createNativeStackNavigator") {
-            navigatorType = "stack";
-          } else if (BabelTypes.isIdentifier(callee) && callee.name === "createStackNavigator") {
-            navigatorType = "stack";
-          } else if (BabelTypes.isIdentifier(callee) && callee.name === "createBottomTabNavigator") {
-            navigatorType = "tab";
-          } else if (BabelTypes.isIdentifier(callee) && callee.name === "createTabNavigator") {
-            navigatorType = "tab";
-          } else if (BabelTypes.isIdentifier(callee) && callee.name === "createDrawerNavigator") {
-            navigatorType = "drawer";
-          }
-          if (navigatorType) {
-            const parent = nodePath.parent;
-            if (BabelTypes.isVariableDeclarator(parent) && BabelTypes.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.isJSXMemberExpression(openingElement.name) && BabelTypes.isJSXIdentifier(openingElement.name.object)) {
-            const objectName = openingElement.name.object.name;
-            const propertyName = BabelTypes.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.isJSXAttribute(attr) && BabelTypes.isJSXIdentifier(attr.name) && attr.name.name === "initialRouteName"
-                );
-                if (BabelTypes.isJSXAttribute(initialRouteAttr) && BabelTypes.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();
+    traverse4(ast, {
+      JSXElement: (nodePath) => {
+        const { node } = nodePath;
+        const openingElement = node.openingElement;
+        if (!BabelTypes.isJSXMemberExpression(openingElement.name) || !BabelTypes.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.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.isJSXAttribute(attr) && BabelTypes.isJSXIdentifier(attr.name) && attr.name.name === "initialRouteName"
+        );
+        if (BabelTypes.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();
+    traverse4(ast, {
+      JSXElement: (nodePath) => {
+        const name = nodePath.node.openingElement.name;
+        if (!BabelTypes.isJSXMemberExpression(name) || !BabelTypes.isJSXIdentifier(name.object)) return;
+        if (!BabelTypes.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.isJSXMemberExpression(parentName) && BabelTypes.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.isIdentifier(param) || !BabelTypes.isTSTypeAnnotation(param.typeAnnotation)) return null;
+    const annotation = param.typeAnnotation.typeAnnotation;
+    if (!BabelTypes.isTSTypeQuery(annotation) || !BabelTypes.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.isStringLiteral(value)) return value.value;
+    if (BabelTypes.isJSXExpressionContainer(value) && BabelTypes.isExpression(value.expression)) {
+      return this.graph.stringConstant(filePath, value.expression);
     }
-    return navigators;
+    return null;
   }
   /**
    * Is this JSX element `<navigatorVarName.MEMBER …>`?
@@ -1855,22 +2801,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.isJSXAttribute(a) && BabelTypes.isJSXIdentifier(a.name) && a.name.name === "name"
+    );
+    const screenName = BabelTypes.isJSXAttribute(nameAttr) ? this.attributeString(filePath, nameAttr) : null;
+    if (!screenName) return null;
+    const componentAttr = attrs.find(
+      (a) => BabelTypes.isJSXAttribute(a) && BabelTypes.isJSXIdentifier(a.name) && a.name.name === "component"
+    );
+    let componentFile = null;
+    if (BabelTypes.isJSXAttribute(componentAttr) && BabelTypes.isJSXExpressionContainer(componentAttr.value)) {
+      const expr = componentAttr.value.expression;
+      if (BabelTypes.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(
@@ -1966,7 +2938,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((t13) => this.typeToString(t13)).join(" | ");
     }
     if (type.type === "TSTypeLiteral") {
       return "object";
@@ -1987,7 +2959,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((t13) => t13.type === navigator.type);
       if (matchingType) {
         for (const screen of navigator.screens) {
           const screenParams = matchingType.paramEntries.get(screen.name);
@@ -2077,8 +3049,8 @@ var ComponentAnalyzer = class {
       });
       const components = [];
       traverse4(ast, {
-        JSXElement: (path9) => {
-          const component = this.extractComponentFromJSXElement(path9.node);
+        JSXElement: (path11) => {
+          const component = this.extractComponentFromJSXElement(path11.node);
           if (component) {
             components.push(component);
           }
@@ -2205,13 +3177,13 @@ var FormAnalyzer = class {
       this.inputElements = [];
       this.submitButtons = [];
       traverse4(ast, {
-        CallExpression: (path9) => {
-          this.extractStateVariables(path9.node);
+        CallExpression: (path11) => {
+          this.extractStateVariables(path11.node);
         }
       });
       traverse4(ast, {
-        JSXElement: (path9) => {
-          this.extractFormElements(path9.node);
+        JSXElement: (path11) => {
+          this.extractFormElements(path11.node);
         }
       });
       const validationRules = this.extractValidationRules(ast);
@@ -2311,8 +3283,8 @@ var FormAnalyzer = class {
   extractValidationRules(ast) {
     const rules = {};
     traverse4(ast, {
-      IfStatement: (path9) => {
-        const test = path9.node.test;
+      IfStatement: (path11) => {
+        const test = path11.node.test;
         const rule = this.extractRuleFromCondition(test);
         if (rule) {
           const { field, description } = rule;
@@ -2366,7 +3338,7 @@ var FormAnalyzer = class {
   }
   buildForms(filePath, validationRules) {
     if (this.inputElements.length === 0) return [];
-    const fileName = path8.basename(filePath, path8.extname(filePath));
+    const fileName = path2.basename(filePath, path2.extname(filePath));
     const formId = `${fileName}Form`.replace(/Screen$/, "").toLowerCase();
     const fields = this.inputElements.map((input) => {
       const fieldType = this.inferFieldType(input);
@@ -2415,13 +3387,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((t13) => t13.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
@@ -2429,14 +3493,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(config.include || ["**/*.tsx", "**/*.ts"], {
+    const screenFiles = await globSorted(config.include || ["**/*.tsx", "**/*.ts"], {
       cwd: config.rootDir,
       ignore: config.exclude || ["**/node_modules/**"]
     });
@@ -2444,7 +3525,7 @@ var ReactNativePlatformAnalyzer = class {
       `[ReactNativePlatformAnalyzer] Analyzing components and forms from ${screenFiles.length} files...`
     );
     const enrichmentPromises = screenFiles.map(async (file) => {
-      const filePath = path8__default.resolve(config.rootDir, file);
+      const filePath = path2__default.resolve(config.rootDir, file);
       try {
         const [components, forms] = await Promise.all([
           componentAnalyzer.analyzeFile(filePath),
@@ -2499,7 +3580,8 @@ var ReactNativePlatformAnalyzer = class {
       screens: enrichedScreens,
       navigation,
       analyzedFiles: screenFiles.length,
-      ...screenAnalyzer.screensFilteredOut > 0 ? { screensFilteredOut: screenAnalyzer.screensFilteredOut } : {}
+      ...screenAnalyzer.screensFilteredOut > 0 ? { screensFilteredOut: screenAnalyzer.screensFilteredOut } : {},
+      diagnostics: { navigation: navigationAnalyzer.diagnostics }
     };
   }
   mergeForm(target, source) {
@@ -2517,9 +3599,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;
       }
@@ -2552,7 +3637,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 };
       }
@@ -2706,13 +3793,13 @@ function staticRoutePath(node) {
   if (!node) return void 0;
   if (BabelTypes.isStringLiteral(node)) return node.value;
   if (BabelTypes.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;
 }
@@ -2797,17 +3884,17 @@ var WebScreenAnalyzer = class {
       include = ["**/*.tsx", "**/*.ts", "**/*.jsx", "**/*.js"],
       exclude = ["**/node_modules/**", "**/dist/**", "**/build/**"]
     } = this.config;
-    const files = (await glob(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(this.screenPatterns, {
+    const patternMatches = await globSorted(this.screenPatterns, {
       cwd: this.config.rootDir,
       ignore: exclude
     });
-    const patternSet = new Set(patternMatches.map((f) => path8__default.resolve(this.config.rootDir, f)));
+    const patternSet = new Set(patternMatches.map((f) => path2__default.resolve(this.config.rootDir, f)));
     const candidates = [];
     for (const file of files) {
-      const filePath = path8__default.resolve(this.config.rootDir, file);
+      const filePath = path2__default.resolve(this.config.rootDir, file);
       try {
         const candidate = await this.analyzeFile(filePath);
         if (!candidate) continue;
@@ -2851,7 +3938,7 @@ var WebScreenAnalyzer = class {
         }
       }
     }
-    const name = registerScreenMeta?.name || componentName || path8__default.basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
+    const name = registerScreenMeta?.name || componentName || path2__default.basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
     const descriptor = {
       name,
       filePath,
@@ -3740,7 +4827,9 @@ var WebNavigationAnalyzer = class {
     for (const filePath of files) {
       try {
         const content = await 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);
@@ -3770,8 +4859,8 @@ var WebNavigationAnalyzer = class {
       ...this.config.exclude || [],
       ...this.navigationExclude
     ];
-    const files = await glob(patterns, { cwd: this.config.rootDir, ignore });
-    return files.map((file) => path8__default.join(this.config.rootDir, file));
+    const files = await globSorted(patterns, { cwd: this.config.rootDir, ignore });
+    return files.map((file) => path2__default.join(this.config.rootDir, file));
   }
   // ── JSX <Route> style ────────────────────────────────────────────
   extractJsxRoutes(ast) {
@@ -3943,11 +5032,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
+        }
+      ] : []
     };
   }
 };
@@ -4269,8 +5360,8 @@ var ZodParsedType = util.arrayToEnum([
   "set"
 ]);
 var getParsedType = (data) => {
-  const t12 = typeof data;
-  switch (t12) {
+  const t13 = typeof data;
+  switch (t13) {
     case "undefined":
       return ZodParsedType.undefined;
     case "string":
@@ -4542,8 +5633,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
@@ -4659,11 +5750,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() {
@@ -8104,7 +9195,18 @@ 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-NMQNNPSJ.mjs
 var locatorSourceSchema = external_exports.enum([
   "appilotsId",
   "testID",
@@ -8283,6 +9385,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({
@@ -8465,7 +9584,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),
@@ -8476,8 +9595,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);
@@ -8502,6 +9621,15 @@ 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({
@@ -8657,6 +9785,32 @@ 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(),
+    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
@@ -8690,7 +9844,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(),
@@ -8796,7 +9962,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),
@@ -8964,8 +10130,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({
@@ -9071,15 +10244,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. */
@@ -9093,20 +10269,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(),
@@ -9126,7 +10302,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(
@@ -9605,7 +10793,7 @@ var manifestSchema = external_exports.object({
   navigation: navigationGraphSchema.partial().optional()
 }).passthrough();
 async function loadManifest(rootDir, manifestPath) {
-  const resolvedPath = path8__default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
+  const resolvedPath = path2__default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
   let raw;
   try {
     raw = await readFile(resolvedPath, "utf-8");
@@ -9688,6 +10876,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([
@@ -9764,7 +10958,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));
 }
@@ -9809,7 +11006,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),
@@ -9824,10 +11024,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"
+        }
       });
     }
   }
@@ -9835,25 +11044,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,
@@ -9880,7 +11096,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}`
@@ -9894,7 +11112,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"}`);
   }
@@ -9969,7 +11189,7 @@ var MCPGenerator = class _MCPGenerator {
     const agentReadyScreens = mergedScreens.map(
       (screen) => enrichScreenForAgent({
         ...screen,
-        filePath: screen.filePath ? path8__default.relative(this.generatorConfig.rootDir, screen.filePath) : screen.filePath
+        filePath: screen.filePath ? path2__default.relative(this.generatorConfig.rootDir, screen.filePath) : screen.filePath
       })
     );
     const projectInfo = await this.getProjectInfo();
@@ -9993,11 +11213,11 @@ var MCPGenerator = class _MCPGenerator {
       }
     };
     const serialized = JSON.stringify(document, null, 2);
-    const checksum = this.calculateChecksum(serialized);
-    const filePath = path8__default.resolve(outputDir, `mcp-document.${this.options.format}`);
+    const checksum = this.calculateChecksum(serializeForChecksum(document));
+    const filePath = path2__default.resolve(outputDir, `mcp-document.${this.options.format}`);
     await writeFile(filePath, serialized, "utf-8");
     console.log(`[MCPGenerator] Document written to: ${filePath}`);
-    const checksumFilePath = path8__default.resolve(outputDir, ".appilots-checksum");
+    const checksumFilePath = path2__default.resolve(outputDir, ".appilots-checksum");
     await writeFile(checksumFilePath, checksum, "utf-8");
     console.log(`[MCPGenerator] Checksum written to: ${checksumFilePath}`);
     console.log("[MCPGenerator] Generation complete!");
@@ -10005,7 +11225,8 @@ var MCPGenerator = class _MCPGenerator {
       document,
       filePath,
       format: this.options.format,
-      checksum
+      checksum,
+      ...analyzed.diagnostics ? { diagnostics: analyzed.diagnostics } : {}
     };
   }
   /**
@@ -10017,7 +11238,7 @@ var MCPGenerator = class _MCPGenerator {
    * after calling `generate()`.
    */
   static async readPreviousChecksum(outputDir) {
-    const checksumFilePath = path8__default.resolve(outputDir, ".appilots-checksum");
+    const checksumFilePath = path2__default.resolve(outputDir, ".appilots-checksum");
     try {
       const content = await readFile(checksumFilePath, "utf-8");
       return content.trim() || null;
@@ -10036,7 +11257,7 @@ var MCPGenerator = class _MCPGenerator {
    */
   async getProjectInfo() {
     try {
-      const packageJsonPath = path8__default.resolve(this.analyzerConfig.rootDir, "package.json");
+      const packageJsonPath = path2__default.resolve(this.analyzerConfig.rootDir, "package.json");
       const packageJsonContent = await readFile(packageJsonPath, "utf-8");
       const packageJson = JSON.parse(packageJsonContent);
       return {
@@ -10119,12 +11340,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 = {};
@@ -10163,6 +11384,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;
@@ -10595,7 +11820,7 @@ var AppilotsAPIClient = class {
 };
 
 // src/version.ts
-var CLI_VERSION = "0.11.0";
+var CLI_VERSION = "0.11.3";
 
 export { AppilotsAPIClient, CLI_VERSION, ComponentAnalyzer, DEFAULT_MANIFEST_FILENAME, DEFAULT_WEB_SCREEN_PATTERNS, FormAnalyzer, GenericPlatformAnalyzer, MCPGenerator, NavigationAnalyzer, ReactNativePlatformAnalyzer, ReactWebPlatformAnalyzer, ScreenAnalyzer, WebNavigationAnalyzer, WebScreenAnalyzer, formatMetadataWarnings, getConfigPath, getEnvOverrides, lintActionMetadata, loadConfig, loadManifest, mergeManifestNavigation, mergeManifestScreens, resolvePathToScreen, saveConfig, screenNameFromPath, validateConfig };
 //# sourceMappingURL=index.mjs.map