@backthread/extractor 0.1.0

package/dist/framework/react-native/react-native.js

@@ -0,0 +1,1181 @@
+// (Slice 1) — the React Native / Expo FrameworkAdapter.
+//
+// FIRST implementation of the FrameworkAdapter contract, and `detect()` ONLY
+// this slice: it decides "is this an RN/Expo app, and is it Expo or bare RN?"
+// from package.json deps + config-file existence — never source content
+// (never-store-source). The graph contributions (navigation graph, JS↔native
+// bridge boundary, screen roles) land in .  reverses the 
+// "connect now, group later" deferral and adds the `groupingPrior` hook:
+// screens registered in one navigator (Stack/Tab/Drawer) become one feature
+// subsystem (a feature-folder fallback covers route files with no navigator —
+// e.g. Expo Router pages). `classificationsNeeded` stays absent (grouping is
+// fully deterministic — name/path-derived, zero LLM).
+//
+// Detection signals (manifest + config existence only):
+//   * deps:    `react-native` and/or `expo`
+//   * configs: app.json · app.config.{js,ts,cjs,mjs} · metro.config.{js,ts,cjs}
+//              · react-native.config.{js,ts}
+//   * native:  ios/ + android/ dirs
+//
+// The scoring is a PURE function (scoreReactNative) so it unit-tests without a
+// real repo dir; the adapter just gathers the fs signals and calls it — the
+// same pure-builder / fs-adapter split the infra adapters use.
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join, posix, relative } from 'node:path';
+import { SyntaxKind, } from 'ts-morph';
+import { addAllSourceFiles, buildExtractionProject, readTsconfigCompilerOptions, toId, } from '../../graph/ts-morph-adapter.js';
+import { SOURCE_EXTENSIONS } from '../../graph/file-graph.js';
+import { extractExpoRouterTree } from '../routing/index.js';
+// Config-file name sets — existence-only checks (we never read their content).
+const APP_CONFIG_NAMES = ['app.config.js', 'app.config.ts', 'app.config.cjs', 'app.config.mjs'];
+const METRO_CONFIG_NAMES = ['metro.config.js', 'metro.config.ts', 'metro.config.cjs'];
+const RN_CONFIG_NAMES = ['react-native.config.js', 'react-native.config.ts'];
+// ---------------------------------------------------------------------------
+// Signal gathering (fs) — kept thin so the scoring stays pure + testable.
+/** The merged dependency map from a package.json (deps + devDeps); {} on any error. */
+function readDeps(baseDir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(baseDir, 'package.json'), 'utf8'));
+        return { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+    }
+    catch {
+        return {};
+    }
+}
+function isDir(p) {
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Gather the signal set for a single root dir. */
+export function gatherReactNativeSignals(baseDir) {
+    const deps = readDeps(baseDir);
+    return {
+        hasReactNativeDep: 'react-native' in deps,
+        hasExpoDep: 'expo' in deps,
+        hasAppJson: existsSync(join(baseDir, 'app.json')),
+        hasAppConfig: APP_CONFIG_NAMES.some((n) => existsSync(join(baseDir, n))),
+        hasMetroConfig: METRO_CONFIG_NAMES.some((n) => existsSync(join(baseDir, n))),
+        hasRnConfig: RN_CONFIG_NAMES.some((n) => existsSync(join(baseDir, n))),
+        hasIosDir: isDir(join(baseDir, 'ios')),
+        hasAndroidDir: isDir(join(baseDir, 'android')),
+    };
+}
+// ---------------------------------------------------------------------------
+// Pure scoring.
+/**
+ * Decide RN/Expo from the signal set. Returns a DetectMatch, or null if the
+ * signals are too weak/ambiguous to claim the stack (so the generic-TS
+ * fallthrough stays intact).
+ *
+ * A SUFFICIENT (match-on-its-own) signal is one of:
+ *   * a `react-native` or `expo` dep                  — the authoritative signal
+ *   * metro.config.* or react-native.config.*         — RN-toolchain-specific
+ *   * BOTH ios/ and android/ native dirs              — a built RN project
+ *
+ * app.json / app.config / a single native dir are SUPPORTING signals (they
+ * raise confidence) but never sufficient alone — app.json in particular is too
+ * generic to claim a stack on its own.
+ *
+ * Variant: `expo` dep (or an `app.config.*` dynamic config) ⇒ 'expo', else
+ * 'bare'. Recorded in metadata + reflected in confidence.
+ */
+export function scoreReactNative(s, rootPath = '') {
+    const hasDep = s.hasReactNativeDep || s.hasExpoDep;
+    const hasRnToolingConfig = s.hasMetroConfig || s.hasRnConfig;
+    const hasBothNative = s.hasIosDir && s.hasAndroidDir;
+    // Gate: need at least one SUFFICIENT signal. Supporting-only ⇒ no match.
+    if (!hasDep && !hasRnToolingConfig && !hasBothNative)
+        return null;
+    let confidence = 0;
+    if (s.hasReactNativeDep)
+        confidence += 0.5;
+    if (s.hasExpoDep)
+        confidence += 0.5;
+    if (s.hasMetroConfig)
+        confidence += 0.2;
+    if (s.hasRnConfig)
+        confidence += 0.2;
+    if (hasBothNative)
+        confidence += 0.3;
+    else if (s.hasIosDir || s.hasAndroidDir)
+        confidence += 0.1;
+    if (s.hasAppConfig)
+        confidence += 0.1;
+    if (s.hasAppJson)
+        confidence += 0.05;
+    confidence = Math.min(1, Number(confidence.toFixed(2)));
+    const variant = s.hasExpoDep || s.hasAppConfig ? 'expo' : 'bare';
+    return {
+        adapter: 'react-native',
+        confidence,
+        rootPath,
+        metadata: {
+            variant,
+            signals: {
+                reactNativeDep: s.hasReactNativeDep,
+                expoDep: s.hasExpoDep,
+                appJson: s.hasAppJson,
+                appConfig: s.hasAppConfig,
+                metroConfig: s.hasMetroConfig,
+                rnConfig: s.hasRnConfig,
+                iosDir: s.hasIosDir,
+                androidDir: s.hasAndroidDir,
+            },
+        },
+    };
+}
+const ROLE_PRIORITY = {
+    endpoint: 9, // Expo Router API route — a server boundary; the only `gateway` here
+    navigator: 8, // React Navigation navigator (structural container)
+    layout: 7, // Expo Router layout (structural container)
+    nativeModule: 6, // JS↔native bridge
+    page: 5, // Expo Router page — a concrete routed screen
+    screen: 4, // React Navigation screen
+    route: 3, // Expo Router generic routable (Expo never emits it; kept for the type)
+    hook: 2,
+    component: 1,
+};
+const ROLE_KIND = {
+    endpoint: 'gateway',
+    navigator: 'frontend',
+    layout: 'frontend',
+    nativeModule: 'service',
+    page: 'frontend',
+    screen: 'frontend',
+    route: 'frontend',
+    hook: 'frontend',
+    component: 'frontend',
+};
+const NAVIGATOR_FACTORIES = new Set([
+    'createStackNavigator',
+    'createNativeStackNavigator',
+    'createBottomTabNavigator',
+    'createMaterialTopTabNavigator',
+    'createMaterialBottomTabNavigator',
+    'createDrawerNavigator',
+]);
+// `navigation.<m>('Screen')` — methods whose first string arg is a screen name.
+// `navigate`/`replace` are nav-unambiguous → an unresolved string is LOGGED.
+// `push`/`popTo`/`jumpTo`/`navigateDeprecated` collide with Array/other APIs
+// (`arr.push('x')`), so they only emit on a REGISTRY HIT and miss silently —
+// a non-screen string there is not a dropped nav target, it's not a nav call.
+const NAV_LOG_METHODS = new Set(['navigate', 'replace']);
+const NAV_SOFT_METHODS = new Set(['push', 'popTo', 'jumpTo', 'navigateDeprecated']);
+const NATIVE_GLOBALS = new Set(['NativeModules', 'TurboModuleRegistry']);
+const NATIVE_FUNCS = new Set(['requireNativeComponent', 'requireNativeModule']);
+const SOURCE_EXT_SET = new Set(SOURCE_EXTENSIONS);
+// Analysis is memoized on the FrameworkContext OBJECT (not repoDir): the step
+// passes the SAME ctx to syntheticEdges + roleTags so they share one parse,
+// while the merge walk's per-checkpoint ctx (same clone.dir path, different tree)
+// gets a fresh analysis — no cross-tree staleness.
+const ANALYSIS_CACHE = new WeakMap();
+function roleTag(role) {
+    return { role, kind: ROLE_KIND[role], priority: ROLE_PRIORITY[role] };
+}
+// Keep the highest-priority candidate role per file (deterministic, lexical
+// tiebreak) — a screen that also touches NativeModules reads as `nativeModule`.
+function addRole(map, fileId, role) {
+    const cur = map.get(fileId);
+    if (cur === undefined ||
+        ROLE_PRIORITY[role] > ROLE_PRIORITY[cur] ||
+        (ROLE_PRIORITY[role] === ROLE_PRIORITY[cur] && role < cur)) {
+        map.set(fileId, role);
+    }
+}
+// localImportedName → resolved repo-relative file id, for a single source file.
+// When ts-morph resolves the specifier we trust it; when it doesn't (a tsconfig
+// path alias the in-memory Project mis-anchors), we fall back to our
+// own alias resolver so `#/`-aliased screen imports still bind to real files.
+function buildImportNameMap(sf, repoDir, aliasResolve) {
+    const map = new Map();
+    for (const decl of sf.getImportDeclarations()) {
+        const resolved = decl.getModuleSpecifierSourceFile();
+        let fileId;
+        if (resolved) {
+            fileId = toId(repoDir, resolved.getFilePath());
+        }
+        else {
+            const spec = decl.getModuleSpecifierValue();
+            fileId = spec ? aliasResolve(spec) : undefined;
+        }
+        if (!fileId)
+            continue;
+        const def = decl.getDefaultImport();
+        if (def)
+            map.set(def.getText(), fileId);
+        const ns = decl.getNamespaceImport();
+        if (ns)
+            map.set(ns.getText(), fileId);
+        for (const ni of decl.getNamedImports()) {
+            map.set((ni.getAliasNode() ?? ni.getNameNode()).getText(), fileId);
+        }
+    }
+    return map;
+}
+// Resolve a bare base path (extensionless) to a real source-file id: the path
+// itself, then each source extension, then an index file, in the FIXED
+// SOURCE_EXTENSIONS order so the pick is snapshot-stable.
+function resolveAgainstIdSet(base, idSet) {
+    if (idSet.has(base))
+        return base;
+    for (const ext of SOURCE_EXTENSIONS) {
+        const cand = `${base}.${ext}`;
+        if (idSet.has(cand))
+            return cand;
+    }
+    for (const ext of SOURCE_EXTENSIONS) {
+        const cand = `${base}/index.${ext}`;
+        if (idSet.has(cand))
+            return cand;
+    }
+    return undefined;
+}
+// Build the alias patterns from the repo's tsconfig/jsconfig `paths`. The
+// tsconfig READ (candidate search + JSONC parse: comments + trailing commas, no
+// `extends` follow) is now the SHARED graph/ts-morph-adapter helper
+// centralized it so this adapter and the structural extractor can't drift on
+// what parses (the no-baseUrl + trailing-comma shape that previously dropped
+// every alias). This adapter then keeps its OWN pattern model + id-set resolver
+// (makeAliasResolver / makeSpecifierResolver), because RN must resolve arbitrary
+// string specifiers — including the lazy `require('#/…')` / `import('#/…')`
+// screen forms — against the file-id set, which ts-morph's static-declaration
+// resolution structurally cannot do.
+//
+// Note: deferring to the shared reader adopts its "FIRST config declaring
+// baseUrl||paths wins" rule (the config the TS compiler loads); the old local
+// reader skipped a baseUrl-only config to keep hunting for one with `paths`.
+// Negligible/more-correct in practice (paths + baseUrl live in the same root
+// tsconfig); fixtures + real RN repos are unaffected. The '*' wildcard + leading
+// './' are normalized away so resolution stays a plain join.
+function readAliasPatterns(repoDir) {
+    const paths = readTsconfigCompilerOptions(repoDir)?.paths;
+    if (!paths || typeof paths !== 'object')
+        return [];
+    const out = [];
+    for (const [key, val] of Object.entries(paths)) {
+        if (!Array.isArray(val))
+            continue;
+        const wildcard = key.endsWith('/*');
+        const prefix = wildcard ? key.slice(0, -1) : key; // '#/*' → '#/'
+        const targets = val
+            .filter((t) => typeof t === 'string')
+            .map((t) => {
+            let s = t.replace(/^\.\//, '').replace(/^\//, '');
+            if (wildcard)
+                s = s.replace(/\*$/, '').replace(/\/$/, ''); // './src/*' → 'src'
+            return s;
+        });
+        if (targets.length > 0)
+            out.push({ prefix, wildcard, targets });
+    }
+    return out;
+}
+// A non-relative specifier → a real file id via the tsconfig path aliases, or
+// undefined. Tries each matching pattern's targets in declared order against the
+// id set (with extension/index resolution) — fully deterministic.
+function makeAliasResolver(patterns, idSet) {
+    return (spec) => {
+        for (const { prefix, wildcard, targets } of patterns) {
+            if (wildcard) {
+                if (!spec.startsWith(prefix))
+                    continue;
+                const rest = spec.slice(prefix.length);
+                for (const base of targets) {
+                    const full = base ? `${base}/${rest}` : rest;
+                    const r = resolveAgainstIdSet(full, idSet);
+                    if (r)
+                        return r;
+                }
+            }
+            else {
+                if (spec !== prefix)
+                    continue;
+                for (const base of targets) {
+                    const r = resolveAgainstIdSet(base, idSet);
+                    if (r)
+                        return r;
+                }
+            }
+        }
+        return undefined;
+    };
+}
+// Deterministic specifier resolver over the known source-file id set, for the
+// lazy `require('…')` / `import('…')` forms: RELATIVE specifiers resolve against
+// the importing file's dir; a non-relative (bare/aliased) specifier falls to the
+// tsconfig alias resolver. Snapshot-stable by construction.
+function makeSpecifierResolver(idSet, aliasResolve) {
+    return (fromFileId, spec) => {
+        if (!spec.startsWith('.'))
+            return aliasResolve(spec);
+        const slash = fromFileId.lastIndexOf('/');
+        const dir = slash >= 0 ? fromFileId.slice(0, slash) : '';
+        return resolveAgainstIdSet(posix.join(dir, spec), idSet);
+    };
+}
+// Structural accessors — ts-morph exposes getExpression()/getInitializer()/
+// getLiteralValue() on many concrete node types but not on the base Node, and we
+// reach them only after a getKind() gate, so a guarded optional-call is both safe
+// and avoids a forest of per-kind casts.
+function innerExpression(node) {
+    return node.getExpression?.();
+}
+function nodeInitializer(node) {
+    return node.getInitializer?.();
+}
+function literalValue(node) {
+    return node.getLiteralValue?.();
+}
+// Statically resolve a string from an expression node — a string literal, an
+// `as`/parenthesis/non-null-wrapped literal (the RUNTIME value; a type cast like
+// `'X' as 'Y'` is type-only), or a const / enum member / object-literal-const
+// property whose value is itself a static string. Truly computed → undefined.
+function staticStringValue(node, depth = 0) {
+    if (depth > 8)
+        return undefined;
+    switch (node.getKind()) {
+        case SyntaxKind.StringLiteral:
+        case SyntaxKind.NoSubstitutionTemplateLiteral:
+            return literalValue(node);
+        case SyntaxKind.ParenthesizedExpression:
+        case SyntaxKind.AsExpression:
+        case SyntaxKind.SatisfiesExpression:
+        case SyntaxKind.NonNullExpression:
+        case SyntaxKind.TypeAssertionExpression: {
+            const inner = innerExpression(node);
+            return inner ? staticStringValue(inner, depth + 1) : undefined;
+        }
+        case SyntaxKind.Identifier:
+        case SyntaxKind.PropertyAccessExpression:
+            return resolveConstString(node, depth);
+        default:
+            return undefined;
+    }
+}
+// Resolve an Identifier / PropertyAccess referring to a const string, enum
+// member, or const object property to its string value (symbol-based; degrades
+// to undefined without resolution rather than throwing).
+function resolveConstString(node, depth) {
+    let sym;
+    try {
+        sym = node.getSymbol();
+    }
+    catch {
+        return undefined;
+    }
+    const decl = sym?.getValueDeclaration() ?? sym?.getDeclarations()?.[0];
+    if (!decl)
+        return undefined;
+    switch (decl.getKind()) {
+        case SyntaxKind.VariableDeclaration:
+        case SyntaxKind.EnumMember:
+        case SyntaxKind.PropertyAssignment: {
+            const init = nodeInitializer(decl);
+            return init ? staticStringValue(init, depth + 1) : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+// Resolve a screen-registration `name` to its runtime string value, or undefined
+// when it's truly computed/dynamic. Handles a JSX string attr (`name="X"`) and a
+// statically-resolvable JSX expression (`name={'X' as 'Y'}`, `name={ROUTE}`, …).
+function resolveScreenName(nameAttr) {
+    const init = nameAttr.getInitializer();
+    if (!init)
+        return undefined;
+    if (init.getKind() === SyntaxKind.StringLiteral) {
+        return init.getLiteralValue();
+    }
+    if (init.getKind() === SyntaxKind.JsxExpression) {
+        const expr = init.getExpression();
+        return expr ? staticStringValue(expr) : undefined;
+    }
+    return undefined;
+}
+// Resolve a component-producing expression used in a screen registration to its
+// file id. Handles BOTH eager `component={X}` and the lazy `getComponent` forms
+//: an imported identifier, a namespace member, or a `require('./x')` /
+// `import('./x')` (incl. a `.Named` access on either). `as`/paren/non-null
+// wrappers are unwrapped. An imported symbol → its source file; a locally-defined
+// component (or nested navigator) → the registering file. Anything else (an
+// inline `() => <Foo/>`, a require we can't resolve install-free) → undefined,
+// so the caller LOGS + skips rather than mis-register the screen.
+function resolveComponentRef(expr, imports, selfFileId, resolveSpecifier, depth = 0) {
+    if (depth > 8)
+        return undefined;
+    switch (expr.getKind()) {
+        case SyntaxKind.ParenthesizedExpression:
+        case SyntaxKind.AsExpression:
+        case SyntaxKind.SatisfiesExpression:
+        case SyntaxKind.NonNullExpression:
+        case SyntaxKind.TypeAssertionExpression: {
+            const inner = innerExpression(expr);
+            return inner ? resolveComponentRef(inner, imports, selfFileId, resolveSpecifier, depth + 1) : undefined;
+        }
+        case SyntaxKind.Identifier:
+            return imports.get(expr.getText()) ?? selfFileId;
+        case SyntaxKind.PropertyAccessExpression: {
+            const base = expr.getExpression();
+            // `require('./x').Named` / `import('./x').Named` → resolve the call.
+            if (base.getKind() === SyntaxKind.CallExpression) {
+                return resolveComponentRef(base, imports, selfFileId, resolveSpecifier, depth + 1);
+            }
+            // `Ns.Component` → resolve the root identifier (imported, else self file).
+            if (base.getKind() === SyntaxKind.Identifier) {
+                return imports.get(base.getText()) ?? selfFileId;
+            }
+            return resolveComponentRef(base, imports, selfFileId, resolveSpecifier, depth + 1);
+        }
+        case SyntaxKind.CallExpression: {
+            const call = expr;
+            const callee = call.getExpression();
+            const isRequire = callee.getKind() === SyntaxKind.Identifier && callee.getText() === 'require';
+            const isImport = callee.getKind() === SyntaxKind.ImportKeyword || callee.getText() === 'import';
+            if (!isRequire && !isImport)
+                return undefined;
+            const arg = call.getArguments()[0];
+            if (!arg || arg.getKind() !== SyntaxKind.StringLiteral)
+                return undefined;
+            return resolveSpecifier(arg.getLiteralValue());
+        }
+        default:
+            return undefined;
+    }
+}
+// From a `getComponent={() => …}` initializer (an arrow / function expression),
+// return the single expression it RETURNS — a concise arrow body, or the first
+// top-level `return`'s argument in a block body. Undefined otherwise.
+function getComponentReturnExpr(fn) {
+    const k = fn.getKind();
+    if (k !== SyntaxKind.ArrowFunction && k !== SyntaxKind.FunctionExpression)
+        return undefined;
+    const body = fn.getBody();
+    if (!body)
+        return undefined;
+    if (body.getKind() !== SyntaxKind.Block)
+        return body; // concise arrow body
+    for (const stmt of body.getStatements()) {
+        if (stmt.getKind() === SyntaxKind.ReturnStatement) {
+            return stmt.getExpression();
+        }
+    }
+    return undefined;
+}
+// The static-config screen property KEY → screen name: a plain identifier/string
+// key, or a computed `[ROUTE]` key resolved to its static string. Dynamic → undefined.
+function staticPropName(pa) {
+    const nameNode = pa.getNameNode();
+    if (nameNode.getKind() === SyntaxKind.ComputedPropertyName) {
+        const e = innerExpression(nameNode);
+        return e ? staticStringValue(e) : undefined;
+    }
+    if (nameNode.getKind() === SyntaxKind.StringLiteral) {
+        return nameNode.getLiteralValue();
+    }
+    return nameNode.getText();
+}
+// A static-config screen VALUE → component file id. The value is either the
+// component reference directly (`Home: HomeScreen`) or a screen-config object
+// (`Home: { screen: X }` / `{ component: X }` / `{ getComponent: () => … }`).
+function resolveConfigScreenComponent(init, imports, selfFileId, resolveSpecifier) {
+    if (init.getKind() === SyntaxKind.ObjectLiteralExpression) {
+        const obj = init;
+        for (const key of ['screen', 'component', 'getComponent']) {
+            const p = obj.getProperty(key);
+            if (!p || p.getKind() !== SyntaxKind.PropertyAssignment)
+                continue;
+            const v = p.getInitializer();
+            if (!v)
+                continue;
+            if (key === 'getComponent') {
+                const ret = getComponentReturnExpr(v);
+                return ret ? resolveComponentRef(ret, imports, selfFileId, resolveSpecifier) : undefined;
+            }
+            return resolveComponentRef(v, imports, selfFileId, resolveSpecifier);
+        }
+        return undefined;
+    }
+    return resolveComponentRef(init, imports, selfFileId, resolveSpecifier);
+}
+// Collect screen registrations from one file: JSX `<X.Screen name component|
+// getComponent>` plus the static `createXNavigator({ screens })` config.
+// `resolveSpecifier` is the per-file (bound to this file) relative require/import
+// resolver. Diagnostics accumulate into `diag` for one aggregated log.
+function collectScreens(sf, imports, selfFileId, registry, screenFiles, resolveSpecifier, diag, membership) {
+    let isNavigator = false;
+    const register = (screenName, componentFile) => {
+        if (!registry.has(screenName))
+            registry.set(screenName, componentFile);
+        screenFiles.add(componentFile);
+        // record this screen's component file as a member of THIS file's
+        // navigator(s), so the grouping prior can group a navigator's screens into
+        // one feature subsystem (independent of the global first-wins registry).
+        membership.add(componentFile);
+    };
+    // The component file from a screen element's `component` / `getComponent` attr.
+    // Returns a file id (resolved), null (an attr was present but unresolvable →
+    // caller logs), or undefined (no component-binding attr at all).
+    const componentFileOf = (el) => {
+        const comp = el.getAttribute('component');
+        if (comp && comp.getKind() === SyntaxKind.JsxAttribute) {
+            const init = comp.getInitializer();
+            if (init && init.getKind() === SyntaxKind.JsxExpression) {
+                const e = init.getExpression();
+                if (e)
+                    return resolveComponentRef(e, imports, selfFileId, resolveSpecifier) ?? null;
+            }
+            return null;
+        }
+        const getComp = el.getAttribute('getComponent');
+        if (getComp && getComp.getKind() === SyntaxKind.JsxAttribute) {
+            const init = getComp.getInitializer();
+            if (init && init.getKind() === SyntaxKind.JsxExpression) {
+                const fn = init.getExpression();
+                const ret = fn ? getComponentReturnExpr(fn) : undefined;
+                if (ret)
+                    return resolveComponentRef(ret, imports, selfFileId, resolveSpecifier) ?? null;
+            }
+            return null;
+        }
+        return undefined;
+    };
+    const jsxEls = [
+        ...sf.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+        ...sf.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement),
+    ];
+    for (const el of jsxEls) {
+        const tag = el.getTagNameNode().getText();
+        if (tag.endsWith('.Navigator') || tag === 'Navigator')
+            isNavigator = true;
+        if (!(tag.endsWith('.Screen') || tag === 'Screen'))
+            continue;
+        isNavigator = true;
+        const nameAttr = el.getAttribute('name');
+        if (!nameAttr || nameAttr.getKind() !== SyntaxKind.JsxAttribute)
+            continue;
+        const screenName = resolveScreenName(nameAttr);
+        if (screenName === undefined) {
+            diag.dynamicNames++;
+            continue;
+        }
+        const componentFile = componentFileOf(el);
+        if (componentFile === undefined)
+            continue; // no component/getComponent binding
+        if (componentFile === null) {
+            diag.unresolvedComponents.add(screenName);
+            continue;
+        }
+        register(screenName, componentFile);
+    }
+    // Static config API: createXNavigator({ screens: { Home: HomeScreen, … } }).
+    for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        if (!NAVIGATOR_FACTORIES.has(call.getExpression().getText()))
+            continue;
+        isNavigator = true;
+        const arg = call.getArguments()[0];
+        if (!arg || arg.getKind() !== SyntaxKind.ObjectLiteralExpression)
+            continue;
+        const screensProp = arg.getProperty('screens');
+        if (!screensProp || screensProp.getKind() !== SyntaxKind.PropertyAssignment)
+            continue;
+        const screensInit = screensProp.getInitializer();
+        if (!screensInit || screensInit.getKind() !== SyntaxKind.ObjectLiteralExpression)
+            continue;
+        for (const prop of screensInit.getProperties()) {
+            if (prop.getKind() !== SyntaxKind.PropertyAssignment)
+                continue;
+            const pa = prop;
+            const screenName = staticPropName(pa);
+            if (screenName === undefined) {
+                diag.dynamicNames++;
+                continue;
+            }
+            const init = pa.getInitializer();
+            if (!init)
+                continue;
+            const componentFile = resolveConfigScreenComponent(init, imports, selfFileId, resolveSpecifier);
+            if (componentFile === undefined) {
+                diag.unresolvedComponents.add(screenName);
+                continue;
+            }
+            register(screenName, componentFile);
+        }
+    }
+    return isNavigator;
+}
+// Does this file touch the JS↔native bridge (NativeModules / TurboModules /
+// requireNative*)? Specific patterns only, to avoid false positives.
+function usesNative(sf) {
+    for (const pae of sf.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)) {
+        const base = pae.getExpression();
+        if (base.getKind() === SyntaxKind.Identifier && NATIVE_GLOBALS.has(base.getText()))
+            return true;
+    }
+    for (const eae of sf.getDescendantsOfKind(SyntaxKind.ElementAccessExpression)) {
+        const base = eae.getExpression();
+        if (base.getKind() === SyntaxKind.Identifier && NATIVE_GLOBALS.has(base.getText()))
+            return true;
+    }
+    for (const vd of sf.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+        const init = vd.getInitializer();
+        if (init && init.getKind() === SyntaxKind.Identifier && NATIVE_GLOBALS.has(init.getText()))
+            return true;
+    }
+    for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        if (NATIVE_FUNCS.has(call.getExpression().getText()))
+            return true;
+    }
+    return false;
+}
+function hasJsx(sf) {
+    return (sf.getFirstDescendantByKind(SyntaxKind.JsxElement) !== undefined ||
+        sf.getFirstDescendantByKind(SyntaxKind.JsxSelfClosingElement) !== undefined ||
+        sf.getFirstDescendantByKind(SyntaxKind.JsxFragment) !== undefined);
+}
+// basename without extension: src/hooks/useAuth.ts → 'useAuth'.
+function baseName(fileId) {
+    const last = fileId.split('/').pop() ?? fileId;
+    return last.replace(/\.[^.]+$/, '');
+}
+function inScope(fileId, rootPath) {
+    if (rootPath === '')
+        return true;
+    return fileId === rootPath || fileId.startsWith(`${rootPath}/`);
+}
+// ---------------------------------------------------------------------------
+// feature grouping prior (the deferred "group later").
+//
+// PRIMARY signal: navigator membership — screens registered in one navigator
+// (Stack/Tab/Drawer) belong to ONE feature subsystem, regardless of where their
+// files sit on disk (the headline value: screens grouped by feature, not by
+// directory). The group id derives from the NAVIGATOR FILE name (deterministic +
+// meaningful — RootNavigator → 'root', AuthStack → 'auth'), NEVER an index.
+//
+// that primary signal OVER-COLLAPSES at real scale: production RN apps
+// (Bluesky) register EVERY screen in a SINGLE `Navigation.tsx` (often via tab
+// sub-navigators in one file), so navigator membership yields ONE group for the
+// whole app. The fix is an adaptive per-navigator mode:
+//   * COHESIVE navigator (its screens share ONE feature directory) → keep them
+//     as one group named by the navigator (the AuthStack case, the fixtures).
+//   * MEGA / incoherent navigator (its screens span MANY feature directories) →
+//     the navigator is a routing HUB, not a feature; SPLIT its screens to their
+//     own feature folders (Bluesky's src/screens/<Feature>/… + src/view/screens/
+//     <Feature>.tsx), so a 78-screen app becomes ~dozens of legible features.
+// The cohesion test is the distinct directory-feature count over the navigator's
+// member screens (filename-as-feature is excluded from cohesion so same-directory
+// screens read as cohesive). Logged per mode — no silent cap.
+//
+// FALLBACK: a feature folder for screen/route-family files in NO navigator — the
+// Expo Router case (file-based routing has no navigator). The feature is the
+// first meaningful directory segment under a container root (a route group
+// `(tabs)` → 'tabs'). A root-level file with no determinable feature is LOGGED,
+// never silently dropped (no filename fallback here — that's the SPLIT path).
+//
+// The contribute-step namespaces these as `<adapter>:<id>` (here
+// `react-native:<id>`) and overrides the claimed modules' subsystem, beating the
+// directory heuristic. Fully deterministic (name/path-derived) → no LLM, so no
+// `classificationsNeeded`.
+// Roles whose files are candidates for the feature-folder fallback (screens that
+// somehow escaped navigator membership + the Expo Router route family).
+const FALLBACK_ROLES = new Set(['screen', 'page', 'layout', 'route', 'endpoint']);
+// Directory segments that are CONTAINERS, not features — stripped (repeatedly,
+// outermost-first) before the first real feature segment is read. Covers the
+// common RN/Expo layout roots (src · app · view(s) · screen(s) · scene(s) ·
+// feature(s) · page(s) · modules), so `src/view/screens/Home.tsx` → 'Home' and
+// `src/screens/Messages/ChatList.tsx` → 'Messages'.
+const CONTAINER_DIRS = new Set([
+    'src',
+    'app',
+    'view',
+    'views',
+    'screen',
+    'screens',
+    'scene',
+    'scenes',
+    'feature',
+    'features',
+    'page',
+    'pages',
+    'modules',
+]);
+// Trailing navigator-y suffixes stripped from a navigator file's basename to get
+// a clean feature name (only when something remains).
+const NAV_NAME_SUFFIX = /(Navigators?|Navigation|Nav|Stack|Tabs?|Drawer|Routers?|Routes|Screens)$/;
+// Basenames too generic to name a navigator group — fall back to the parent dir.
+const GENERIC_NAV_BASENAMES = new Set([
+    'index',
+    'navigation',
+    'navigator',
+    'navigators',
+    'routes',
+    'router',
+    'app',
+]);
+// Deterministic slug (camelCase → kebab, drop non-alnum). Mirrors the Nest/infra
+// id discipline so the group id is stable across snapshots.
+function slugify(s) {
+    return s
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+// Humanize a raw name into a subsystem label (split camel/kebab/snake, title-case).
+function humanizeName(s) {
+    const words = s
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/[_\-.]+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean);
+    if (words.length === 0)
+        return s;
+    return words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+}
+// The last directory segment of a file id (the parent dir name); '' at root.
+function parentDirName(fileId) {
+    const segs = fileId.split('/');
+    return segs.length >= 2 ? segs[segs.length - 2] : '';
+}
+// A navigator file's feature name: its basename with a navigator-y suffix
+// stripped; a generic basename (index/navigation/…) falls back to the parent dir.
+function navigatorGroupName(fileId) {
+    let base = baseName(fileId);
+    if (GENERIC_NAV_BASENAMES.has(base.toLowerCase())) {
+        base = parentDirName(fileId) || base;
+    }
+    const stripped = base.replace(NAV_NAME_SUFFIX, '');
+    return stripped.length > 0 ? stripped : base;
+}
+// A screen/route file's feature name. Strips leading CONTAINER segments, then:
+//   * a remaining directory segment is the feature (a route group `(tabs)` →
+//     'tabs');
+//   * if NOTHING remains (the file sits directly in a container, e.g.
+//     `src/view/screens/Home.tsx`) → `allowFilename` decides: the SPLIT path
+//     uses the file basename ('Home'); the Expo fallback path returns undefined
+//     (a root-level route — logged as ungroupable, never silently dropped).
+function deriveFeature(fileId, allowFilename) {
+    const segs = fileId.split('/');
+    const file = segs.pop() ?? fileId;
+    let i = 0;
+    while (i < segs.length && CONTAINER_DIRS.has(segs[i].toLowerCase()))
+        i++;
+    const first = segs[i];
+    if (first) {
+        const stripped = first.replace(/^\((.*)\)$/, '$1'); // route group → bare name
+        if (stripped.length > 0)
+            return stripped;
+    }
+    if (!allowFilename)
+        return undefined;
+    const fn = baseName(file);
+    return fn.length > 0 ? fn : undefined;
+}
+// The directory-only feature key used for the COHESION test (no filename
+// fallback): files in the same container directory share a key, so same-folder
+// screens read as one cohesive feature. A file with no sub-feature directory
+// keys on its container dir path, distinguishing e.g. src/view/screens from
+// src/legacy/screens.
+function featureDirKey(fileId) {
+    const dir = deriveFeature(fileId, false);
+    if (dir)
+        return dir.toLowerCase();
+    const slash = fileId.lastIndexOf('/');
+    return `dir:${slash >= 0 ? fileId.slice(0, slash) : ''}`;
+}
+// Build the grouping prior: per-navigator COHESIVE (one group) vs MEGA (split by
+// feature folder), then a feature-folder fallback for non-navigator screen/route
+// files. Deterministic by construction: sorted inputs, set-union accumulation,
+// sorted output, lexical label tiebreak — so two runs are byte-identical.
+function buildGroupingPrior(navMembership, roles) {
+    const acc = new Map();
+    const add = (id, label, files) => {
+        let g = acc.get(id);
+        if (!g) {
+            g = { label, fileIds: new Set() };
+            acc.set(id, g);
+        }
+        else if (label < g.label) {
+            g.label = label; // deterministic on the (rare) same-id/different-label case
+        }
+        for (const f of files)
+            g.fileIds.add(f);
+    };
+    const claimed = new Set();
+    const ungroupable = [];
+    let keptNavs = 0;
+    let splitNavs = 0;
+    // Assign one screen-ish file to its own feature folder (filename-as-feature
+    // when it sits directly in a container) — the SPLIT path + the mega-navigator's
+    // own file. A file with no determinable feature is logged, never dropped.
+    const splitFile = (f) => {
+        if (claimed.has(f))
+            return;
+        const feat = deriveFeature(f, true);
+        if (!feat) {
+            ungroupable.push(f);
+            return;
+        }
+        const id = slugify(feat) || 'feature';
+        add(id, humanizeName(feat) || id, [f]);
+        claimed.add(f);
+    };
+    // Per-navigator (sorted; first-claim wins so a screen in two navigators is
+    // deterministic). A navigator with NO statically-resolvable screens has nothing
+    // to group → skip (keeps the directory heuristic, not a noisy singleton).
+    for (const navFile of [...navMembership.keys()].sort()) {
+        const members = navMembership.get(navFile);
+        if (members.size === 0)
+            continue;
+        const memberList = [...members].sort();
+        const dirKeys = new Set(memberList.map(featureDirKey));
+        if (dirKeys.size <= 1) {
+            // COHESIVE — the navigator's screens are one feature; keep them together
+            // under the navigator name (defeats the directory heuristic — the headline
+            // value). Only add files not already claimed by an earlier navigator.
+            keptNavs++;
+            const name = navigatorGroupName(navFile);
+            const id = slugify(name) || 'navigator';
+            const fresh = [navFile, ...memberList].filter((f) => !claimed.has(f));
+            if (fresh.length > 0) {
+                add(id, humanizeName(name) || id, fresh);
+                for (const f of fresh)
+                    claimed.add(f);
+            }
+        }
+        else {
+            // MEGA / incoherent — a routing hub spanning many features; distribute its
+            // screens (and the navigator file itself) to their own feature folders.
+            splitNavs++;
+            splitFile(navFile);
+            for (const m of memberList)
+                splitFile(m);
+        }
+    }
+    // Fallback — screen/route-family files in no navigator (Expo Router pages, or
+    // an orphan screen), grouped by feature folder. Root-level files with no
+    // determinable feature are logged (no silent cap; no filename fallback here).
+    for (const fileId of [...roles.keys()].sort()) {
+        if (!FALLBACK_ROLES.has(roles.get(fileId).role))
+            continue;
+        if (claimed.has(fileId))
+            continue;
+        const feature = deriveFeature(fileId, false);
+        if (!feature) {
+            ungroupable.push(fileId);
+            continue;
+        }
+        const id = slugify(feature) || 'feature';
+        add(id, humanizeName(feature) || id, [fileId]);
+        claimed.add(fileId);
+    }
+    const groups = [...acc.entries()]
+        .map(([id, g]) => ({ id, label: g.label, fileIds: [...g.fileIds].sort() }))
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    return { groups, ungroupable, keptNavs, splitNavs };
+}
+function analyzeExpoRouter(repoDir, rootPath) {
+    const tree = extractExpoRouterTree({ repoDir, rootPath });
+    if (!tree)
+        return null;
+    // Route roles. parentFileId + routePath carried as metadata (NOT edges).
+    const roles = new Map();
+    for (const node of tree.routes) {
+        roles.set(node.fileId, {
+            role: node.role,
+            kind: ROLE_KIND[node.role],
+            priority: ROLE_PRIORITY[node.role],
+            metadata: {
+                framework: 'react-native',
+                convention: tree.convention,
+                routePath: node.routePath,
+                ...(node.parentFileId !== undefined ? { parentFileId: node.parentFileId } : {}),
+            },
+        });
+    }
+    // Nav edges → `calls`. The step resolves file ids → modules, drops self-edges,
+    // and dedupes these AGAINST the React-Navigation edges (overlap collapses).
+    const edges = tree.navEdges.map((e) => ({
+        source: e.fromFileId,
+        target: e.toFileId,
+        kind: 'calls',
+        metadata: { framework: 'react-native', convention: tree.convention, relation: 'navigation' },
+    }));
+    return { edges, roles };
+}
+// Mirror of contribute-step.ts beats(): higher priority wins; lexical role
+// tiebreak keeps the pick deterministic regardless of merge/iteration order.
+function roleBeats(incoming, incumbent) {
+    const a = incoming.priority ?? 0;
+    const b = incumbent.priority ?? 0;
+    if (a !== b)
+        return a > b;
+    return incoming.role < incumbent.role;
+}
+// Fold one role map into another, collapsing a per-file collision (a file that
+// matched both a React-Navigation role AND an Expo route role) by roleBeats and
+// recording it for a single aggregated log — no silent pick (constraint 7).
+function mergeRole(into, fileId, tag, collisions) {
+    const cur = into.get(fileId);
+    if (cur === undefined) {
+        into.set(fileId, tag);
+        return;
+    }
+    if (cur.role !== tag.role) {
+        let set = collisions.get(fileId);
+        if (!set) {
+            set = new Set([cur.role]);
+            collisions.set(fileId, set);
+        }
+        set.add(tag.role);
+    }
+    if (roleBeats(tag, cur))
+        into.set(fileId, tag);
+}
+function analyzeReactNative(ctx) {
+    const { repoDir, rootPath, graph } = ctx;
+    const project = buildExtractionProject(repoDir);
+    addAllSourceFiles(project, repoDir);
+    const sourceFiles = project.getSourceFiles();
+    const fileById = new Map();
+    for (const sf of sourceFiles)
+        fileById.set(toId(repoDir, sf.getFilePath()), sf);
+    // Pass 1 — global screen registry + navigator/screen role signals.
+    const registry = new Map(); // screen name → component file id
+    const screenFiles = new Set();
+    const navigatorFiles = new Set();
+    // navigator file id → the set of screen component files it registers
+    // (the navigator-membership grouping signal).
+    const navMembership = new Map();
+    const importMaps = new Map();
+    const idSet = new Set(fileById.keys());
+    const aliasResolve = makeAliasResolver(readAliasPatterns(repoDir), idSet);
+    const resolveSpecifier = makeSpecifierResolver(idSet, aliasResolve);
+    const screenDiag = { dynamicNames: 0, unresolvedComponents: new Set() };
+    for (const [fileId, sf] of fileById) {
+        if (!inScope(fileId, rootPath))
+            continue;
+        const imports = buildImportNameMap(sf, repoDir, aliasResolve);
+        importMaps.set(fileId, imports);
+        const membership = new Set();
+        const navigator = collectScreens(sf, imports, fileId, registry, screenFiles, (spec) => resolveSpecifier(fileId, spec), screenDiag, membership);
+        if (navigator) {
+            navigatorFiles.add(fileId);
+            navMembership.set(fileId, membership);
+        }
+    }
+    // Pass 2 — nav edges from navigate()/push() targets + native boundary files.
+    const navEdges = [];
+    const seenNav = new Set();
+    const nativeFiles = new Set();
+    let dynamicNavTargets = 0;
+    const unresolvedNavTargets = new Set();
+    for (const [fileId, sf] of fileById) {
+        if (!inScope(fileId, rootPath))
+            continue;
+        if (usesNative(sf))
+            nativeFiles.add(fileId);
+        for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+            const callee = call.getExpression();
+            if (callee.getKind() !== SyntaxKind.PropertyAccessExpression)
+                continue;
+            const method = callee.getName();
+            const isLog = NAV_LOG_METHODS.has(method);
+            const isSoft = NAV_SOFT_METHODS.has(method);
+            if (!isLog && !isSoft)
+                continue;
+            const arg = call.getArguments()[0];
+            if (!arg)
+                continue;
+            if (arg.getKind() !== SyntaxKind.StringLiteral) {
+                // Dynamic target — only count it for the nav-unambiguous methods, so
+                // `arr.push(x)` doesn't masquerade as a dropped navigation.
+                if (isLog)
+                    dynamicNavTargets++;
+                continue;
+            }
+            const target = arg.getLiteralValue();
+            const targetFile = registry.get(target);
+            if (!targetFile) {
+                if (isLog)
+                    unresolvedNavTargets.add(target);
+                continue;
+            }
+            const key = `${fileId}→${targetFile}`;
+            if (seenNav.has(key))
+                continue;
+            seenNav.add(key);
+            navEdges.push({ source: fileId, target: targetFile, kind: 'calls', metadata: { framework: 'react-native', relation: 'navigation', screen: target } });
+        }
+    }
+    // Pass 3 — JS↔native bridge edges: importers (from the structural graph) of a
+    // native-boundary file → that file. Native code itself is off-graph (we never
+    // parse ios/android source); the boundary FILE is the JS side of the bridge.
+    const bridgeEdges = [];
+    const seenBridge = new Set();
+    if (nativeFiles.size > 0) {
+        for (const e of graph.edges) {
+            if (e.external)
+                continue;
+            if (!nativeFiles.has(e.to))
+                continue;
+            if (e.from === e.to)
+                continue;
+            const key = `${e.from}→${e.to}`;
+            if (seenBridge.has(key))
+                continue;
+            seenBridge.add(key);
+            bridgeEdges.push({ source: e.from, target: e.to, kind: 'calls', metadata: { framework: 'react-native', relation: 'native-bridge' } });
+        }
+    }
+    // Roles — combine all signals; highest priority per file wins.
+    const roleByFile = new Map();
+    for (const f of navigatorFiles)
+        addRole(roleByFile, f, 'navigator');
+    for (const f of nativeFiles)
+        addRole(roleByFile, f, 'nativeModule');
+    for (const f of screenFiles)
+        addRole(roleByFile, f, 'screen');
+    for (const [fileId, sf] of fileById) {
+        if (!inScope(fileId, rootPath))
+            continue;
+        if (/^use[A-Z0-9]/.test(baseName(fileId)))
+            addRole(roleByFile, fileId, 'hook');
+        if (hasJsx(sf))
+            addRole(roleByFile, fileId, 'component');
+    }
+    const roles = new Map();
+    for (const [fileId, role] of roleByFile)
+        roles.set(fileId, roleTag(role));
+    // Slice B — Expo Router routes. DETECTION-GATED: no `app/`|`src/app/` route dir
+    // ⇒ analyzeExpoRouter returns null ⇒ no route roles/edges ⇒ the Slice-A output
+    // (and a non-Expo repo) is byte-identical. When present, fold the route roles
+    // into the SAME role map — one file can carry a React-Navigation role (Slice A)
+    // AND an Expo route role (Slice B); collapse by priority, record the collision
+    // — and collect the route nav edges into their own bucket (the step dedupes
+    // them against the React-Navigation edges + resolves both to modules).
+    const routeEdges = [];
+    const roleCollisions = new Map();
+    const expo = analyzeExpoRouter(repoDir, rootPath);
+    if (expo) {
+        for (const [fileId, tag] of expo.roles)
+            mergeRole(roles, fileId, tag, roleCollisions);
+        routeEdges.push(...expo.edges);
+    }
+    // Registration summary (a positive signal for validation) + the "no silent
+    // caps" registration diagnostics: screens whose name/component couldn't be
+    // statically resolved (lazy registration recovered, the rest logged).
+    if (navigatorFiles.size > 0 || registry.size > 0) {
+        console.log(`  [react-native] registered ${registry.size} screen(s) across ${navigatorFiles.size} navigator file(s)`);
+    }
+    if (screenDiag.dynamicNames > 0 || screenDiag.unresolvedComponents.size > 0) {
+        const parts = [];
+        if (screenDiag.dynamicNames > 0)
+            parts.push(`${screenDiag.dynamicNames} dynamic screen name(s)`);
+        if (screenDiag.unresolvedComponents.size > 0) {
+            parts.push(`${screenDiag.unresolvedComponents.size} screen(s) with an unresolvable component: ${[...screenDiag.unresolvedComponents].sort().join(', ')}`);
+        }
+        console.log(`  [react-native] registration skipped ${parts.join(' · ')} (logged, not silently dropped)`);
+    }
+    // No silent caps ( constraint 7): log dropped/unresolved targets once.
+    if (dynamicNavTargets > 0 || unresolvedNavTargets.size > 0) {
+        const parts = [];
+        if (dynamicNavTargets > 0)
+            parts.push(`${dynamicNavTargets} dynamic target(s)`);
+        if (unresolvedNavTargets.size > 0) {
+            parts.push(`${unresolvedNavTargets.size} unregistered target(s): ${[...unresolvedNavTargets].sort().join(', ')}`);
+        }
+        console.log(`  [react-native] skipped ${parts.join(' · ')} (logged, not silently dropped)`);
+    }
+    // No silent caps: a file that matched BOTH a React-Navigation role AND an Expo
+    // route role had them collapsed by priority — report each (roles seen + winner),
+    // never a silent pick. (The contribute-step logs the analogous per-MODULE
+    // collapse after file→module resolution; this is the per-FILE collapse.)
+    if (roleCollisions.size > 0) {
+        const sample = [...roleCollisions.entries()]
+            .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+            .slice(0, 10)
+            .map(([fileId, set]) => `${fileId} {${[...set].sort().join(', ')}} → kept '${roles.get(fileId)?.role}'`);
+        console.log(`  [react-native] ${roleCollisions.size} file(s) matched both a React-Navigation and an Expo Router role (collapsed by priority): ${sample.join(' · ')}` +
+            (roleCollisions.size > sample.length ? ' …' : ''));
+    }
+    // the feature grouping prior (navigator membership + feature-folder
+    // fallback). Built from the final role map (so the fallback sees every role).
+    const { groups, ungroupable, keptNavs, splitNavs } = buildGroupingPrior(navMembership, roles);
+    if (groups.length > 0) {
+        console.log(`  [react-native] grouped into ${groups.length} feature subsystem(s) from ${navMembership.size} navigator file(s) ` +
+            `(${keptNavs} cohesive navigator group(s) + ${splitNavs} mega-navigator(s) split by feature folder + feature-folder fallback)`);
+    }
+    if (ungroupable.length > 0) {
+        const sample = [...ungroupable].sort().slice(0, 10);
+        console.log(`  [react-native] ${ungroupable.length} screen/route file(s) had no determinable feature folder (not grouped): ${sample.join(', ')}` +
+            (ungroupable.length > sample.length ? ' …' : ''));
+    }
+    // Deterministic ordering — module-id resolution + dedupe downstream rely on a
+    // stable input order; sort by endpoints.
+    const byEndpoints = (a, b) => a.source < b.source ? -1 : a.source > b.source ? 1 : a.target < b.target ? -1 : a.target > b.target ? 1 : 0;
+    navEdges.sort(byEndpoints);
+    bridgeEdges.sort(byEndpoints);
+    routeEdges.sort(byEndpoints);
+    return { navEdges, bridgeEdges, routeEdges, roles, groups };
+}
+function getAnalysis(ctx) {
+    let a = ANALYSIS_CACHE.get(ctx);
+    if (!a) {
+        a = analyzeReactNative(ctx);
+        ANALYSIS_CACHE.set(ctx, a);
+    }
+    return a;
+}
+// ---------------------------------------------------------------------------
+// The adapter.
+export const reactNativeAdapter = {
+    name: 'react-native',
+    async detect(ctx) {
+        // Thin single-root pass: scan the workspace package when given, else the
+        // repo root (per-package fan-out is ). rootPath is the repo-relative
+        // posix path of that base ('' for the repo root).
+        const base = ctx.packageDir ?? ctx.repoDir;
+        const rootPath = ctx.packageDir
+            ? relative(ctx.repoDir, ctx.packageDir).split('\\').join('/')
+            : '';
+        return scoreReactNative(gatherReactNativeSignals(base), rootPath);
+    },
+    // the feature grouping prior: navigator membership (primary) +
+    // feature-folder fallback. The contribute-step namespaces each group
+    // `react-native:<id>` and overrides the claimed modules' subsystem, beating the
+    // directory heuristic (screens grouped by feature, not by folder). Deterministic
+    // (name/path-derived) → no classificationsNeeded (the deferred-LLM channel stays
+    // empty, preserving the zero-LLM property).
+    async groupingPrior(ctx) {
+        return { groups: getAnalysis(ctx).groups };
+    },
+    // the navigation graph + JS↔native boundary (file-id space; the
+    // contribution step resolves to modules). kind 'calls' only.
+    async syntheticEdges(ctx) {
+        const a = getAnalysis(ctx);
+        // React-Navigation nav + JS↔native bridge (Slice A) + Expo Router route nav
+        // (Slice B). All `calls`, file-id endpoints; the step dedupes the union.
+        return [...a.navEdges, ...a.bridgeEdges, ...a.routeEdges];
+    },
+    async roleTags(ctx) {
+        return getAnalysis(ctx).roles;
+    },
+    // The hooks READ SOURCE — React-Navigation navigator config + navigate() calls
+    // + NativeModules usage (Slice A), AND the Expo Router `app/` route files +
+    // their <Link href>/router.push() nav targets (Slice B) — so declare the
+    // source paths the diff-driven hosted walk must treat as framework-relevant.
+    // Every Expo route file is a source file (.ts/.tsx/.js/.jsx, incl. `+api.ts`),
+    // so the source-extension test already covers them. Never-store-source holds:
+    // read server-side, persist only derived edges/roles.
+    scansSourcePath(path) {
+        const ext = path.split('.').pop();
+        return ext !== undefined && SOURCE_EXT_SET.has(ext);
+    },
+};
+//# sourceMappingURL=react-native.js.map