@appilots/cli 0.11.0 → 0.11.3

package/dist/cli/index.js

@@ -31,7 +31,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var import_commander8 = require("commander");
 
 // src/version.ts
-var CLI_VERSION = "0.11.0";
+var CLI_VERSION = "0.11.3";
 
 // src/config/index.ts
 var import_fs = require("fs");
@@ -107,12 +107,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 = {};
@@ -151,6 +151,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;
@@ -763,12 +767,18 @@ function initCommand() {
 // src/cli/commands/sync.ts
 var import_commander2 = require("commander");
 var import_promises5 = require("fs/promises");
-var import_node_path5 = require("path");
+var import_node_path7 = require("path");
 
 // src/generators/MCPGenerator.ts
 var import_promises4 = require("fs/promises");
 var import_node_crypto = require("crypto");
-var import_node_path3 = __toESM(require("path"));
+var import_node_path5 = __toESM(require("path"));
+
+// 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) {
@@ -846,7 +856,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));
 }
@@ -891,7 +904,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),
@@ -906,10 +922,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"
+        }
       });
     }
   }
@@ -917,25 +942,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,
@@ -962,7 +994,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}`
@@ -976,7 +1010,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"}`);
   }
@@ -986,15 +1022,23 @@ function synthesizePrimaryGoal(screen) {
 }
 
 // src/analyzers/ReactNativePlatformAnalyzer.ts
-var import_node_path = __toESM(require("path"));
-var import_fast_glob3 = __toESM(require("fast-glob"));
+var import_node_path3 = __toESM(require("path"));
+
+// src/utils/glob.ts
+var import_fast_glob = __toESM(require("fast-glob"));
+function byCodeUnit(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+async function globSorted(patterns, options) {
+  const files = await (0, import_fast_glob.default)(patterns, options);
+  return files.sort(byCodeUnit);
+}
 
 // src/analyzers/ScreenAnalyzer.ts
 var import_promises = __toESM(require("fs/promises"));
 var import_path3 = __toESM(require("path"));
 var import_traverse4 = __toESM(require("@babel/traverse"));
 var BabelTypes = __toESM(require("@babel/types"));
-var import_fast_glob = __toESM(require("fast-glob"));
 
 // src/ast/parse.ts
 var import_parser = require("@babel/parser");
@@ -1397,14 +1441,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 */
@@ -1416,7 +1471,7 @@ var ScreenAnalyzer = class {
         console.log(`[ScreenAnalyzer] Strict mode ON \u2014 screen patterns:`, this.screenPatterns);
       }
     }
-    const files = await (0, import_fast_glob.default)(include, {
+    const files = await globSorted(include, {
       cwd: this.config.rootDir,
       ignore: exclude
     });
@@ -1425,7 +1480,7 @@ var ScreenAnalyzer = class {
     }
     let screenPatternFiles = null;
     if (this.strictScreens) {
-      const matched = await (0, import_fast_glob.default)(this.screenPatterns, {
+      const matched = await globSorted(this.screenPatterns, {
         cwd: this.config.rootDir,
         ignore: exclude
       });
@@ -1441,7 +1496,8 @@ var ScreenAnalyzer = class {
         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): ${file2}`);
@@ -1649,6 +1705,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);
       }
@@ -2636,43 +2694,880 @@ var ScreenAnalyzer = class {
 // src/analyzers/NavigationAnalyzer.ts
 var import_fs4 = require("fs");
 var import_path4 = __toESM(require("path"));
-var import_fast_glob2 = __toESM(require("fast-glob"));
-var parser = __toESM(require("@babel/parser"));
+var parser2 = __toESM(require("@babel/parser"));
 var import_traverse5 = __toESM(require("@babel/traverse"));
+var t6 = __toESM(require("@babel/types"));
+
+// src/ast/navigation/module-graph.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+var parser = __toESM(require("@babel/parser"));
 var t5 = __toESM(require("@babel/types"));
+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(file2) {
+    const cached = this.asts.get(file2);
+    if (cached !== void 0) return cached;
+    let ast = null;
+    try {
+      ast = parser.parse((0, import_node_fs.readFileSync)(file2, "utf-8"), {
+        sourceType: "module",
+        plugins: ["jsx", "typescript"]
+      });
+    } catch {
+      ast = null;
+    }
+    this.asts.set(file2, 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 = import_node_path.default.resolve(import_node_path.default.dirname(fromFile), spec);
+    } else {
+      for (const { prefix, target } of this.aliases) {
+        if (spec === prefix || spec.startsWith(prefix + "/")) {
+          base = import_node_path.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 = import_node_path.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) => import_node_path.default.join(base, "index" + e))
+    ];
+    let found = null;
+    for (const c of candidates) {
+      try {
+        if ((0, import_node_fs.existsSync)(c) && (0, import_node_fs.statSync)(c).isFile()) {
+          found = c;
+          break;
+        }
+      } catch {
+      }
+    }
+    this.resolved.set(key, found);
+    return found;
+  }
+  /** `import`s do arquivo, por nome local. */
+  imports(file2) {
+    const out = /* @__PURE__ */ new Map();
+    const ast = this.parse(file2);
+    if (!ast) return out;
+    for (const stmt of ast.program.body) {
+      if (!t5.isImportDeclaration(stmt)) continue;
+      const source = stmt.source.value;
+      for (const spec of stmt.specifiers) {
+        if (t5.isImportDefaultSpecifier(spec)) {
+          out.set(spec.local.name, { source, imported: "default" });
+        } else if (t5.isImportNamespaceSpecifier(spec)) {
+          out.set(spec.local.name, { source, imported: "*" });
+        } else if (t5.isImportSpecifier(spec)) {
+          const imported = t5.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(file2, name) {
+    const ast = this.parse(file2);
+    if (!ast) return null;
+    for (const stmt of ast.program.body) {
+      const decl = t5.isExportNamedDeclaration(stmt) ? stmt.declaration : stmt;
+      if (!t5.isVariableDeclaration(decl)) continue;
+      for (const d of decl.declarations) {
+        if (t5.isIdentifier(d.id) && d.id.name === name && d.init) {
+          return t5.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(file2, name, hops = 0) {
+    if (hops > MAX_HOPS) return null;
+    if (this.topLevelInit(file2, name) !== null) return { file: file2, name };
+    const binding = this.imports(file2).get(name);
+    if (binding) {
+      const target = this.resolve(file2, 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(file2);
+    if (ast) {
+      for (const stmt of ast.program.body) {
+        if (!t5.isExportNamedDeclaration(stmt) || !stmt.source) continue;
+        for (const spec of stmt.specifiers) {
+          if (!t5.isExportSpecifier(spec)) continue;
+          const exported = t5.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value;
+          if (exported !== name) continue;
+          const target = this.resolve(file2, 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 (!t5.isExportAllDeclaration(stmt)) continue;
+        const target = this.resolve(file2, stmt.source.value);
+        if (!target || target === file2) continue;
+        const deeper = this.resolveBinding(target, name, hops + 1);
+        if (deeper) return deeper;
+      }
+    }
+    if (ast) {
+      for (const stmt of ast.program.body) {
+        if (!t5.isExportDefaultDeclaration(stmt)) continue;
+        if (t5.isIdentifier(stmt.declaration)) {
+          const local = stmt.declaration.name;
+          if (local === name) return null;
+          return this.resolveBinding(file2, local, hops + 1) ?? { file: file2, 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(file2, node, hops = 0) {
+    if (!node || hops > MAX_HOPS) return null;
+    if (t5.isStringLiteral(node)) return node.value;
+    if (t5.isTemplateLiteral(node)) {
+      return node.expressions.length === 0 ? node.quasis[0]?.value.cooked ?? null : null;
+    }
+    if (t5.isTSAsExpression(node)) return this.stringConstant(file2, node.expression, hops + 1);
+    const chain = memberChain(node);
+    if (!chain) return null;
+    const origin = this.resolveBinding(file2, 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 (!t5.isObjectExpression(current)) return null;
+      const prop = objectProperty(current, key);
+      if (!prop) return null;
+      current = t5.isTSAsExpression(prop) ? prop.expression : prop;
+    }
+    return t5.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(file2, node, hops = 0) {
+    if (!node || hops > MAX_HOPS) return null;
+    if (t5.isCallExpression(node)) {
+      for (const arg of node.arguments) {
+        if (t5.isIdentifier(arg) || t5.isMemberExpression(arg)) {
+          const inner = this.componentFile(file2, arg, hops + 1);
+          if (inner) return inner;
+        }
+      }
+      return null;
+    }
+    if (t5.isTSAsExpression(node)) return this.componentFile(file2, node.expression, hops + 1);
+    const chain = memberChain(node);
+    if (!chain) return null;
+    const origin = this.resolveBinding(file2, chain.root);
+    if (!origin) return null;
+    if (chain.path.length === 0) return origin.file;
+    const init = this.topLevelInit(origin.file, origin.name);
+    if (init && t5.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(file2) {
+    const ast = this.parse(file2);
+    if (!ast) return [];
+    const names = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      if (!node || typeof node !== "object") return;
+      if (t5.isJSXOpeningElement(node) && t5.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(file2, name);
+      if (origin && origin.file !== file2) out.add(origin.file);
+    }
+    return [...out];
+  }
+};
+function memberChain(node) {
+  const chain = [];
+  let current = node;
+  while (t5.isMemberExpression(current)) {
+    if (current.computed) {
+      if (!t5.isStringLiteral(current.property)) return null;
+      chain.unshift(current.property.value);
+    } else if (t5.isIdentifier(current.property)) {
+      chain.unshift(current.property.name);
+    } else {
+      return null;
+    }
+    current = current.object;
+  }
+  return t5.isIdentifier(current) ? { root: current.name, path: chain } : null;
+}
+function objectProperty(obj, key) {
+  for (const prop of obj.properties) {
+    if (!t5.isObjectProperty(prop)) continue;
+    const name = t5.isIdentifier(prop.key) ? prop.key.name : t5.isStringLiteral(prop.key) ? prop.key.value : null;
+    if (name === key && t5.isExpression(prop.value)) return prop.value;
+  }
+  return null;
+}
+function readTsconfigAliases(rootDir) {
+  const file2 = import_node_path.default.join(rootDir, "tsconfig.json");
+  if (!(0, import_node_fs.existsSync)(file2)) return [];
+  let parsed;
+  try {
+    const raw = stripJsonComments((0, import_node_fs.readFileSync)(file2, "utf-8")).replace(/,(\s*[}\]])/g, "$1");
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const paths = parsed.compilerOptions?.paths;
+  if (!paths) return [];
+  const baseUrl = import_node_path.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: import_node_path.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 = import_node_path.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 + import_node_path.default.sep)
+      );
+      return containsApp ? packages : [];
+    }
+    const parent = import_node_path.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return [];
+}
+function workspaceGlobs(dir) {
+  const pnpm = import_node_path.default.join(dir, "pnpm-workspace.yaml");
+  if ((0, import_node_fs.existsSync)(pnpm)) {
+    try {
+      const lines = (0, import_node_fs.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 = import_node_path.default.join(dir, "package.json");
+  if (!(0, import_node_fs.existsSync)(pkgPath)) return [];
+  try {
+    const pkg = JSON.parse((0, import_node_fs.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 = import_node_path.default.join(dir, "package.json");
+    if (!(0, import_node_fs.existsSync)(pkgPath)) return;
+    try {
+      const name = JSON.parse((0, import_node_fs.readFileSync)(pkgPath, "utf-8")).name;
+      if (name) out.push({ name, dir });
+    } catch {
+    }
+  };
+  for (const glob of globs) {
+    if (glob.endsWith("/*")) {
+      const parent = import_node_path.default.join(root, glob.slice(0, -2));
+      let entries = [];
+      try {
+        entries = (0, import_node_fs.readdirSync)(parent);
+      } catch {
+        continue;
+      }
+      for (const entry of entries) {
+        const dir = import_node_path.default.join(parent, entry);
+        try {
+          if ((0, import_node_fs.statSync)(dir).isDirectory()) add(dir);
+        } catch {
+        }
+      }
+    } else if (!glob.includes("*")) {
+      add(import_node_path.default.join(root, glob));
+    }
+  }
+  return out.sort((a, b) => b.name.length - a.name.length);
+}
+
+// src/ast/navigation/expo-router.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = __toESM(require("path"));
+var ROUTE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+var PLATFORM_SUFFIXES = [".ios", ".android", ".native", ".web"];
+var ROUTE_DIR_CANDIDATES = ["app", "src/app"];
+function baseName(file2) {
+  let name = file2;
+  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(file2) {
+  return ROUTE_EXTENSIONS.some((ext) => file2.endsWith(ext));
+}
+function isSpecial(base) {
+  if (base === "_layout") return true;
+  if (base.startsWith("+")) return base !== "+not-found";
+  return base.startsWith("_");
+}
+function layoutType(file2) {
+  try {
+    const src = (0, import_node_fs2.readFileSync)(file2, "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 = import_node_path2.default.join(dir, "_layout" + ext);
+    if ((0, import_node_fs2.existsSync)(candidate)) return candidate;
+  }
+  return null;
+}
+function analyzeExpoRouter(appRoot) {
+  let routeDir = null;
+  for (const candidate of ROUTE_DIR_CANDIDATES) {
+    const full = import_node_path2.default.join(appRoot, candidate);
+    if ((0, import_node_fs2.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 = (0, import_node_fs2.readdirSync)(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort()) {
+      const full = import_node_path2.default.join(dir, entry);
+      let isDir = false;
+      try {
+        isDir = (0, import_node_fs2.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: import_node_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 (t6.isCallExpression(value)) {
+    const arg = value.arguments[0];
+    return arg ? unwrapStaticScreen(arg) : null;
+  }
+  if (t6.isObjectExpression(value)) {
+    for (const prop of value.properties) {
+      if (!t6.isObjectProperty(prop)) continue;
+      const key = t6.isIdentifier(prop.key) ? prop.key.name : null;
+      if (key === "screen" && t6.isExpression(prop.value)) return prop.value;
+    }
+    return null;
+  }
+  return t6.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 import_fs4.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 (error2) {
         console.warn(`Failed to parse ${filePath}:`, error2);
       }
     }
+    const parsedNavigators = [];
+    for (const filePath of evidenceFiles) {
+      try {
+        parsedNavigators.push(...this.parseNavigatorUsages(filePath, declarations));
+      } catch (error2) {
+        console.warn(`Failed to parse navigators in ${filePath}:`, error2);
+      }
+    }
+    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 (error2) {
+        console.warn(`Failed to parse detached screens in ${filePath}:`, error2);
+      }
+    }
+    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();
+    (0, import_traverse5.default)(ast, {
+      CallExpression: (nodePath) => {
+        const callee = nodePath.node.callee;
+        if (!t6.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 (t6.isVariableDeclarator(up.node)) break;
+          if (!t6.isMemberExpression(up.node) && !t6.isCallExpression(up.node)) {
+            up = null;
+            break;
+          }
+          up = up.parentPath;
+        }
+        const declarator = up?.node;
+        if (!declarator || !t6.isVariableDeclarator(declarator) || !t6.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 || !t6.isObjectExpression(config) || depth > 4) return [];
+    const out = [];
+    for (const prop of config.properties) {
+      if (!t6.isObjectProperty(prop)) continue;
+      const key = t6.isIdentifier(prop.key) ? prop.key.name : t6.isStringLiteral(prop.key) ? prop.key.value : null;
+      if (!key) continue;
+      if (key === "groups" && t6.isObjectExpression(prop.value)) {
+        for (const group of prop.value.properties) {
+          if (!t6.isObjectProperty(group) || !t6.isExpression(group.value)) continue;
+          out.push(
+            ...this.parseStaticScreens(
+              filePath,
+              group.value,
+              navigatorName,
+              navigatorType,
+              depth + 1
+            )
+          );
+        }
+        continue;
+      }
+      if (key !== "screens" || !t6.isObjectExpression(prop.value)) continue;
+      for (const entry of prop.value.properties) {
+        if (!t6.isObjectProperty(entry)) continue;
+        const routeName = t6.isIdentifier(entry.key) ? entry.key.name : t6.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}",
@@ -2683,91 +3578,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 (0, import_fast_glob2.default)(patterns, {
+    const files = await globSorted(patterns, {
       cwd: this.config.rootDir,
       ignore: excludePatterns
     });
     return files.map((file2) => import_path4.default.join(this.config.rootDir, file2));
   }
-  /** 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();
-      (0, import_traverse5.default)(ast, {
-        // Detect createStackNavigator / createTabNavigator / createDrawerNavigator calls
-        CallExpression: (nodePath) => {
-          const { node } = nodePath;
-          const callee = node.callee;
-          let navigatorType = null;
-          if (t5.isIdentifier(callee) && callee.name === "createNativeStackNavigator") {
-            navigatorType = "stack";
-          } else if (t5.isIdentifier(callee) && callee.name === "createStackNavigator") {
-            navigatorType = "stack";
-          } else if (t5.isIdentifier(callee) && callee.name === "createBottomTabNavigator") {
-            navigatorType = "tab";
-          } else if (t5.isIdentifier(callee) && callee.name === "createTabNavigator") {
-            navigatorType = "tab";
-          } else if (t5.isIdentifier(callee) && callee.name === "createDrawerNavigator") {
-            navigatorType = "drawer";
-          }
-          if (navigatorType) {
-            const parent = nodePath.parent;
-            if (t5.isVariableDeclarator(parent) && t5.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 (t5.isJSXMemberExpression(openingElement.name) && t5.isJSXIdentifier(openingElement.name.object)) {
-            const objectName = openingElement.name.object.name;
-            const propertyName = t5.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) => t5.isJSXAttribute(attr) && t5.isJSXIdentifier(attr.name) && attr.name.name === "initialRouteName"
-                );
-                if (t5.isJSXAttribute(initialRouteAttr) && t5.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();
+    (0, import_traverse5.default)(ast, {
+      JSXElement: (nodePath) => {
+        const { node } = nodePath;
+        const openingElement = node.openingElement;
+        if (!t6.isJSXMemberExpression(openingElement.name) || !t6.isJSXIdentifier(openingElement.name.object)) {
+          return;
         }
-      });
-      navigatorCalls.forEach((navigator) => {
-        const screens = screensByNavigator.get(navigator.name) || [];
-        navigator.screens = screens;
-        navigators.push(navigator);
-      });
-    } catch (error2) {
-      console.warn(`Failed to parse navigators in ${filePath}:`, error2);
+        const objectName = openingElement.name.object.name;
+        const propertyName = t6.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) => t6.isJSXAttribute(attr) && t6.isJSXIdentifier(attr.name) && attr.name.name === "initialRouteName"
+        );
+        if (t6.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();
+    (0, import_traverse5.default)(ast, {
+      JSXElement: (nodePath) => {
+        const name = nodePath.node.openingElement.name;
+        if (!t6.isJSXMemberExpression(name) || !t6.isJSXIdentifier(name.object)) return;
+        if (!t6.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 t6.isJSXMemberExpression(parentName) && t6.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 (!t6.isIdentifier(param) || !t6.isTSTypeAnnotation(param.typeAnnotation)) return null;
+    const annotation = param.typeAnnotation.typeAnnotation;
+    if (!t6.isTSTypeQuery(annotation) || !t6.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 (t6.isStringLiteral(value)) return value.value;
+    if (t6.isJSXExpressionContainer(value) && t6.isExpression(value.expression)) {
+      return this.graph.stringConstant(filePath, value.expression);
     }
-    return navigators;
+    return null;
   }
   /**
    * Is this JSX element `<navigatorVarName.MEMBER …>`?
@@ -2778,9 +3770,9 @@ var NavigationAnalyzer = class {
   // `never`. It is a question about the member name, not about the node
   // kind.
   isNavigatorMember(node, navigatorVarName, member) {
-    if (!t5.isJSXElement(node)) return false;
+    if (!t6.isJSXElement(node)) return false;
     const name = node.openingElement.name;
-    return t5.isJSXMemberExpression(name) && t5.isJSXIdentifier(name.object) && name.object.name === navigatorVarName && t5.isJSXIdentifier(name.property) && name.property.name === member;
+    return t6.isJSXMemberExpression(name) && t6.isJSXIdentifier(name.object) && name.object.name === navigatorVarName && t6.isJSXIdentifier(name.property) && name.property.name === member;
   }
   /**
    * Flatten a navigator's JSX children into the `<X.Screen>` elements they
@@ -2811,37 +3803,37 @@ var NavigationAnalyzer = class {
         found.push(...this.collectScreenElements(group.children, navigatorVarName, depth + 1));
         return;
       }
-      if (t5.isJSXElement(node)) {
+      if (t6.isJSXElement(node)) {
         const name = node.openingElement.name;
-        const isForeignNavigator = t5.isJSXMemberExpression(name) && t5.isJSXIdentifier(name.property) && name.property.name === "Navigator";
+        const isForeignNavigator = t6.isJSXMemberExpression(name) && t6.isJSXIdentifier(name.property) && name.property.name === "Navigator";
         if (isForeignNavigator) return;
         found.push(...this.collectScreenElements(node.children, navigatorVarName, depth + 1));
         return;
       }
-      if (t5.isJSXFragment(node)) {
+      if (t6.isJSXFragment(node)) {
         found.push(...this.collectScreenElements(node.children, navigatorVarName, depth + 1));
         return;
       }
-      if (t5.isJSXExpressionContainer(node)) {
+      if (t6.isJSXExpressionContainer(node)) {
         visit(node.expression);
         return;
       }
-      if (t5.isConditionalExpression(node)) {
+      if (t6.isConditionalExpression(node)) {
         visit(node.consequent);
         visit(node.alternate);
         return;
       }
-      if (t5.isLogicalExpression(node)) {
+      if (t6.isLogicalExpression(node)) {
         visit(node.left);
         visit(node.right);
         return;
       }
-      if (t5.isCallExpression(node)) {
+      if (t6.isCallExpression(node)) {
         for (const arg of node.arguments) {
-          if (t5.isArrowFunctionExpression(arg) || t5.isFunctionExpression(arg)) {
-            if (t5.isBlockStatement(arg.body)) {
+          if (t6.isArrowFunctionExpression(arg) || t6.isFunctionExpression(arg)) {
+            if (t6.isBlockStatement(arg.body)) {
               for (const stmt of arg.body.body) {
-                if (t5.isReturnStatement(stmt)) visit(stmt.argument);
+                if (t6.isReturnStatement(stmt)) visit(stmt.argument);
               }
             } else {
               visit(arg.body);
@@ -2850,11 +3842,11 @@ var NavigationAnalyzer = class {
         }
         return;
       }
-      if (t5.isArrayExpression(node)) {
+      if (t6.isArrayExpression(node)) {
         for (const el of node.elements) visit(el);
         return;
       }
-      if (t5.isTSAsExpression(node) || t5.isTSNonNullExpression(node)) {
+      if (t6.isTSAsExpression(node) || t6.isTSNonNullExpression(node)) {
         visit(node.expression);
       }
     };
@@ -2862,28 +3854,54 @@ 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) => t6.isJSXAttribute(a) && t6.isJSXIdentifier(a.name) && a.name.name === "name"
+    );
+    const screenName = t6.isJSXAttribute(nameAttr) ? this.attributeString(filePath, nameAttr) : null;
+    if (!screenName) return null;
+    const componentAttr = attrs.find(
+      (a) => t6.isJSXAttribute(a) && t6.isJSXIdentifier(a.name) && a.name.name === "component"
+    );
+    let componentFile = null;
+    if (t6.isJSXAttribute(componentAttr) && t6.isJSXExpressionContainer(componentAttr.value)) {
+      const expr = componentAttr.value.expression;
+      if (t6.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(
-      (a) => t5.isJSXAttribute(a) && t5.isJSXIdentifier(a.name) && a.name.name === attrName
+      (a) => t6.isJSXAttribute(a) && t6.isJSXIdentifier(a.name) && a.name.name === attrName
     );
-    if (t5.isJSXAttribute(attr) && t5.isStringLiteral(attr.value)) {
+    if (t6.isJSXAttribute(attr) && t6.isStringLiteral(attr.value)) {
       return attr.value.value;
     }
     return null;
@@ -2892,7 +3910,7 @@ var NavigationAnalyzer = class {
   parseParamTypes(content, filePath) {
     const types = [];
     try {
-      const ast = parser.parse(content, {
+      const ast = parser2.parse(content, {
         sourceType: "module",
         plugins: [
           "jsx",
@@ -2973,7 +3991,7 @@ var NavigationAnalyzer = class {
     if (type.type === "TSUndefinedKeyword") return "undefined";
     if (type.type === "TSNullKeyword") return "null";
     if (type.type === "TSUnionType") {
-      return type.types.map((t15) => this.typeToString(t15)).join(" | ");
+      return type.types.map((t16) => this.typeToString(t16)).join(" | ");
     }
     if (type.type === "TSTypeLiteral") {
       return "object";
@@ -2994,7 +4012,7 @@ var NavigationAnalyzer = class {
   /** Attach parsed type params to navigator screens */
   attachParamsToNavigators(navigators, types) {
     for (const navigator of navigators) {
-      const matchingType = types.find((t15) => t15.type === navigator.type);
+      const matchingType = types.find((t16) => t16.type === navigator.type);
       if (matchingType) {
         for (const screen of navigator.screens) {
           const screenParams = matchingType.paramEntries.get(screen.name);
@@ -3072,9 +4090,9 @@ var NavigationAnalyzer = class {
 
 // src/analyzers/ComponentAnalyzer.ts
 var import_fs5 = require("fs");
-var parser2 = __toESM(require("@babel/parser"));
+var parser3 = __toESM(require("@babel/parser"));
 var import_traverse6 = __toESM(require("@babel/traverse"));
-var t6 = __toESM(require("@babel/types"));
+var t7 = __toESM(require("@babel/types"));
 var ComponentAnalyzer = class {
   config;
   constructor(config) {
@@ -3084,14 +4102,14 @@ var ComponentAnalyzer = class {
   async analyzeFile(filePath) {
     try {
       const code = (0, import_fs5.readFileSync)(filePath, "utf-8");
-      const ast = parser2.parse(code, {
+      const ast = parser3.parse(code, {
         sourceType: "module",
         plugins: ["jsx", "typescript", ["decorators", { decoratorsBeforeExport: true }]]
       });
       const components = [];
       (0, import_traverse6.default)(ast, {
-        JSXElement: (path11) => {
-          const component = this.extractComponentFromJSXElement(path11.node);
+        JSXElement: (path13) => {
+          const component = this.extractComponentFromJSXElement(path13.node);
           if (component) {
             components.push(component);
           }
@@ -3120,19 +4138,19 @@ var ComponentAnalyzer = class {
     };
   }
   getElementName(openingElement) {
-    if (t6.isJSXIdentifier(openingElement.name)) {
+    if (t7.isJSXIdentifier(openingElement.name)) {
       return openingElement.name.name;
     }
-    if (t6.isJSXMemberExpression(openingElement.name)) {
+    if (t7.isJSXMemberExpression(openingElement.name)) {
       const parts = [];
       let current = openingElement.name;
-      while (t6.isJSXMemberExpression(current)) {
-        if (t6.isJSXIdentifier(current.property)) {
+      while (t7.isJSXMemberExpression(current)) {
+        if (t7.isJSXIdentifier(current.property)) {
           parts.unshift(current.property.name);
         }
         current = current.object;
       }
-      if (t6.isJSXIdentifier(current)) {
+      if (t7.isJSXIdentifier(current)) {
         parts.unshift(current.name);
       }
       return parts.join(".");
@@ -3155,13 +4173,13 @@ var ComponentAnalyzer = class {
   extractProps(openingElement) {
     const props = {};
     for (const attr of openingElement.attributes) {
-      if (t6.isJSXAttribute(attr) && t6.isJSXIdentifier(attr.name)) {
+      if (t7.isJSXAttribute(attr) && t7.isJSXIdentifier(attr.name)) {
         const propName = attr.name.name;
         if (attr.value === null) {
           props[propName] = "true";
-        } else if (t6.isStringLiteral(attr.value)) {
+        } else if (t7.isStringLiteral(attr.value)) {
           props[propName] = attr.value.value;
-        } else if (t6.isJSXExpressionContainer(attr.value) && t6.isStringLiteral(attr.value.expression)) {
+        } else if (t7.isJSXExpressionContainer(attr.value) && t7.isStringLiteral(attr.value.expression)) {
           props[propName] = attr.value.expression.value;
         }
       }
@@ -3171,12 +4189,12 @@ var ComponentAnalyzer = class {
   extractAccessibilityProps(openingElement) {
     const result = {};
     for (const attr of openingElement.attributes) {
-      if (t6.isJSXAttribute(attr) && t6.isJSXIdentifier(attr.name)) {
+      if (t7.isJSXAttribute(attr) && t7.isJSXIdentifier(attr.name)) {
         const propName = attr.name.name;
         if ((propName === "testID" || propName === "accessibilityLabel") && attr.value) {
-          if (t6.isStringLiteral(attr.value)) {
+          if (t7.isStringLiteral(attr.value)) {
             result[propName] = attr.value.value;
-          } else if (t6.isJSXExpressionContainer(attr.value) && t6.isStringLiteral(attr.value.expression)) {
+          } else if (t7.isJSXExpressionContainer(attr.value) && t7.isStringLiteral(attr.value.expression)) {
             result[propName] = attr.value.expression.value;
           }
         }
@@ -3188,7 +4206,7 @@ var ComponentAnalyzer = class {
     if (depth >= maxDepth) return [];
     const extracted = [];
     for (const child of children) {
-      if (t6.isJSXElement(child)) {
+      if (t7.isJSXElement(child)) {
         const component = this.extractComponentFromJSXElement(child);
         if (component) {
           extracted.push(component);
@@ -3201,10 +4219,10 @@ var ComponentAnalyzer = class {
 
 // src/analyzers/FormAnalyzer.ts
 var import_fs6 = require("fs");
-var parser3 = __toESM(require("@babel/parser"));
+var parser4 = __toESM(require("@babel/parser"));
 var import_traverse7 = __toESM(require("@babel/traverse"));
-var t7 = __toESM(require("@babel/types"));
-var path3 = __toESM(require("path"));
+var t8 = __toESM(require("@babel/types"));
+var path5 = __toESM(require("path"));
 var FormAnalyzer = class {
   config;
   stateVariables = /* @__PURE__ */ new Map();
@@ -3217,7 +4235,7 @@ var FormAnalyzer = class {
   async analyzeFile(filePath) {
     try {
       const code = (0, import_fs6.readFileSync)(filePath, "utf-8");
-      const ast = parser3.parse(code, {
+      const ast = parser4.parse(code, {
         sourceType: "module",
         plugins: ["jsx", "typescript", ["decorators", { decoratorsBeforeExport: true }]]
       });
@@ -3225,13 +4243,13 @@ var FormAnalyzer = class {
       this.inputElements = [];
       this.submitButtons = [];
       (0, import_traverse7.default)(ast, {
-        CallExpression: (path11) => {
-          this.extractStateVariables(path11.node);
+        CallExpression: (path13) => {
+          this.extractStateVariables(path13.node);
         }
       });
       (0, import_traverse7.default)(ast, {
-        JSXElement: (path11) => {
-          this.extractFormElements(path11.node);
+        JSXElement: (path13) => {
+          this.extractFormElements(path13.node);
         }
       });
       const validationRules = this.extractValidationRules(ast);
@@ -3242,7 +4260,7 @@ var FormAnalyzer = class {
     }
   }
   extractStateVariables(node) {
-    if (t7.isIdentifier(node.callee) && node.callee.name === "useState" && node.arguments.length > 0) {
+    if (t8.isIdentifier(node.callee) && node.callee.name === "useState" && node.arguments.length > 0) {
       return;
     }
   }
@@ -3263,7 +4281,7 @@ var FormAnalyzer = class {
   extractInputInfo(openingElement) {
     const info2 = { varName: "" };
     for (const attr of openingElement.attributes) {
-      if (t7.isJSXAttribute(attr) && t7.isJSXIdentifier(attr.name)) {
+      if (t8.isJSXAttribute(attr) && t8.isJSXIdentifier(attr.name)) {
         const propName = attr.name.name;
         const propValue = this.extractAttributeValue(attr.value);
         switch (propName) {
@@ -3284,7 +4302,7 @@ var FormAnalyzer = class {
             if (propValue) info2.varName = propValue;
             break;
           case "value":
-            if (attr.value && t7.isJSXExpressionContainer(attr.value) && t7.isIdentifier(attr.value.expression)) {
+            if (attr.value && t8.isJSXExpressionContainer(attr.value) && t8.isIdentifier(attr.value.expression)) {
               info2.varName = attr.value.expression.name;
             }
             break;
@@ -3296,16 +4314,16 @@ var FormAnalyzer = class {
   extractButtonInfo(openingElement) {
     const info2 = {};
     for (const attr of openingElement.attributes) {
-      if (t7.isJSXAttribute(attr) && t7.isJSXIdentifier(attr.name)) {
+      if (t8.isJSXAttribute(attr) && t8.isJSXIdentifier(attr.name)) {
         const propName = attr.name.name;
         if (propName === "title" || propName === "label") {
           info2.label = this.extractAttributeValue(attr.value);
         }
         if (propName === "onPress") {
-          if (attr.value && t7.isJSXExpressionContainer(attr.value)) {
-            if (t7.isIdentifier(attr.value.expression)) {
+          if (attr.value && t8.isJSXExpressionContainer(attr.value)) {
+            if (t8.isIdentifier(attr.value.expression)) {
               info2.handler = attr.value.expression.name;
-            } else if (t7.isArrowFunctionExpression(attr.value.expression) || t7.isFunctionExpression(attr.value.expression)) {
+            } else if (t8.isArrowFunctionExpression(attr.value.expression) || t8.isFunctionExpression(attr.value.expression)) {
               info2.handler = "anonymous";
             }
           }
@@ -3316,14 +4334,14 @@ var FormAnalyzer = class {
   }
   extractAttributeValue(value) {
     if (value === null) return void 0;
-    if (t7.isStringLiteral(value)) return value.value;
-    if (t7.isJSXExpressionContainer(value) && t7.isStringLiteral(value.expression)) {
+    if (t8.isStringLiteral(value)) return value.value;
+    if (t8.isJSXExpressionContainer(value) && t8.isStringLiteral(value.expression)) {
       return value.expression.value;
     }
     return void 0;
   }
   getElementName(openingElement) {
-    if (t7.isJSXIdentifier(openingElement.name)) {
+    if (t8.isJSXIdentifier(openingElement.name)) {
       return openingElement.name.name;
     }
     return null;
@@ -3331,8 +4349,8 @@ var FormAnalyzer = class {
   extractValidationRules(ast) {
     const rules = {};
     (0, import_traverse7.default)(ast, {
-      IfStatement: (path11) => {
-        const test = path11.node.test;
+      IfStatement: (path13) => {
+        const test = path13.node.test;
         const rule = this.extractRuleFromCondition(test);
         if (rule) {
           const { field, description } = rule;
@@ -3347,36 +4365,36 @@ var FormAnalyzer = class {
   extractRuleFromCondition(test) {
     let fieldName = "";
     let description = "";
-    if (t7.isUnaryExpression(test) && test.operator === "!") {
-      if (t7.isCallExpression(test.argument)) {
+    if (t8.isUnaryExpression(test) && test.operator === "!") {
+      if (t8.isCallExpression(test.argument)) {
         const callExpr = test.argument;
-        if (t7.isMemberExpression(callExpr.callee)) {
+        if (t8.isMemberExpression(callExpr.callee)) {
           const memberExpr = callExpr.callee;
-          if (t7.isIdentifier(memberExpr.object)) {
+          if (t8.isIdentifier(memberExpr.object)) {
             fieldName = memberExpr.object.name;
             description = `${fieldName} is required`;
           }
         }
-      } else if (t7.isIdentifier(test.argument)) {
+      } else if (t8.isIdentifier(test.argument)) {
         fieldName = test.argument.name;
         description = `${fieldName} is required`;
       }
     }
-    if (t7.isBinaryExpression(test) && (test.operator === "<" || test.operator === "<=")) {
-      if (t7.isMemberExpression(test.left)) {
+    if (t8.isBinaryExpression(test) && (test.operator === "<" || test.operator === "<=")) {
+      if (t8.isMemberExpression(test.left)) {
         const memberExpr = test.left;
-        if (t7.isIdentifier(memberExpr.object)) {
+        if (t8.isIdentifier(memberExpr.object)) {
           fieldName = memberExpr.object.name;
-          if (t7.isNumericLiteral(test.right)) {
+          if (t8.isNumericLiteral(test.right)) {
             description = `${fieldName} must be at least ${test.right.value} characters`;
           }
         }
       }
     }
-    if (t7.isUnaryExpression(test) && test.operator === "!") {
-      if (t7.isCallExpression(test.argument) && t7.isMemberExpression(test.argument.callee)) {
-        const methodName = t7.isIdentifier(test.argument.callee.property) ? test.argument.callee.property.name : null;
-        if (methodName === "includes" && t7.isIdentifier(test.argument.callee.object)) {
+    if (t8.isUnaryExpression(test) && test.operator === "!") {
+      if (t8.isCallExpression(test.argument) && t8.isMemberExpression(test.argument.callee)) {
+        const methodName = t8.isIdentifier(test.argument.callee.property) ? test.argument.callee.property.name : null;
+        if (methodName === "includes" && t8.isIdentifier(test.argument.callee.object)) {
           fieldName = test.argument.callee.object.name;
           description = `${fieldName} format is invalid`;
         }
@@ -3386,7 +4404,7 @@ var FormAnalyzer = class {
   }
   buildForms(filePath, validationRules) {
     if (this.inputElements.length === 0) return [];
-    const fileName = path3.basename(filePath, path3.extname(filePath));
+    const fileName = path5.basename(filePath, path5.extname(filePath));
     const formId = `${fileName}Form`.replace(/Screen$/, "").toLowerCase();
     const fields = this.inputElements.map((input) => {
       const fieldType = this.inferFieldType(input);
@@ -3436,14 +4454,104 @@ var FormAnalyzer = class {
   }
 };
 
+// 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 file2 of frontier) {
+      for (const child of graph.renderedComponentFiles(file2)) {
+        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((t16) => t16.id));
+    const formIds = new Set(screen.forms.map((f) => f.id));
+    let gained = false;
+    for (const file2 of exclusive) {
+      if (!analyzed.has(file2)) {
+        try {
+          analyzed.set(file2, await analyzeFile(file2));
+        } catch {
+          analyzed.set(file2, null);
+        }
+      }
+      const child = analyzed.get(file2);
+      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
@@ -3451,14 +4559,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(
+          (file2) => !navigationAnalyzer.navigatorFiles.has(file2)
+        )
+      )
+    });
+    const screens = await screenAnalyzer.analyze();
+    const composed = await composeAffordances({
+      screens,
+      graph: navigationAnalyzer.graph,
+      analyzeFile: (file2) => screenAnalyzer.analyzeFile(file2),
+      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 (0, import_fast_glob3.default)(config.include || ["**/*.tsx", "**/*.ts"], {
+    const screenFiles = await globSorted(config.include || ["**/*.tsx", "**/*.ts"], {
       cwd: config.rootDir,
       ignore: config.exclude || ["**/node_modules/**"]
     });
@@ -3466,7 +4591,7 @@ var ReactNativePlatformAnalyzer = class {
       `[ReactNativePlatformAnalyzer] Analyzing components and forms from ${screenFiles.length} files...`
     );
     const enrichmentPromises = screenFiles.map(async (file2) => {
-      const filePath = import_node_path.default.resolve(config.rootDir, file2);
+      const filePath = import_node_path3.default.resolve(config.rootDir, file2);
       try {
         const [components, forms] = await Promise.all([
           componentAnalyzer.analyzeFile(filePath),
@@ -3521,7 +4646,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) {
@@ -3539,9 +4665,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;
       }
@@ -3574,7 +4703,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 };
       }
@@ -3601,9 +4732,8 @@ var GenericPlatformAnalyzer = class {
 // src/analyzers/web/WebScreenAnalyzer.ts
 var import_promises2 = __toESM(require("fs/promises"));
 var import_path5 = __toESM(require("path"));
-var import_fast_glob4 = __toESM(require("fast-glob"));
 var import_traverse9 = __toESM(require("@babel/traverse"));
-var t10 = __toESM(require("@babel/types"));
+var t11 = __toESM(require("@babel/types"));
 
 // src/ast/jsx/web/classify.ts
 var VIEW_TAGS = /* @__PURE__ */ new Set([
@@ -3719,16 +4849,16 @@ function classifyWebJsxComponent(name, element) {
 }
 
 // src/ast/jsx/names.ts
-var t8 = __toESM(require("@babel/types"));
+var t9 = __toESM(require("@babel/types"));
 function getJsxElementName(openingElement) {
   return getJsxName(openingElement.name);
 }
 function getJsxName(name) {
-  if (t8.isJSXIdentifier(name)) return name.name;
-  if (t8.isJSXNamespacedName(name)) return `${name.namespace.name}:${name.name.name}`;
-  if (t8.isJSXMemberExpression(name)) {
+  if (t9.isJSXIdentifier(name)) return name.name;
+  if (t9.isJSXNamespacedName(name)) return `${name.namespace.name}:${name.name.name}`;
+  if (t9.isJSXMemberExpression(name)) {
     const objectName = getJsxName(name.object);
-    const propertyName = t8.isJSXIdentifier(name.property) ? name.property.name : null;
+    const propertyName = t9.isJSXIdentifier(name.property) ? name.property.name : null;
     return objectName && propertyName ? `${objectName}.${propertyName}` : null;
   }
   return null;
@@ -3736,32 +4866,32 @@ function getJsxName(name) {
 
 // src/ast/navigation/web-calls.ts
 var import_traverse8 = __toESM(require("@babel/traverse"));
-var t9 = __toESM(require("@babel/types"));
+var t10 = __toESM(require("@babel/types"));
 var ROUTERISH_OBJECTS = /^(router|history|navigation)$/;
 function staticRoutePath(node) {
   if (!node) return void 0;
-  if (t9.isStringLiteral(node)) return node.value;
-  if (t9.isTemplateLiteral(node)) {
-    let path11 = "";
+  if (t10.isStringLiteral(node)) return node.value;
+  if (t10.isTemplateLiteral(node)) {
+    let path13 = "";
     node.quasis.forEach((quasi, index) => {
-      path11 += quasi.value.cooked ?? quasi.value.raw;
+      path13 += quasi.value.cooked ?? quasi.value.raw;
       const expr = node.expressions[index];
-      if (expr) path11 += `:${paramNameOf(expr)}`;
+      if (expr) path13 += `:${paramNameOf(expr)}`;
     });
-    return path11;
+    return path13;
   }
   return void 0;
 }
 function paramNameOf(expr) {
-  if (t9.isIdentifier(expr)) return expr.name;
-  if (t9.isMemberExpression(expr) && t9.isIdentifier(expr.property)) return expr.property.name;
+  if (t10.isIdentifier(expr)) return expr.name;
+  if (t10.isMemberExpression(expr) && t10.isIdentifier(expr.property)) return expr.property.name;
   return "param";
 }
 function extractWebNavigationCalls(ast) {
   const calls = [];
   const inspect = (node) => {
-    if (t9.isCallExpression(node)) {
-      if (t9.isIdentifier(node.callee) && node.callee.name === "navigate") {
+    if (t10.isCallExpression(node)) {
+      if (t10.isIdentifier(node.callee) && node.callee.name === "navigate") {
         const first = node.arguments[0];
         const targetPath = staticRoutePath(first);
         if (targetPath !== void 0) {
@@ -3769,12 +4899,12 @@ function extractWebNavigationCalls(ast) {
             method: hasReplaceOption(node.arguments[1]) ? "replace" : "navigate",
             targetPath
           });
-        } else if (t9.isNumericLiteral(first) || t9.isUnaryExpression(first) && first.operator === "-") {
+        } else if (t10.isNumericLiteral(first) || t10.isUnaryExpression(first) && first.operator === "-") {
           calls.push({ method: "goBack" });
         }
         return;
       }
-      if (t9.isMemberExpression(node.callee) && t9.isIdentifier(node.callee.object) && ROUTERISH_OBJECTS.test(node.callee.object.name) && t9.isIdentifier(node.callee.property)) {
+      if (t10.isMemberExpression(node.callee) && t10.isIdentifier(node.callee.object) && ROUTERISH_OBJECTS.test(node.callee.object.name) && t10.isIdentifier(node.callee.property)) {
         const method = node.callee.property.name;
         const targetPath = staticRoutePath(node.arguments[0]);
         if ((method === "push" || method === "navigate") && targetPath !== void 0) {
@@ -3787,25 +4917,25 @@ function extractWebNavigationCalls(ast) {
       }
       return;
     }
-    if (t9.isAssignmentExpression(node) && t9.isMemberExpression(node.left) && t9.isIdentifier(node.left.property) && node.left.property.name === "href" && isLocationExpression(node.left.object) && t9.isStringLiteral(node.right) && node.right.value.startsWith("/")) {
+    if (t10.isAssignmentExpression(node) && t10.isMemberExpression(node.left) && t10.isIdentifier(node.left.property) && node.left.property.name === "href" && isLocationExpression(node.left.object) && t10.isStringLiteral(node.right) && node.right.value.startsWith("/")) {
       calls.push({ method: "navigate", targetPath: node.right.value });
     }
   };
   (0, import_traverse8.default)(ast, {
-    noScope: !t9.isFile(ast),
+    noScope: !t10.isFile(ast),
     enter: (nodePath) => inspect(nodePath.node)
   });
   return calls;
 }
 function hasReplaceOption(arg) {
-  if (!arg || !t9.isObjectExpression(arg)) return false;
+  if (!arg || !t10.isObjectExpression(arg)) return false;
   return arg.properties.some(
-    (prop) => t9.isObjectProperty(prop) && t9.isIdentifier(prop.key) && prop.key.name === "replace" && t9.isBooleanLiteral(prop.value) && prop.value.value === true
+    (prop) => t10.isObjectProperty(prop) && t10.isIdentifier(prop.key) && prop.key.name === "replace" && t10.isBooleanLiteral(prop.value) && prop.value.value === true
   );
 }
 function isLocationExpression(node) {
-  if (t9.isIdentifier(node)) return node.name === "location";
-  return t9.isMemberExpression(node) && t9.isIdentifier(node.object) && node.object.name === "window" && t9.isIdentifier(node.property) && node.property.name === "location";
+  if (t10.isIdentifier(node)) return node.name === "location";
+  return t10.isMemberExpression(node) && t10.isIdentifier(node.object) && node.object.name === "window" && t10.isIdentifier(node.property) && node.property.name === "location";
 }
 
 // src/analyzers/web/WebScreenAnalyzer.ts
@@ -3833,10 +4963,10 @@ var WebScreenAnalyzer = class {
       include = ["**/*.tsx", "**/*.ts", "**/*.jsx", "**/*.js"],
       exclude = ["**/node_modules/**", "**/dist/**", "**/build/**"]
     } = this.config;
-    const files = (await (0, import_fast_glob4.default)(include, { cwd: this.config.rootDir, ignore: exclude })).filter(
+    const files = (await globSorted(include, { cwd: this.config.rootDir, ignore: exclude })).filter(
       (file2) => !file2.endsWith(".d.ts")
     );
-    const patternMatches = await (0, import_fast_glob4.default)(this.screenPatterns, {
+    const patternMatches = await globSorted(this.screenPatterns, {
       cwd: this.config.rootDir,
       ignore: exclude
     });
@@ -3930,7 +5060,7 @@ var WebScreenAnalyzer = class {
       CallExpression: (nodePath) => {
         if (!isRegisterScreenCallee(nodePath.node.callee)) return;
         const arg = nodePath.node.arguments[0];
-        if (t10.isObjectExpression(arg)) {
+        if (t11.isObjectExpression(arg)) {
           plain = literalToPlain(arg);
         }
       }
@@ -3977,20 +5107,20 @@ var WebScreenAnalyzer = class {
     (0, import_traverse9.default)(ast, {
       ExportDefaultDeclaration: (nodePath) => {
         const declaration = nodePath.node.declaration;
-        if (t10.isFunctionDeclaration(declaration) && declaration.id?.name) {
+        if (t11.isFunctionDeclaration(declaration) && declaration.id?.name) {
           defaultName = declaration.id.name;
-        } else if (t10.isIdentifier(declaration)) {
+        } else if (t11.isIdentifier(declaration)) {
           defaultName = declaration.name;
         }
       },
       ExportNamedDeclaration: (nodePath) => {
         if (firstExported) return;
         const declaration = nodePath.node.declaration;
-        if (t10.isFunctionDeclaration(declaration) && declaration.id && /^[A-Z]/.test(declaration.id.name)) {
+        if (t11.isFunctionDeclaration(declaration) && declaration.id && /^[A-Z]/.test(declaration.id.name)) {
           firstExported = declaration.id.name;
-        } else if (t10.isVariableDeclaration(declaration)) {
+        } else if (t11.isVariableDeclaration(declaration)) {
           for (const declarator of declaration.declarations) {
-            if (t10.isIdentifier(declarator.id) && /^[A-Z]/.test(declarator.id.name) && (t10.isArrowFunctionExpression(declarator.init) || t10.isFunctionExpression(declarator.init))) {
+            if (t11.isIdentifier(declarator.id) && /^[A-Z]/.test(declarator.id.name) && (t11.isArrowFunctionExpression(declarator.init) || t11.isFunctionExpression(declarator.init))) {
               firstExported = declarator.id.name;
               break;
             }
@@ -4162,15 +5292,15 @@ var WebScreenAnalyzer = class {
       });
     }
     for (const attr of opening.attributes) {
-      if (!t10.isJSXAttribute(attr) || !t10.isJSXIdentifier(attr.name)) continue;
+      if (!t11.isJSXAttribute(attr) || !t11.isJSXIdentifier(attr.name)) continue;
       const attrName = attr.name.name;
       if (attrName === "required") {
         if (attr.value === null) field.required = true;
-        else if (t10.isJSXExpressionContainer(attr.value) && t10.isBooleanLiteral(attr.value.expression)) {
+        else if (t11.isJSXExpressionContainer(attr.value) && t11.isBooleanLiteral(attr.value.expression)) {
           field.required = attr.value.expression.value;
         }
       }
-      if ((attrName === "value" || attrName === "checked") && attr.value && t10.isJSXExpressionContainer(attr.value) && t10.isIdentifier(attr.value.expression)) {
+      if ((attrName === "value" || attrName === "checked") && attr.value && t11.isJSXExpressionContainer(attr.value) && t11.isIdentifier(attr.value.expression)) {
         field.valueBinding = attr.value.expression.name;
         if (!field.name) field.name = attr.value.expression.name;
       }
@@ -4220,7 +5350,7 @@ var WebScreenAnalyzer = class {
   extractSelectOptions(selectElement) {
     const options = [];
     for (const child of selectElement.children) {
-      if (!t10.isJSXElement(child)) continue;
+      if (!t11.isJSXElement(child)) continue;
       if (getJsxElementName(child.openingElement) !== "option") continue;
       const value = getStringAttr(child.openingElement, "value");
       const label = jsxTextContent(child) || value || "";
@@ -4331,14 +5461,14 @@ var WebScreenAnalyzer = class {
     }
     let handlerName;
     const onClickAttr = opening.attributes.find(
-      (attr) => t10.isJSXAttribute(attr) && t10.isJSXIdentifier(attr.name) && attr.name.name === "onClick"
+      (attr) => t11.isJSXAttribute(attr) && t11.isJSXIdentifier(attr.name) && attr.name.name === "onClick"
     );
-    if (onClickAttr?.value && t10.isJSXExpressionContainer(onClickAttr.value)) {
+    if (onClickAttr?.value && t11.isJSXExpressionContainer(onClickAttr.value)) {
       const expr = onClickAttr.value.expression;
-      if (t10.isIdentifier(expr)) {
+      if (t11.isIdentifier(expr)) {
         handlerName = expr.name;
         action.handler = expr.name;
-      } else if (!t10.isJSXEmptyExpression(expr)) {
+      } else if (!t11.isJSXEmptyExpression(expr)) {
         const inlineNavCalls = extractWebNavigationCalls(expr);
         const inlineNav = inlineNavCalls.find((call) => call.targetPath);
         if (inlineNav?.targetPath) {
@@ -4477,12 +5607,12 @@ var WebScreenAnalyzer = class {
   }
   handlerNameFromAttr(opening, attrName) {
     const attr = opening.attributes.find(
-      (candidate) => t10.isJSXAttribute(candidate) && t10.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
+      (candidate) => t11.isJSXAttribute(candidate) && t11.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
     );
-    if (!attr?.value || !t10.isJSXExpressionContainer(attr.value)) return void 0;
+    if (!attr?.value || !t11.isJSXExpressionContainer(attr.value)) return void 0;
     const expr = attr.value.expression;
-    if (t10.isIdentifier(expr)) return expr.name;
-    if (t10.isArrowFunctionExpression(expr) || t10.isFunctionExpression(expr)) {
+    if (t11.isIdentifier(expr)) return expr.name;
+    if (t11.isArrowFunctionExpression(expr) || t11.isFunctionExpression(expr)) {
       return firstCalledFunctionName(expr) ?? "anonymous";
     }
     return void 0;
@@ -4516,11 +5646,11 @@ var WebScreenAnalyzer = class {
     (0, import_traverse9.default)(ast, {
       JSXExpressionContainer: (nodePath) => {
         const expr = nodePath.node.expression;
-        if (!t10.isCallExpression(expr) || !t10.isMemberExpression(expr.callee) || !t10.isIdentifier(expr.callee.object) || !t10.isIdentifier(expr.callee.property) || expr.callee.property.name !== "map") {
+        if (!t11.isCallExpression(expr) || !t11.isMemberExpression(expr.callee) || !t11.isIdentifier(expr.callee.object) || !t11.isIdentifier(expr.callee.property) || expr.callee.property.name !== "map") {
           return;
         }
         const callback = expr.arguments[0];
-        if (!t10.isArrowFunctionExpression(callback) && !t10.isFunctionExpression(callback)) return;
+        if (!t11.isArrowFunctionExpression(callback) && !t11.isFunctionExpression(callback)) return;
         const enclosing = nodePath.findParent(
           (p) => p.isJSXElement()
         );
@@ -4555,22 +5685,22 @@ var WebScreenAnalyzer = class {
   }
 };
 function isRegisterScreenCallee(callee) {
-  return t10.isIdentifier(callee) && callee.name === "registerScreen" || t10.isMemberExpression(callee) && t10.isIdentifier(callee.property) && callee.property.name === "registerScreen";
+  return t11.isIdentifier(callee) && callee.name === "registerScreen" || t11.isMemberExpression(callee) && t11.isIdentifier(callee.property) && callee.property.name === "registerScreen";
 }
 function literalToPlain(node) {
-  if (t10.isStringLiteral(node) || t10.isNumericLiteral(node) || t10.isBooleanLiteral(node)) {
+  if (t11.isStringLiteral(node) || t11.isNumericLiteral(node) || t11.isBooleanLiteral(node)) {
     return node.value;
   }
-  if (t10.isNullLiteral(node)) return null;
-  if (t10.isArrayExpression(node)) {
-    return node.elements.filter((el) => el !== null && t10.isExpression(el)).map((el) => literalToPlain(el)).filter((value) => value !== void 0);
+  if (t11.isNullLiteral(node)) return null;
+  if (t11.isArrayExpression(node)) {
+    return node.elements.filter((el) => el !== null && t11.isExpression(el)).map((el) => literalToPlain(el)).filter((value) => value !== void 0);
   }
-  if (t10.isObjectExpression(node)) {
+  if (t11.isObjectExpression(node)) {
     const out = {};
     for (const prop of node.properties) {
-      if (!t10.isObjectProperty(prop)) continue;
-      const key = t10.isIdentifier(prop.key) ? prop.key.name : t10.isStringLiteral(prop.key) ? prop.key.value : void 0;
-      if (!key || !t10.isExpression(prop.value)) continue;
+      if (!t11.isObjectProperty(prop)) continue;
+      const key = t11.isIdentifier(prop.key) ? prop.key.name : t11.isStringLiteral(prop.key) ? prop.key.value : void 0;
+      if (!key || !t11.isExpression(prop.value)) continue;
       const value = literalToPlain(prop.value);
       if (value !== void 0) out[key] = value;
     }
@@ -4582,12 +5712,12 @@ function jsxTextContent(element) {
   const parts = [];
   const walk = (children) => {
     for (const child of children) {
-      if (t10.isJSXText(child)) {
+      if (t11.isJSXText(child)) {
         const trimmed = child.value.replace(/\s+/g, " ").trim();
         if (trimmed) parts.push(trimmed);
-      } else if (t10.isJSXExpressionContainer(child) && t10.isStringLiteral(child.expression)) {
+      } else if (t11.isJSXExpressionContainer(child) && t11.isStringLiteral(child.expression)) {
         parts.push(child.expression.value);
-      } else if (t10.isJSXElement(child)) {
+      } else if (t11.isJSXElement(child)) {
         walk(child.children);
       }
     }
@@ -4597,26 +5727,26 @@ function jsxTextContent(element) {
   return text.length > 0 ? text : void 0;
 }
 function firstCalledFunctionName(node) {
-  if (t10.isIdentifier(node)) return node.name;
-  if (t10.isArrowFunctionExpression(node) || t10.isFunctionExpression(node)) {
+  if (t11.isIdentifier(node)) return node.name;
+  if (t11.isArrowFunctionExpression(node) || t11.isFunctionExpression(node)) {
     return firstCalledFunctionName(node.body);
   }
-  if (t10.isBlockStatement(node)) {
+  if (t11.isBlockStatement(node)) {
     for (const statement of node.body) {
       const handler = firstCalledFunctionName(statement);
       if (handler) return handler;
     }
     return void 0;
   }
-  if (t10.isExpressionStatement(node)) return firstCalledFunctionName(node.expression);
-  if (t10.isReturnStatement(node)) {
+  if (t11.isExpressionStatement(node)) return firstCalledFunctionName(node.expression);
+  if (t11.isReturnStatement(node)) {
     return node.argument ? firstCalledFunctionName(node.argument) : void 0;
   }
-  if (t10.isAwaitExpression(node) || t10.isUnaryExpression(node)) {
+  if (t11.isAwaitExpression(node) || t11.isUnaryExpression(node)) {
     return firstCalledFunctionName(node.argument);
   }
-  if (t10.isCallExpression(node)) {
-    if (t10.isIdentifier(node.callee) && !/^(navigate|confirm|alert)$/.test(node.callee.name)) {
+  if (t11.isCallExpression(node)) {
+    if (t11.isIdentifier(node.callee) && !/^(navigate|confirm|alert)$/.test(node.callee.name)) {
       return node.callee.name;
     }
     return void 0;
@@ -4631,8 +5761,8 @@ function containsWindowConfirm(body) {
       noScope: true,
       CallExpression: (nodePath) => {
         const callee = nodePath.node.callee;
-        if (t10.isIdentifier(callee) && callee.name === "confirm") found = true;
-        if (t10.isMemberExpression(callee) && t10.isIdentifier(callee.object) && callee.object.name === "window" && t10.isIdentifier(callee.property) && callee.property.name === "confirm") {
+        if (t11.isIdentifier(callee) && callee.name === "confirm") found = true;
+        if (t11.isMemberExpression(callee) && t11.isIdentifier(callee.object) && callee.object.name === "window" && t11.isIdentifier(callee.property) && callee.property.name === "confirm") {
           found = true;
         }
       }
@@ -4647,9 +5777,9 @@ function routePathAttr(opening, attrName) {
   const literal = getStringAttr(opening, attrName);
   if (literal) return literal;
   const attr = opening.attributes.find(
-    (candidate) => t10.isJSXAttribute(candidate) && t10.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
+    (candidate) => t11.isJSXAttribute(candidate) && t11.isJSXIdentifier(candidate.name) && candidate.name.name === attrName
   );
-  if (!attr?.value || !t10.isJSXExpressionContainer(attr.value)) return void 0;
+  if (!attr?.value || !t11.isJSXExpressionContainer(attr.value)) return void 0;
   return staticRoutePath(attr.value.expression);
 }
 function slugify(label) {
@@ -4664,10 +5794,10 @@ function isWeakInferredFieldName(name) {
 function collectionItemNames(callback) {
   const names = /* @__PURE__ */ new Set(["item"]);
   const firstParam = callback.params[0];
-  if (t10.isIdentifier(firstParam)) names.add(firstParam.name);
-  if (t10.isObjectPattern(firstParam)) {
+  if (t11.isIdentifier(firstParam)) names.add(firstParam.name);
+  if (t11.isObjectPattern(firstParam)) {
     for (const prop of firstParam.properties) {
-      if (t10.isObjectProperty(prop) && t10.isIdentifier(prop.key) && t10.isIdentifier(prop.value)) {
+      if (t11.isObjectProperty(prop) && t11.isIdentifier(prop.key) && t11.isIdentifier(prop.value)) {
         names.add(prop.value.name);
       }
     }
@@ -4683,7 +5813,7 @@ function collectionDisplayFields(callback, itemNames) {
       noScope: true,
       MemberExpression: (nodePath) => {
         const node = nodePath.node;
-        if (t10.isIdentifier(node.object) && itemNames.has(node.object.name) && t10.isIdentifier(node.property)) {
+        if (t11.isIdentifier(node.object) && itemNames.has(node.object.name) && t11.isIdentifier(node.property)) {
           fields.add(node.property.name);
         }
       }
@@ -4700,10 +5830,10 @@ function collectionKeyField(callback, itemNames) {
       noScope: true,
       JSXAttribute: (nodePath) => {
         const attr = nodePath.node;
-        if (!t10.isJSXIdentifier(attr.name) || attr.name.name !== "key") return;
-        if (!attr.value || !t10.isJSXExpressionContainer(attr.value)) return;
+        if (!t11.isJSXIdentifier(attr.name) || attr.name.name !== "key") return;
+        if (!attr.value || !t11.isJSXExpressionContainer(attr.value)) return;
         const expr = attr.value.expression;
-        if (t10.isMemberExpression(expr) && t10.isIdentifier(expr.object) && itemNames.has(expr.object.name) && t10.isIdentifier(expr.property)) {
+        if (t11.isMemberExpression(expr) && t11.isIdentifier(expr.object) && itemNames.has(expr.object.name) && t11.isIdentifier(expr.property)) {
           keyField = keyField ?? expr.property.name;
         }
       }
@@ -4726,18 +5856,18 @@ function callbackReturnsTag(callback, tags) {
   let found = false;
   const inspect = (node) => {
     if (!node || found) return;
-    if (t10.isJSXElement(node)) {
+    if (t11.isJSXElement(node)) {
       const name = getJsxElementName(node.openingElement);
       if (name && tags.has(name)) found = true;
       return;
     }
-    if (t10.isBlockStatement(node)) {
+    if (t11.isBlockStatement(node)) {
       for (const statement of node.body) {
-        if (t10.isReturnStatement(statement)) inspect(statement.argument);
+        if (t11.isReturnStatement(statement)) inspect(statement.argument);
       }
     }
-    if (t10.isParenthesizedExpression(node)) inspect(node.expression);
-    if (t10.isConditionalExpression(node)) {
+    if (t11.isParenthesizedExpression(node)) inspect(node.expression);
+    if (t11.isConditionalExpression(node)) {
       inspect(node.consequent);
       inspect(node.alternate);
     }
@@ -4764,9 +5894,8 @@ function inferIdentityFields(keyField, displayFields) {
 // src/analyzers/web/WebNavigationAnalyzer.ts
 var import_fs7 = require("fs");
 var import_path6 = __toESM(require("path"));
-var import_fast_glob5 = __toESM(require("fast-glob"));
 var import_traverse10 = __toESM(require("@babel/traverse"));
-var t11 = __toESM(require("@babel/types"));
+var t12 = __toESM(require("@babel/types"));
 var WEB_NAVIGATOR_TYPE = "route";
 var WebNavigationAnalyzer = class {
   config;
@@ -4783,7 +5912,9 @@ var WebNavigationAnalyzer = class {
     for (const filePath of files) {
       try {
         const content = await import_fs7.promises.readFile(filePath, "utf-8");
-        if (!/createBrowserRouter|createHashRouter|createMemoryRouter|useRoutes|<Route[\s>]/.test(content)) {
+        if (!/createBrowserRouter|createHashRouter|createMemoryRouter|useRoutes|<Route[\s>]/.test(
+          content
+        )) {
           continue;
         }
         const ast = parseSource(content, this.config.parserPlugins);
@@ -4813,7 +5944,7 @@ var WebNavigationAnalyzer = class {
       ...this.config.exclude || [],
       ...this.navigationExclude
     ];
-    const files = await (0, import_fast_glob5.default)(patterns, { cwd: this.config.rootDir, ignore });
+    const files = await globSorted(patterns, { cwd: this.config.rootDir, ignore });
     return files.map((file2) => import_path6.default.join(this.config.rootDir, file2));
   }
   // ── JSX <Route> style ────────────────────────────────────────────
@@ -4824,7 +5955,7 @@ var WebNavigationAnalyzer = class {
       const name = getJsxElementName(opening);
       if (name !== "Route") {
         for (const child of element.children) {
-          if (t11.isJSXElement(child)) visitRoute(child, parentPath);
+          if (t12.isJSXElement(child)) visitRoute(child, parentPath);
         }
         return;
       }
@@ -4833,13 +5964,13 @@ var WebNavigationAnalyzer = class {
       const fullPath = this.joinPaths(parentPath, segment, isIndex);
       const componentName = this.componentNameFromElementAttr(opening) ?? void 0;
       const isLeaf = !element.children.some(
-        (child) => t11.isJSXElement(child) && getJsxElementName(child.openingElement) === "Route"
+        (child) => t12.isJSXElement(child) && getJsxElementName(child.openingElement) === "Route"
       );
       if ((segment || isIndex) && (componentName || isLeaf)) {
         routes.push(this.buildRoute(fullPath, componentName, isIndex, !isLeaf));
       }
       for (const child of element.children) {
-        if (t11.isJSXElement(child)) visitRoute(child, fullPath);
+        if (t12.isJSXElement(child)) visitRoute(child, fullPath);
       }
     };
     (0, import_traverse10.default)(ast, {
@@ -4861,13 +5992,13 @@ var WebNavigationAnalyzer = class {
   /** `element={<VehicleList/>}` or `Component={VehicleList}`. */
   componentNameFromElementAttr(opening) {
     for (const attr of opening.attributes) {
-      if (!t11.isJSXAttribute(attr) || !t11.isJSXIdentifier(attr.name)) continue;
-      if (attr.name.name === "element" && t11.isJSXExpressionContainer(attr.value)) {
+      if (!t12.isJSXAttribute(attr) || !t12.isJSXIdentifier(attr.name)) continue;
+      if (attr.name.name === "element" && t12.isJSXExpressionContainer(attr.value)) {
         const expr = attr.value.expression;
-        if (t11.isJSXElement(expr)) return getJsxElementName(expr.openingElement);
+        if (t12.isJSXElement(expr)) return getJsxElementName(expr.openingElement);
       }
-      if (attr.name.name === "Component" && t11.isJSXExpressionContainer(attr.value)) {
-        if (t11.isIdentifier(attr.value.expression)) return attr.value.expression.name;
+      if (attr.name.name === "Component" && t12.isJSXExpressionContainer(attr.value)) {
+        if (t12.isIdentifier(attr.value.expression)) return attr.value.expression.name;
       }
     }
     return null;
@@ -4884,9 +6015,9 @@ var WebNavigationAnalyzer = class {
     (0, import_traverse10.default)(ast, {
       CallExpression: (nodePath) => {
         const callee = nodePath.node.callee;
-        if (!t11.isIdentifier(callee) || !ROUTER_FACTORIES.has(callee.name)) return;
+        if (!t12.isIdentifier(callee) || !ROUTER_FACTORIES.has(callee.name)) return;
         const first = nodePath.node.arguments[0];
-        if (!t11.isArrayExpression(first)) return;
+        if (!t12.isArrayExpression(first)) return;
         this.visitRouteObjects(first, "", routes);
       }
     });
@@ -4894,21 +6025,21 @@ var WebNavigationAnalyzer = class {
   }
   visitRouteObjects(arr, parentPath, out) {
     for (const element of arr.elements) {
-      if (!t11.isObjectExpression(element)) continue;
+      if (!t12.isObjectExpression(element)) continue;
       let segment;
       let isIndex = false;
       let componentName;
       let children;
       for (const prop of element.properties) {
-        if (!t11.isObjectProperty(prop) || !t11.isIdentifier(prop.key)) continue;
+        if (!t12.isObjectProperty(prop) || !t12.isIdentifier(prop.key)) continue;
         const key = prop.key.name;
-        if (key === "path" && t11.isStringLiteral(prop.value)) segment = prop.value.value;
-        if (key === "index" && t11.isBooleanLiteral(prop.value)) isIndex = prop.value.value;
-        if (key === "element" && t11.isJSXElement(prop.value)) {
+        if (key === "path" && t12.isStringLiteral(prop.value)) segment = prop.value.value;
+        if (key === "index" && t12.isBooleanLiteral(prop.value)) isIndex = prop.value.value;
+        if (key === "element" && t12.isJSXElement(prop.value)) {
           componentName = getJsxElementName(prop.value.openingElement) ?? void 0;
         }
-        if (key === "Component" && t11.isIdentifier(prop.value)) componentName = prop.value.name;
-        if (key === "children" && t11.isArrayExpression(prop.value)) children = prop.value;
+        if (key === "Component" && t12.isIdentifier(prop.value)) componentName = prop.value.name;
+        if (key === "children" && t12.isArrayExpression(prop.value)) children = prop.value;
       }
       const fullPath = this.joinPaths(parentPath, segment, isIndex);
       if ((segment !== void 0 || isIndex) && (componentName || !children)) {
@@ -4986,11 +6117,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
+        }
+      ] : []
     };
   }
 };
@@ -5109,7 +6242,7 @@ var ReactWebPlatformAnalyzer = class {
 
 // src/manifest/loadManifest.ts
 var import_promises3 = require("fs/promises");
-var import_node_path2 = __toESM(require("path"));
+var import_node_path4 = __toESM(require("path"));
 
 // ../../node_modules/zod/v3/external.js
 var external_exports = {};
@@ -5316,8 +6449,8 @@ var ZodParsedType = util.arrayToEnum([
   "set"
 ]);
 var getParsedType = (data) => {
-  const t15 = typeof data;
-  switch (t15) {
+  const t16 = typeof data;
+  switch (t16) {
     case "undefined":
       return ZodParsedType.undefined;
     case "string":
@@ -5589,8 +6722,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path11, errorMaps, issueData } = params;
-  const fullPath = [...path11, ...issueData.path || []];
+  const { data, path: path13, errorMaps, issueData } = params;
+  const fullPath = [...path13, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -5706,11 +6839,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path11, key) {
+  constructor(parent, value, path13, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path11;
+    this._path = path13;
     this._key = key;
   }
   get path() {
@@ -9152,7 +10285,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",
@@ -9331,6 +10475,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({
@@ -9513,7 +10674,7 @@ var uploadMCPDocumentSchema = 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"]);
 var createApiKeySchema = external_exports.object({
   name: external_exports.string().min(1).max(100),
@@ -9524,8 +10685,8 @@ var createApiKeySchema = 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);
@@ -9550,6 +10711,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({
@@ -9705,6 +10875,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
@@ -9738,7 +10934,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(),
@@ -9844,7 +11052,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),
@@ -10012,8 +11220,15 @@ var continueAgentSchema = 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({
@@ -10119,15 +11334,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"
+});
 var projectPersonalizationSchema = 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. */
@@ -10141,20 +11359,20 @@ var projectPersonalizationSchema = 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()
 });
 var updateProjectPersonalizationSchema = 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(),
@@ -10174,7 +11392,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(
@@ -10632,7 +11862,7 @@ var manifestSchema = external_exports.object({
   navigation: navigationGraphSchema.partial().optional()
 }).passthrough();
 async function loadManifest(rootDir, manifestPath) {
-  const resolvedPath = import_node_path2.default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
+  const resolvedPath = import_node_path4.default.resolve(rootDir, manifestPath || DEFAULT_MANIFEST_FILENAME);
   let raw;
   try {
     raw = await (0, import_promises3.readFile)(resolvedPath, "utf-8");
@@ -10781,7 +12011,7 @@ var MCPGenerator = class _MCPGenerator {
     const agentReadyScreens = mergedScreens.map(
       (screen) => enrichScreenForAgent({
         ...screen,
-        filePath: screen.filePath ? import_node_path3.default.relative(this.generatorConfig.rootDir, screen.filePath) : screen.filePath
+        filePath: screen.filePath ? import_node_path5.default.relative(this.generatorConfig.rootDir, screen.filePath) : screen.filePath
       })
     );
     const projectInfo = await this.getProjectInfo();
@@ -10805,11 +12035,11 @@ var MCPGenerator = class _MCPGenerator {
       }
     };
     const serialized = JSON.stringify(document, null, 2);
-    const checksum = this.calculateChecksum(serialized);
-    const filePath = import_node_path3.default.resolve(outputDir, `mcp-document.${this.options.format}`);
+    const checksum = this.calculateChecksum(serializeForChecksum(document));
+    const filePath = import_node_path5.default.resolve(outputDir, `mcp-document.${this.options.format}`);
     await (0, import_promises4.writeFile)(filePath, serialized, "utf-8");
     console.log(`[MCPGenerator] Document written to: ${filePath}`);
-    const checksumFilePath = import_node_path3.default.resolve(outputDir, ".appilots-checksum");
+    const checksumFilePath = import_node_path5.default.resolve(outputDir, ".appilots-checksum");
     await (0, import_promises4.writeFile)(checksumFilePath, checksum, "utf-8");
     console.log(`[MCPGenerator] Checksum written to: ${checksumFilePath}`);
     console.log("[MCPGenerator] Generation complete!");
@@ -10817,7 +12047,8 @@ var MCPGenerator = class _MCPGenerator {
       document,
       filePath,
       format: this.options.format,
-      checksum
+      checksum,
+      ...analyzed.diagnostics ? { diagnostics: analyzed.diagnostics } : {}
     };
   }
   /**
@@ -10829,7 +12060,7 @@ var MCPGenerator = class _MCPGenerator {
    * after calling `generate()`.
    */
   static async readPreviousChecksum(outputDir) {
-    const checksumFilePath = import_node_path3.default.resolve(outputDir, ".appilots-checksum");
+    const checksumFilePath = import_node_path5.default.resolve(outputDir, ".appilots-checksum");
     try {
       const content = await (0, import_promises4.readFile)(checksumFilePath, "utf-8");
       return content.trim() || null;
@@ -10848,7 +12079,7 @@ var MCPGenerator = class _MCPGenerator {
    */
   async getProjectInfo() {
     try {
-      const packageJsonPath = import_node_path3.default.resolve(this.analyzerConfig.rootDir, "package.json");
+      const packageJsonPath = import_node_path5.default.resolve(this.analyzerConfig.rootDir, "package.json");
       const packageJsonContent = await (0, import_promises4.readFile)(packageJsonPath, "utf-8");
       const packageJson = JSON.parse(packageJsonContent);
       return {
@@ -10923,8 +12154,8 @@ function reportMetadataLint(document, strict) {
 }
 
 // src/cli/utils/remote-drift.ts
-var import_node_fs = require("fs");
-var import_node_path4 = require("path");
+var import_node_fs3 = require("fs");
+var import_node_path6 = require("path");
 var STUB_RATIO = 0.5;
 function compareWithRemote(local, remote) {
   if (remote.screensCount === local.screens) return null;
@@ -10937,7 +12168,7 @@ function compareWithRemote(local, remote) {
 }
 function readLocalDocumentSummary(outputDir) {
   try {
-    const raw = (0, import_node_fs.readFileSync)((0, import_node_path4.join)(outputDir, "mcp-document.json"), "utf-8");
+    const raw = (0, import_node_fs3.readFileSync)((0, import_node_path6.join)(outputDir, "mcp-document.json"), "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.metadata?.totalScreens !== "number") return null;
     return { screens: parsed.metadata.totalScreens };
@@ -11022,14 +12253,18 @@ function assertDocumentHasScreens(document, options = {}) {
   }
   error("No screens found \u2014 this application map would give the agent nothing to navigate.");
   info("");
-  info("The analyzer looks for React Navigation: a <NavigationContainer> and");
-  info("<Stack.Screen> / <Tab.Screen> declarations. It found none.");
+  info("The analyzer reads React Navigation \u2014 <X.Navigator> JSX and the static");
+  info("`createXNavigator({ screens })` config \u2014 and Expo Router directory trees.");
+  info("It found no screen in any of them.");
   info("");
   info("The two usual causes:");
-  info("  \u2022 The app uses Expo Router (or another file-based router). It is the");
-  info("    default for `npx create-expo-app` and the analyzer cannot read it.");
-  info("  \u2022 The screens live outside the analyzed paths \u2014 check `include`,");
-  info("    `exclude` and `screenPatterns` in your Appilots config.");
+  info("  \u2022 The screens live outside the analyzed paths, or are named in a way");
+  info("    the screen filter does not match \u2014 check `include`, `exclude` and");
+  info("    `screenPatterns` in your Appilots config. The scan summary printed");
+  info("    above says how many files were reached and how many were filtered.");
+  info("  \u2022 The app uses a router the analyzer does not read yet, such as");
+  info("    react-native-navigation (Wix). Declaring the screens works for any");
+  info("    router \u2014 see the escape hatch below.");
   info("");
   info("The escape hatch, which works for any router: declare your screens in");
   info("an `appilots.manifest.json` at the project root. Its screens are merged");
@@ -11076,7 +12311,7 @@ function syncCommand() {
       const outputDir = config.outputDir || ".appilots";
       let previousChecksum = "";
       try {
-        const checksumPath = (0, import_node_path5.join)(outputDir, ".appilots-checksum");
+        const checksumPath = (0, import_node_path7.join)(outputDir, ".appilots-checksum");
         previousChecksum = (await (0, import_promises5.readFile)(checksumPath, "utf-8")).trim();
       } catch {
       }
@@ -11203,7 +12438,7 @@ function syncCommand() {
 
 // src/cli/commands/watch.ts
 var import_commander3 = require("commander");
-var import_node_fs2 = require("fs");
+var import_node_fs4 = require("fs");
 function watchCommand() {
   return new import_commander3.Command("watch").description("Watch project for changes and auto-sync MCP documents").option("--verbose", "Enable verbose logging", false).action(async (options) => {
     try {
@@ -11250,7 +12485,7 @@ function watchCommand() {
       dim("Press Ctrl+C to stop\n");
       let debounceTimer = null;
       const DEBOUNCE_MS = 500;
-      const watcher = (0, import_node_fs2.watch)(process.cwd(), { recursive: true }, async (eventType, filename) => {
+      const watcher = (0, import_node_fs4.watch)(process.cwd(), { recursive: true }, async (eventType, filename) => {
         if (!filename) return;
         if (filename.startsWith(".") || filename.includes("node_modules") || filename.includes(config.outputDir || ".appilots")) {
           return;
@@ -11302,6 +12537,95 @@ function watchCommand() {
 
 // src/cli/commands/generate.ts
 var import_commander4 = require("commander");
+
+// src/cli/utils/reach-report.ts
+function actionableScreens(document) {
+  return (document.screens ?? []).filter(
+    (screen) => (screen.actions?.length ?? 0) > 0 || (screen.forms?.length ?? 0) > 0 || (screen.targets?.length ?? 0) > 0
+  ).length;
+}
+function pct(part, whole) {
+  if (whole <= 0) return "\u2014";
+  return `${Math.round(100 * part / whole)}%`;
+}
+function reportReach(input) {
+  const { document, navigation } = input;
+  const screens = document.screens?.length ?? 0;
+  const useful = actionableScreens(document);
+  const filteredOut = document.metadata?.screensFilteredOut ?? 0;
+  info("");
+  info("Alcance da varredura");
+  info(
+    `  telas          ${screens} de ${document.metadata?.analyzedFiles ?? 0} arquivos analisados` + (filteredOut > 0 ? `, ${filteredOut} fora pelo filtro de tela` : "")
+  );
+  info(`  com aford\xE2ncia ${useful} (${pct(useful, screens)}) \u2014 a\xE7\xE3o, formul\xE1rio ou target`);
+  if (navigation) {
+    info(
+      `  navega\xE7\xE3o      ${navigation.filesWithEvidence} de ${navigation.filesScanned} arquivos com evid\xEAncia, ${navigation.navigatorsWithJsx} navegador(es) no documento`
+    );
+    info(
+      `  rotas          ${navigation.routes}, ${navigation.routesLinkedToFile} (${pct(navigation.routesLinkedToFile, navigation.routes)}) ligadas a um arquivo de tela`
+    );
+    if (navigation.fileBasedRouter) {
+      info(
+        `  roteador       ${navigation.fileBasedRouter.kind} em "${navigation.fileBasedRouter.routeDir}"`
+      );
+    }
+  }
+  const notes = [];
+  if (navigation && navigation.routes > 0 && useful > navigation.routes * 5) {
+    notes.push([
+      `${useful} tela(s) com aford\xE2ncia para apenas ${navigation.routes} rota(s).`,
+      "A varredura achou o que tocar em muito mais lugares do que sabe alcan\xE7ar.",
+      `S\xF3 ${navigation.filesWithEvidence} de ${navigation.filesScanned} arquivos varridos mencionam navega\xE7\xE3o \u2014`,
+      "se o roteador deste app mora fora deles, `navigationInclude` no `.appilotsrc`",
+      "estende a varredura sem mexer no resto."
+    ]);
+  }
+  if (navigation && navigation.routes === 0 && useful > 0) {
+    notes.push([
+      `${useful} tela(s) com aford\xE2ncia e nenhuma rota: o agente v\xEA o que tocar e n\xE3o sabe chegar l\xE1.`,
+      "O extractor l\xEA React Navigation (JSX e configura\xE7\xE3o est\xE1tica) e expo-router.",
+      "Se o app usa outro roteador, declare as telas em `appilots.manifest.json` \u2014",
+      "elas s\xE3o mescladas por cima do que a an\xE1lise achou."
+    ]);
+  } else if (navigation && navigation.routes > 0 && navigation.routesLinkedToFile < navigation.routes / 2) {
+    notes.push([
+      `${navigation.routes - navigation.routesLinkedToFile} de ${navigation.routes} rotas n\xE3o dizem qual arquivo montam.`,
+      "A liga\xE7\xE3o vem de `component={X}`. Formas indiretas \u2014 `getComponent={() => X}`,",
+      "componente constru\xEDdo em runtime \u2014 n\xE3o resolvem, e o agente fica com destinos vazios."
+    ]);
+  }
+  if (screens > 0 && useful === 0) {
+    notes.push([
+      `${screens} tela(s) encontradas e nenhuma com aford\xE2ncia.`,
+      "O extractor mira `onPress`/`onChangeText` com um locator endere\xE7\xE1vel:",
+      "`testID`, `appilotsId`, `accessibilityLabel` ou r\xF3tulo literal.",
+      "Sem nenhum deles n\xE3o h\xE1 como o agente apontar para o elemento."
+    ]);
+  }
+  if (filteredOut > 0 && screens > 0 && filteredOut > screens * 9) {
+    notes.push([
+      `${filteredOut} arquivos ficaram fora do filtro de tela para ${screens} dentro.`,
+      "Se as telas deste app moram noutro lugar, uma linha de `screenPatterns` no",
+      "`.appilotsrc` aponta onde \u2014 \xE9 o degrau mais barato da escada."
+    ]);
+  }
+  if (navigation && navigation.filesScanned > 0 && navigation.filesWithEvidence === 0) {
+    notes.push([
+      `Nenhum dos ${navigation.filesScanned} arquivos varridos menciona navega\xE7\xE3o.`,
+      "Confira `include`/`exclude` no `.appilotsrc`: o extractor pode n\xE3o estar",
+      "alcan\xE7ando o diret\xF3rio onde o roteador \xE9 declarado."
+    ]);
+  }
+  for (const note of notes) {
+    info("");
+    warn(note[0]);
+    for (const line of note.slice(1)) info(`  ${line}`);
+  }
+}
+
+// src/cli/commands/generate.ts
 function generateCommand() {
   return new import_commander4.Command("generate").description("Generate MCP documents from project source (local only)").option("-o, --output <path>", "Output directory for MCP documents", ".appilots").option("-f, --format <format>", "Output format (only json supported)", "json").option(
     "--strict-metadata",
@@ -11318,7 +12642,7 @@ function generateCommand() {
       spinner.start();
       let loaded = null;
       try {
-        loaded = loadConfig(warn);
+        loaded = loadConfig(warn, { requireApiKey: false });
       } catch {
         loaded = null;
       }
@@ -11326,11 +12650,21 @@ function generateCommand() {
         rootDir: process.cwd(),
         outputDir: options.output || ".appilots",
         format: "json",
+        strictScreens: loaded?.strictScreens,
+        screenPatterns: loaded?.screenPatterns,
+        include: loaded?.include,
+        exclude: loaded?.exclude,
+        navigationInclude: loaded?.navigationInclude,
+        navigationExclude: loaded?.navigationExclude,
         platform: loaded?.platform,
         manifestPath: loaded?.manifestPath
       });
       const output = await generator.generate();
       spinner.stop();
+      reportReach({
+        document: output.document,
+        ...output.diagnostics?.navigation ? { navigation: output.diagnostics.navigation } : {}
+      });
       assertDocumentHasScreens(output.document, {
         rootDir: process.cwd(),
         allowEmpty: Boolean(options.allowEmpty)
@@ -11350,19 +12684,18 @@ function generateCommand() {
 
 // src/cli/commands/annotate.ts
 var import_promises6 = require("fs/promises");
-var import_node_path7 = __toESM(require("path"));
+var import_node_path9 = __toESM(require("path"));
 var import_commander5 = require("commander");
-var import_fast_glob6 = __toESM(require("fast-glob"));
 
 // src/annotate/sites.ts
 var import_traverse12 = __toESM(require("@babel/traverse"));
-var t13 = __toESM(require("@babel/types"));
+var t14 = __toESM(require("@babel/types"));
 
 // src/annotate/forwarding.ts
-var import_node_path6 = __toESM(require("path"));
-var import_node_fs3 = require("fs");
+var import_node_path8 = __toESM(require("path"));
+var import_node_fs5 = require("fs");
 var import_traverse11 = __toESM(require("@babel/traverse"));
-var t12 = __toESM(require("@babel/types"));
+var t13 = __toESM(require("@babel/types"));
 var traverse11 = import_traverse11.default.default ?? import_traverse11.default;
 var RN_TESTID_CARRIERS = /* @__PURE__ */ new Set([
   "View",
@@ -11394,10 +12727,10 @@ function collectImports(ast) {
     ImportDeclaration(nodePath) {
       const source = nodePath.node.source.value;
       for (const spec of nodePath.node.specifiers) {
-        if (t12.isImportSpecifier(spec)) {
-          const imported = t12.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+        if (t13.isImportSpecifier(spec)) {
+          const imported = t13.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
           out.set(spec.local.name, { source, local: spec.local.name, imported });
-        } else if (t12.isImportDefaultSpecifier(spec)) {
+        } else if (t13.isImportDefaultSpecifier(spec)) {
           out.set(spec.local.name, { source, local: spec.local.name, imported: "default" });
         }
       }
@@ -11405,17 +12738,17 @@ function collectImports(ast) {
   });
   return out;
 }
-var EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+var EXTENSIONS2 = [".tsx", ".ts", ".jsx", ".js"];
 function resolveRelativeImport(fromFile, source) {
   if (!source.startsWith(".")) return void 0;
-  const base = import_node_path6.default.resolve(import_node_path6.default.dirname(fromFile), source);
-  for (const ext of EXTENSIONS) {
+  const base = import_node_path8.default.resolve(import_node_path8.default.dirname(fromFile), source);
+  for (const ext of EXTENSIONS2) {
     const candidate = `${base}${ext}`;
-    if ((0, import_node_fs3.existsSync)(candidate)) return candidate;
+    if ((0, import_node_fs5.existsSync)(candidate)) return candidate;
   }
-  for (const ext of EXTENSIONS) {
-    const candidate = import_node_path6.default.join(base, `index${ext}`);
-    if ((0, import_node_fs3.existsSync)(candidate)) return candidate;
+  for (const ext of EXTENSIONS2) {
+    const candidate = import_node_path8.default.join(base, `index${ext}`);
+    if ((0, import_node_fs5.existsSync)(candidate)) return candidate;
   }
   return void 0;
 }
@@ -11430,7 +12763,7 @@ function inspectModule(file2, exportName, depth = 0) {
   if (depth > 2) return none;
   let source;
   try {
-    source = (0, import_node_fs3.readFileSync)(file2, "utf-8");
+    source = (0, import_node_fs5.readFileSync)(file2, "utf-8");
   } catch {
     return none;
   }
@@ -11451,7 +12784,7 @@ function inspectModule(file2, exportName, depth = 0) {
       const from = nodePath.node.source?.value;
       if (!from) return;
       const named = nodePath.node.specifiers.some(
-        (spec) => t12.isExportSpecifier(spec) && (t12.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value) === exportName
+        (spec) => t13.isExportSpecifier(spec) && (t13.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value) === exportName
       );
       if (named) barrelTarget = from;
     },
@@ -11460,11 +12793,11 @@ function inspectModule(file2, exportName, depth = 0) {
     },
     // `interface CardProps { testID?: string }` / `type Props = { testID… }`
     TSPropertySignature(nodePath) {
-      if (t12.isIdentifier(nodePath.node.key) && nodePath.node.key.name === "testID") forwards = true;
+      if (t13.isIdentifier(nodePath.node.key) && nodePath.node.key.name === "testID") forwards = true;
     },
     // `function Card({ testID }) {}` — the destructured parameter.
     ObjectProperty(nodePath) {
-      if (t12.isIdentifier(nodePath.node.key) && nodePath.node.key.name === "testID") forwards = true;
+      if (t13.isIdentifier(nodePath.node.key) && nodePath.node.key.name === "testID") forwards = true;
     },
     // `<View {...props} />` — anything spread onto JSX carries it along.
     JSXSpreadAttribute() {
@@ -11475,17 +12808,17 @@ function inspectModule(file2, exportName, depth = 0) {
     // that is one hardcoded name shared by every instance, which is the
     // duplicate-id problem rather than a solution to it.
     JSXAttribute(nodePath) {
-      const name = t12.isJSXIdentifier(nodePath.node.name) ? nodePath.node.name.name : "";
+      const name = t13.isJSXIdentifier(nodePath.node.name) ? nodePath.node.name.name : "";
       if (name !== "testID" && name !== "accessibilityLabel") return;
       const value = nodePath.node.value;
-      if (!t12.isJSXExpressionContainer(value)) return;
-      if (t12.isStringLiteral(value.expression)) return;
+      if (!t13.isJSXExpressionContainer(value)) return;
+      if (t13.isStringLiteral(value.expression)) return;
       derives = true;
     },
     // `useAppilotsTarget(`${groupId}-${option.value}`, …)`
     CallExpression(nodePath) {
       const callee = nodePath.node.callee;
-      if (t12.isIdentifier(callee) && IDENTITY_HOOKS.has(callee.name)) derives = true;
+      if (t13.isIdentifier(callee) && IDENTITY_HOOKS.has(callee.name)) derives = true;
     }
   });
   if (forwards || derives) return { forwards, derives };
@@ -11570,18 +12903,18 @@ function hasLabelText(element) {
 function namedHandler(element, prop) {
   if (!prop) return void 0;
   const attr = findJsxAttribute(element, prop);
-  if (!attr || !t13.isJSXExpressionContainer(attr.value)) return void 0;
-  return t13.isIdentifier(attr.value.expression) ? attr.value.expression.name : void 0;
+  if (!attr || !t14.isJSXExpressionContainer(attr.value)) return void 0;
+  return t14.isIdentifier(attr.value.expression) ? attr.value.expression.name : void 0;
 }
 var ANNOTATABLE_ROLES = /* @__PURE__ */ new Set(["button", "input", "select", "toggle", "date", "list"]);
 function isPerItemRender(nodePath) {
   let current = nodePath.parentPath;
   while (current) {
     const node = current.node;
-    if (t13.isCallExpression(node) && t13.isMemberExpression(node.callee) && t13.isIdentifier(node.callee.property) && (node.callee.property.name === "map" || node.callee.property.name === "flatMap")) {
+    if (t14.isCallExpression(node) && t14.isMemberExpression(node.callee) && t14.isIdentifier(node.callee.property) && (node.callee.property.name === "map" || node.callee.property.name === "flatMap")) {
       return true;
     }
-    if (t13.isJSXAttribute(node) && t13.isJSXIdentifier(node.name) && /^render[A-Z]|^ListHeaderComponent$|^ListFooterComponent$/.test(node.name.name) && node.name.name !== "renderScrollComponent") {
+    if (t14.isJSXAttribute(node) && t14.isJSXIdentifier(node.name) && /^render[A-Z]|^ListHeaderComponent$|^ListFooterComponent$/.test(node.name.name) && node.name.name !== "renderScrollComponent") {
       return /^renderItem$|^renderSectionHeader$|^renderSectionFooter$/.test(node.name.name);
     }
     current = current.parentPath;
@@ -11611,7 +12944,7 @@ function findAnnotationSites(source, file2) {
   traverse12(ast, {
     JSXOpeningElement(nodePath) {
       const element = nodePath.node;
-      if (!t13.isJSXIdentifier(element.name)) return;
+      if (!t14.isJSXIdentifier(element.name)) return;
       const component = element.name.name;
       const role = classifyJsxComponent(component, element);
       if (!ANNOTATABLE_ROLES.has(role)) return;
@@ -11693,10 +13026,10 @@ function applyToFile(source, sites) {
 }
 
 // src/annotate/forward.ts
-var import_node_fs4 = require("fs");
+var import_node_fs6 = require("fs");
 var import_magic_string2 = __toESM(require("magic-string"));
 var import_traverse13 = __toESM(require("@babel/traverse"));
-var t14 = __toESM(require("@babel/types"));
+var t15 = __toESM(require("@babel/types"));
 var traverse13 = import_traverse13.default.default ?? import_traverse13.default;
 function findComponent(ast, name) {
   let found;
@@ -11707,9 +13040,9 @@ function findComponent(ast, name) {
       }
     },
     VariableDeclarator(nodePath) {
-      if (!t14.isIdentifier(nodePath.node.id) || nodePath.node.id.name !== name) return;
+      if (!t15.isIdentifier(nodePath.node.id) || nodePath.node.id.name !== name) return;
       const init = nodePath.node.init;
-      if (t14.isArrowFunctionExpression(init) || t14.isFunctionExpression(init)) {
+      if (t15.isArrowFunctionExpression(init) || t15.isFunctionExpression(init)) {
         found ??= { params: init.params, body: init.body };
       }
     }
@@ -11721,26 +13054,26 @@ function findReturnedRoots(body) {
   let unsupported = false;
   const record = (node) => {
     if (!node) return;
-    if (t14.isParenthesizedExpression(node)) return record(node.expression);
-    if (t14.isJSXElement(node)) {
+    if (t15.isParenthesizedExpression(node)) return record(node.expression);
+    if (t15.isJSXElement(node)) {
       roots.push(node.openingElement);
       return;
     }
-    if (t14.isConditionalExpression(node)) {
+    if (t15.isConditionalExpression(node)) {
       record(node.consequent);
       record(node.alternate);
       return;
     }
-    if (t14.isJSXFragment(node)) {
+    if (t15.isJSXFragment(node)) {
       unsupported = true;
       return;
     }
-    if (t14.isNullLiteral(node)) return;
+    if (t15.isNullLiteral(node)) return;
     unsupported = true;
   };
-  if (t14.isBlockStatement(body)) {
+  if (t15.isBlockStatement(body)) {
     traverse13(
-      t14.file(t14.program([t14.expressionStatement(t14.functionExpression(null, [], body))])),
+      t15.file(t15.program([t15.expressionStatement(t15.functionExpression(null, [], body))])),
       {
         ReturnStatement(nodePath) {
           record(nodePath.node.argument);
@@ -11754,7 +13087,7 @@ function findReturnedRoots(body) {
   return roots;
 }
 function isCarrierRoot(element, imports) {
-  if (!t14.isJSXIdentifier(element.name)) return false;
+  if (!t15.isJSXIdentifier(element.name)) return false;
   const name = element.name.name;
   const origin = imports.get(name);
   if (origin?.source !== "react-native") return false;
@@ -11762,7 +13095,7 @@ function isCarrierRoot(element, imports) {
 }
 function hasProp(element, name) {
   return element.attributes.some(
-    (attr) => t14.isJSXAttribute(attr) && t14.isJSXIdentifier(attr.name) && attr.name.name === name
+    (attr) => t15.isJSXAttribute(attr) && t15.isJSXIdentifier(attr.name) && attr.name.name === name
   );
 }
 function indentOf(source, offset) {
@@ -11793,7 +13126,7 @@ function followBarrel(file2, ast, component) {
       const from = nodePath.node.source?.value;
       if (!from) return;
       const named = nodePath.node.specifiers.some(
-        (spec) => t14.isExportSpecifier(spec) && (t14.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value) === component
+        (spec) => t15.isExportSpecifier(spec) && (t15.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value) === component
       );
       if (named) target ??= from;
     }
@@ -11804,7 +13137,7 @@ function planForward(file2, component, depth = 0) {
   const base = { file: file2, component, edits: [], roots: 0 };
   let source;
   try {
-    source = (0, import_node_fs4.readFileSync)(file2, "utf-8");
+    source = (0, import_node_fs6.readFileSync)(file2, "utf-8");
   } catch {
     return { ...base, refusal: `cannot read ${file2}` };
   }
@@ -11821,7 +13154,7 @@ function planForward(file2, component, depth = 0) {
     return { ...base, refusal: `no function named ${component} in this file` };
   }
   const param = found.params[0];
-  if (!t14.isObjectPattern(param)) {
+  if (!t15.isObjectPattern(param)) {
     return {
       ...base,
       refusal: `${component} does not destructure its props, so there is no safe place to add one without knowing what the parameter is called downstream`
@@ -11837,7 +13170,7 @@ function planForward(file2, component, depth = 0) {
   const imports = collectImports(ast);
   const nonCarrier = roots.find((root) => !isCarrierRoot(root, imports));
   if (nonCarrier) {
-    const name = t14.isJSXIdentifier(nonCarrier.name) ? nonCarrier.name.name : "its root";
+    const name = t15.isJSXIdentifier(nonCarrier.name) ? nonCarrier.name.name : "its root";
     return {
       ...base,
       refusal: `${component} renders <${name}> at its root, which is not a React Native element known to accept testID. Forwarding into it would move the problem down a level, not fix it`
@@ -11845,21 +13178,21 @@ function planForward(file2, component, depth = 0) {
   }
   const edits = [];
   const alreadyDestructured = param.properties.some(
-    (prop) => t14.isObjectProperty(prop) && t14.isIdentifier(prop.key) && prop.key.name === "testID"
+    (prop) => t15.isObjectProperty(prop) && t15.isIdentifier(prop.key) && prop.key.name === "testID"
   );
   if (!alreadyDestructured) {
     const insert = insertAfterLastMember(source, param.properties, "testID", param.end ?? 0, ",");
     edits.push({ ...insert, what: "parameter" });
   }
   const annotation = param.typeAnnotation;
-  if (t14.isTSTypeAnnotation(annotation)) {
+  if (t15.isTSTypeAnnotation(annotation)) {
     const declared = annotation.typeAnnotation;
     let body;
     let closing = 0;
-    if (t14.isTSTypeLiteral(declared)) {
+    if (t15.isTSTypeLiteral(declared)) {
       body = declared.members;
       closing = declared.end ?? 0;
-    } else if (t14.isTSTypeReference(declared) && t14.isIdentifier(declared.typeName)) {
+    } else if (t15.isTSTypeReference(declared) && t15.isIdentifier(declared.typeName)) {
       const typeName = declared.typeName.name;
       traverse13(ast, {
         TSInterfaceDeclaration(nodePath) {
@@ -11868,7 +13201,7 @@ function planForward(file2, component, depth = 0) {
           closing = nodePath.node.body.end ?? 0;
         },
         TSTypeAliasDeclaration(nodePath) {
-          if (nodePath.node.id.name !== typeName || !t14.isTSTypeLiteral(nodePath.node.typeAnnotation))
+          if (nodePath.node.id.name !== typeName || !t15.isTSTypeLiteral(nodePath.node.typeAnnotation))
             return;
           body = nodePath.node.typeAnnotation.members;
           closing = nodePath.node.typeAnnotation.end ?? 0;
@@ -11883,7 +13216,7 @@ function planForward(file2, component, depth = 0) {
     }
     if (body) {
       const declaresTestId = body.some(
-        (member) => t14.isTSPropertySignature(member) && t14.isIdentifier(member.key) && member.key.name === "testID"
+        (member) => t15.isTSPropertySignature(member) && t15.isIdentifier(member.key) && member.key.name === "testID"
       );
       if (!declaresTestId) {
         const insert = insertAfterLastMember(source, body, "testID?: string;", closing, ";");
@@ -11940,7 +13273,7 @@ function annotateCommand() {
       const spinner = createSpinner("Scanning for unaddressable controls...");
       spinner.start();
       resetForwardingCache();
-      const files = await (0, import_fast_glob6.default)(include, { cwd: rootDir, ignore: exclude, absolute: true });
+      const files = await globSorted(include, { cwd: rootDir, ignore: exclude, absolute: true });
       const scan = async () => {
         const out = [];
         for (const file2 of files) {
@@ -11989,9 +13322,9 @@ function annotateCommand() {
           written: options.write === true,
           annotated: written.length,
           blocked: blocked.length,
-          files: touched.map((edit) => import_node_path7.default.relative(rootDir, edit.file)),
+          files: touched.map((edit) => import_node_path9.default.relative(rootDir, edit.file)),
           sites: [...written, ...blocked].map((site) => ({
-            file: import_node_path7.default.relative(rootDir, site.file),
+            file: import_node_path9.default.relative(rootDir, site.file),
             line: site.line,
             component: site.component,
             role: site.role,
@@ -12034,9 +13367,12 @@ async function planForwards(edits, rootDir) {
   void rootDir;
   return plans;
 }
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function findImportSource(source, name) {
   const pattern = new RegExp(
-    String.raw`import\s*\{[^}]*\b${name}\b[^}]*\}\s*from\s*['"]([^'"]+)['"]`
+    String.raw`import\s*\{[^}]*\b${escapeRegExp(name)}\b[^}]*\}\s*from\s*['"]([^'"]+)['"]`
   );
   return pattern.exec(source)?.[1];
 }
@@ -12045,7 +13381,7 @@ function reportSites(rootDir, touched, blocked, didWrite, forwards) {
   if (written.length > 0) {
     heading(didWrite ? "Added" : "Would add");
     for (const edit of touched) {
-      info(import_node_path7.default.relative(rootDir, edit.file));
+      info(import_node_path9.default.relative(rootDir, edit.file));
       for (const site of edit.written) {
         dim(`  ${String(site.line).padStart(4)}  <${site.component}>  testID="${site.testId}"`);
       }
@@ -12057,7 +13393,7 @@ function reportSites(rootDir, touched, blocked, didWrite, forwards) {
   if (teachable.size > 0) {
     heading(didWrite ? "Taught to carry testID" : "Would teach to carry testID");
     for (const plan of teachable.values()) {
-      info(`<${plan.component}>  ${import_node_path7.default.relative(rootDir, plan.file)}`);
+      info(`<${plan.component}>  ${import_node_path9.default.relative(rootDir, plan.file)}`);
       for (const edit of plan.edits) {
         dim(`      ${edit.what}: ${edit.text.trim()}`);
       }
@@ -12365,10 +13701,10 @@ function matchActions(expected, actual, reply = "") {
 var import_fs9 = require("fs");
 var import_path8 = require("path");
 var EMPTY_BASELINE = { generatedAt: null, gitSha: null, perScenario: {} };
-function loadBaseline(path11) {
-  if (!(0, import_fs9.existsSync)(path11)) return { ...EMPTY_BASELINE, perScenario: {} };
+function loadBaseline(path13) {
+  if (!(0, import_fs9.existsSync)(path13)) return { ...EMPTY_BASELINE, perScenario: {} };
   try {
-    const raw = JSON.parse((0, import_fs9.readFileSync)(path11, "utf-8"));
+    const raw = JSON.parse((0, import_fs9.readFileSync)(path13, "utf-8"));
     return {
       generatedAt: raw.generatedAt ?? null,
       gitSha: raw.gitSha ?? null,
@@ -12378,9 +13714,9 @@ function loadBaseline(path11) {
     return { ...EMPTY_BASELINE, perScenario: {} };
   }
 }
-function saveBaseline(path11, baseline) {
-  (0, import_fs9.mkdirSync)((0, import_path8.dirname)(path11), { recursive: true });
-  (0, import_fs9.writeFileSync)(path11, `${JSON.stringify(baseline, null, 2)}
+function saveBaseline(path13, baseline) {
+  (0, import_fs9.mkdirSync)((0, import_path8.dirname)(path13), { recursive: true });
+  (0, import_fs9.writeFileSync)(path13, `${JSON.stringify(baseline, null, 2)}
 `, "utf-8");
 }
 function buildBaseline(outcomes, meta) {
@@ -12408,11 +13744,11 @@ function diffAgainstBaseline(outcomes, baseline, maxTokenRegression) {
       continue;
     }
     if (outcome.status === "passed" && prior.status === "passed" && prior.totalTokens > 0 && outcome.totalTokens > prior.totalTokens * (1 + maxTokenRegression)) {
-      const pct = Math.round((outcome.totalTokens - prior.totalTokens) / prior.totalTokens * 100);
+      const pct2 = Math.round((outcome.totalTokens - prior.totalTokens) / prior.totalTokens * 100);
       regressions.push({
         name: outcome.name,
         kind: "token-regression",
-        detail: `tokens ${prior.totalTokens} \u2192 ${outcome.totalTokens} (+${pct}%, threshold +${Math.round(maxTokenRegression * 100)}%)`
+        detail: `tokens ${prior.totalTokens} \u2192 ${outcome.totalTokens} (+${pct2}%, threshold +${Math.round(maxTokenRegression * 100)}%)`
       });
     }
   }