diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1ce847c4..3e963792 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -169,6 +169,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - In TypeScript and JavaScript, a call on a value another file exports, like `store.add(…)` after `import { store } from './state'` with `export const store = new Store()` there, now links to the method of the class that file imports or declares when other classes in the project share its name, in Vue, Svelte and Astro components too. Before, it linked to whichever of them was indexed first: in vscode, calls on `FileAccess`, `extUri`, `errorHandler` and `MenuRegistry` reached the copies the Copilot extension vendors or one of its test fixtures, and in folo the mobile app's `settingSyncQueue.init()` reached the desktop app's `SettingSyncQueue`. Re-index TypeScript and JavaScript projects after upgrading.
 - In TypeScript, a call through a field that a wrapper sets up, like `this._onDidChange.fire()` after `private readonly _onDidChange = this._register(new Emitter<void>())` or `= this._store.add(new Emitter<void>())`, now links to the method of the class handed to the wrapper, also in a class that inherits the field. Before, such a field had no type, so its calls linked nowhere, and that is one of the most common ways vscode declares its event emitters and disposables. A wrapper counts only when its own declaration hands back what it is given, like `_register<T>(o: T): T`, so a field set from a wrapper that returns something else, or from a member of what it returns (`.event`), is never taken for the class. A call through an inherited field is also found now when the field is declared further up the class hierarchy than before. Re-index TypeScript projects after upgrading.
 - In TypeScript and JavaScript, a class whose declaration constrains a type parameter, like `class EditorPane<MementoType extends object = object> extends Composite<MementoType>`, is now read as extending the class after its type parameters. Before, the constraint's type was taken for its base class, so fields, wrapped event emitters and static methods inherited through such a class were missed or found on the wrong class. Class declarations that span several lines or sit below a decorator are read too. Re-index TypeScript and JavaScript projects after upgrading.
+- In JavaScript and TypeScript, an import written from a jsconfig or tsconfig `baseUrl`, like `import MainLayout from 'layout/MainLayout'` under `"baseUrl": "src"`, or through a catch-all `"paths": { "*": ["./src/*"] }`, now links to the file it names, read with the config of the app the importing file belongs to, and so does an import of a single name like `'config'` or `'themes'`. Create React App and Vite admin templates such as Berry, Mantis and MatX write nearly every import this way. Before, each one was taken for an npm package, so it linked nothing, its names were matched by name alone, which could reach a same-named component in another app of the same repository, and a React Router route whose page loads through `lazy(() => import('views/dashboard/Default'))` pointed at that loader instead of the page and its layout. A package the app's `package.json` declares, or a Node built-in, never links to a project module of the same name, only to type declarations the project keeps for it, and only a file the index holds counts, never a folder or something in `node_modules`. `codegraph sync` and the file watcher link such an import too when the file it names is added later or gains what it imports. Re-index JavaScript and TypeScript projects after upgrading.
 
 ## [1.6.2] - 2026-10-03
 
diff --git a/__tests__/tsconfig-baseurl-imports.test.ts b/__tests__/tsconfig-baseurl-imports.test.ts
new file mode 100644
index 00000000..47e2ebad
--- /dev/null
+++ b/__tests__/tsconfig-baseurl-imports.test.ts
@@ -0,0 +1,447 @@
+/**
+ * Bare specifiers that name a project file through the importing app's own
+ * tsconfig / jsconfig: a `baseUrl` with no `paths` (berry, matx) or a
+ * catch-all `"*": ["./src/*"]` (mantis). CRA and Vite admin templates write
+ * nearly every cross-file import this way (`import MainLayout from
+ * 'layout/MainLayout'`), and each one used to be taken for an npm package:
+ * the import stayed unresolved and its names linked by bare-name matching,
+ * often into another app of the same repository.
+ *
+ * Locked in:
+ *  - the importing app's own config decides (two apps, two baseUrls)
+ *  - only an indexed file binds; a specifier that names none stays unresolved
+ *  - a package the app's package.json declares, or a Node built-in, never
+ *    binds to a same-named project folder or file, also under a root `"*"`
+ *  - a route's `lazy(() => import('views/x'))` renders `views/x/index.jsx`,
+ *    and the layout around it links through the same kind of import
+ *  - a class extending one imported this way keeps its `extends` edge
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { CodeGraph } from '../src';
+import { resolveImportPath } from '../src/resolution/import-resolver';
+import type { AliasMap } from '../src/resolution/path-aliases';
+import type { ResolutionContext } from '../src/resolution';
+
+const ROOT = path.join(os.tmpdir(), 'cg-baseurl-stub');
+
+function stubContext(files: string[], opts: {
+  nearest?: (fromFile: string) => AliasMap | null;
+  project?: AliasMap | null;
+  declared?: string[];
+  noPackageCheck?: boolean;
+}): ResolutionContext {
+  const set = new Set(files);
+  return {
+    getNodesInFile: () => [],
+    getNodesByName: () => [],
+    getNodesByQualifiedName: () => [],
+    getNodesByKind: () => [],
+    fileExists: (p: string) => set.has(p),
+    readFile: () => null,
+    getProjectRoot: () => ROOT,
+    getAllFiles: () => files,
+    getImportMappings: () => [],
+    getNearestAliases: opts.nearest ?? (() => null),
+    getProjectAliases: () => opts.project ?? null,
+    ...(opts.noPackageCheck ? {} : { isDeclaredPackage: (source: string) => (opts.declared ?? []).includes(source.split('/')[0]!) }),
+  } as unknown as ResolutionContext;
+}
+
+const baseUrlOnly = (dir: string): AliasMap => ({ baseUrl: path.join(ROOT, dir), declaresBaseUrl: true, patterns: [] });
+
+describe('resolving a bare specifier through the app’s own config', () => {
+  it('reads a nested app’s baseUrl, down to an index.jsx (berry)', () => {
+    const files = ['vite/src/routes/MainRoutes.jsx', 'vite/src/layout/MainLayout/index.jsx', 'vite/src/views/dashboard/Default/index.jsx'];
+    const ctx = stubContext(files, { nearest: (f) => (f.startsWith('vite/') ? baseUrlOnly('vite/src') : null) });
+    expect(resolveImportPath('layout/MainLayout', 'vite/src/routes/MainRoutes.jsx', 'jsx', ctx)).toBe('vite/src/layout/MainLayout/index.jsx');
+    // A route table resolves a lazily loaded module as TypeScript, whatever it is written in.
+    expect(resolveImportPath('views/dashboard/Default', 'vite/src/routes/MainRoutes.jsx', 'typescript', ctx)).toBe('vite/src/views/dashboard/Default/index.jsx');
+  });
+
+  it('reads a catch-all "*" from the config’s directory (mantis)', () => {
+    const star: AliasMap = {
+      baseUrl: path.join(ROOT, 'vite'),
+      declaresBaseUrl: false,
+      patterns: [{ prefix: '', suffix: '', hasWildcard: true, replacements: ['./src/*'] }],
+    };
+    const ctx = stubContext(['vite/src/routes/LoginRoutes.jsx', 'vite/src/pages/auth/Register.jsx'], { nearest: () => star });
+    expect(resolveImportPath('pages/auth/Register', 'vite/src/routes/LoginRoutes.jsx', 'jsx', ctx)).toBe('vite/src/pages/auth/Register.jsx');
+  });
+
+  it('reads the root jsconfig when no nearer config has one (matx)', () => {
+    const ctx = stubContext(['src/app/routes.jsx', 'src/app/views/dashboard/Analytics.jsx'], { project: baseUrlOnly('src') });
+    expect(resolveImportPath('app/views/dashboard/Analytics', 'src/app/routes.jsx', 'jsx', ctx)).toBe('src/app/views/dashboard/Analytics.jsx');
+  });
+
+  it('uses the importing app’s baseUrl, not another app’s', () => {
+    const files = ['vite/src/views/Page.jsx', 'vite/src/utils/format.js', 'remix/app/routes/index.jsx', 'remix/app/utils/format.js'];
+    const ctx = stubContext(files, {
+      nearest: (f) => (f.startsWith('vite/') ? baseUrlOnly('vite/src') : f.startsWith('remix/') ? baseUrlOnly('remix/app') : null),
+    });
+    expect(resolveImportPath('utils/format', 'vite/src/views/Page.jsx', 'jsx', ctx)).toBe('vite/src/utils/format.js');
+    expect(resolveImportPath('utils/format', 'remix/app/routes/index.jsx', 'jsx', ctx)).toBe('remix/app/utils/format.js');
+  });
+
+  it('never binds a declared package to a same-named project folder', () => {
+    const files = ['src/hooks/useSearch.js', 'src/lodash/index.js'];
+    expect(resolveImportPath('lodash', 'src/hooks/useSearch.js', 'javascript', stubContext(files, { project: baseUrlOnly('src'), declared: ['lodash'] }))).toBeNull();
+    // Only the declaration keeps it out: the same folder is the project's when nothing declares `lodash`.
+    expect(resolveImportPath('lodash', 'src/hooks/useSearch.js', 'javascript', stubContext(files, { project: baseUrlOnly('src') }))).toBe('src/lodash/index.js');
+    // A context that cannot tell packages apart resolves nothing this way.
+    expect(resolveImportPath('lodash', 'src/hooks/useSearch.js', 'javascript', stubContext(files, { project: baseUrlOnly('src'), noPackageCheck: true }))).toBeNull();
+  });
+
+  it('lets a declared package reach a declaration file the project keeps for it, never a module', () => {
+    // cord-field's shape: `"*": ["./typings/*"]` holds types for untyped packages.
+    const typings: AliasMap = {
+      baseUrl: path.join(ROOT, 'src'),
+      declaresBaseUrl: true,
+      patterns: [{ prefix: '', suffix: '', hasWildcard: true, replacements: ['./typings/*'] }],
+    };
+    const files = ['src/scenes/Page.tsx', 'src/typings/legacy-widgets.d.ts', 'src/axios/index.ts'];
+    const ctx = stubContext(files, { project: typings, declared: ['legacy-widgets', 'axios'] });
+    expect(resolveImportPath('legacy-widgets', 'src/scenes/Page.tsx', 'tsx', ctx)).toBe('src/typings/legacy-widgets.d.ts');
+    // `baseUrl` reads `src/axios/index.ts`, the app's own wrapper: the package stays the package.
+    expect(resolveImportPath('axios', 'src/scenes/Page.tsx', 'tsx', ctx)).toBeNull();
+  });
+
+  it('leaves a specifier that names no project file unresolved', () => {
+    const ctx = stubContext(['src/App.jsx'], { project: baseUrlOnly('src') });
+    expect(resolveImportPath('react', 'src/App.jsx', 'jsx', ctx)).toBeNull();
+    expect(resolveImportPath('virtual:pwa-register', 'src/App.jsx', 'jsx', ctx)).toBeNull();
+  });
+
+  it('binds only a file the index holds, not a folder or node_modules on disk', () => {
+    // `fileExists` falls back to the disk: true for `src/assets` (a folder) and
+    // for a package installed under a `"*"` target like `node_modules/*`.
+    const onDisk = new Set(['src/App.jsx', 'src/assets', 'node_modules/history/index.js']);
+    const indexed = new Set(['src/App.jsx']);
+    const star: AliasMap = {
+      baseUrl: ROOT,
+      declaresBaseUrl: true,
+      patterns: [{ prefix: '', suffix: '', hasWildcard: true, replacements: ['src/*', 'node_modules/*'] }],
+    };
+    const ctx = {
+      ...stubContext([...indexed], { project: star }),
+      fileExists: (p: string) => onDisk.has(p),
+      isIndexedFile: (p: string) => indexed.has(p),
+    } as unknown as ResolutionContext;
+    expect(resolveImportPath('assets', 'src/App.jsx', 'jsx', ctx)).toBeNull();
+    expect(resolveImportPath('history', 'src/App.jsx', 'jsx', ctx)).toBeNull();
+  });
+
+  it('does not read bare specifiers from a config with paths but no baseUrl', () => {
+    const atOnly: AliasMap = {
+      baseUrl: ROOT,
+      declaresBaseUrl: false,
+      patterns: [{ prefix: '@/', suffix: '', hasWildcard: true, replacements: ['./src/*'] }],
+    };
+    const ctx = stubContext(['src/App.jsx', 'components/Button.jsx', 'src/components/Button.jsx'], { project: atOnly });
+    expect(resolveImportPath('components/Button', 'src/App.jsx', 'jsx', ctx)).toBeNull();
+    expect(resolveImportPath('@/components/Button', 'src/App.jsx', 'jsx', ctx)).toBe('src/components/Button.jsx');
+  });
+});
+
+function writeTree(root: string, files: Record<string, string>): void {
+  for (const [rel, content] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+    fs.writeFileSync(path.join(root, rel), content);
+  }
+}
+
+describe('two admin apps with their own baseUrl (berry shape)', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-baseurl-apps-'));
+    writeTree(root, {
+      'package.json': JSON.stringify({ name: 'admin-templates', private: true }),
+      'vite/package.json': JSON.stringify({ name: 'vite-app', dependencies: { react: '^18', 'react-router-dom': '^6', lodash: '^4' } }),
+      'vite/jsconfig.json': JSON.stringify({ compilerOptions: { baseUrl: 'src', jsx: 'react-jsx' } }),
+      'vite/src/routes/index.jsx': `import { createBrowserRouter } from 'react-router-dom';
+import MainRoutes from './MainRoutes';
+
+const router = createBrowserRouter([MainRoutes]);
+
+export default router;
+`,
+      'vite/src/routes/MainRoutes.jsx': `import { lazy } from 'react';
+
+import MainLayout from 'layout/MainLayout';
+import Loadable from 'ui-component/Loadable';
+
+const DashboardDefault = Loadable(lazy(() => import('views/dashboard/Default')));
+
+const MainRoutes = {
+  path: '/',
+  element: <MainLayout />,
+  children: [
+    {
+      path: 'dashboard',
+      element: <DashboardDefault />
+    }
+  ]
+};
+
+export default MainRoutes;
+`,
+      'vite/src/layout/MainLayout/index.jsx': `export default function MainLayout() {
+  return <main />;
+}
+`,
+      'vite/src/ui-component/Loadable.jsx': `export default function Loadable(Component) {
+  return (props) => <Component {...props} />;
+}
+`,
+      'vite/src/views/dashboard/Default/index.jsx': `import { formatDate } from 'utils/format';
+
+export default function Dashboard() {
+  return <section>{formatDate(new Date())}</section>;
+}
+`,
+      'vite/src/utils/format.js': `export function formatDate(d) {
+  return String(d);
+}
+`,
+      // A one-segment specifier, and a binding named like another module.
+      'vite/src/config.js': `export const DEFAULT_THEME_MODE = 'system';
+export const themes = ['light', 'dark'];
+`,
+      'vite/src/themes/index.jsx': `export default function ThemeCustomization({ children }) {
+  return children;
+}
+`,
+      'vite/src/layout/Customization/index.jsx': `import { DEFAULT_THEME_MODE, themes } from 'config';
+
+export default function Customization() {
+  return themes.includes(DEFAULT_THEME_MODE);
+}
+`,
+      // A folder named like a dependency, and a file named like a Node built-in.
+      'vite/src/lodash/index.js': `export function debounce(fn) {
+  return fn;
+}
+`,
+      'vite/src/events.js': `export class EventEmitter {}
+`,
+      'vite/src/hooks/useSearch.js': `import { debounce } from 'lodash';
+import { EventEmitter } from 'events';
+
+export function useSearch() {
+  return debounce(() => new EventEmitter());
+}
+`,
+      'vite/src/components/BasePanel.js': `export default class BasePanel {}
+`,
+      'vite/src/components/Panel.js': `import BasePanel from 'components/BasePanel';
+
+export class Panel extends BasePanel {}
+`,
+      'remix/package.json': JSON.stringify({ name: 'remix-app', dependencies: { react: '^18' } }),
+      'remix/jsconfig.json': JSON.stringify({ compilerOptions: { baseUrl: 'app' } }),
+      'remix/app/utils/format.js': `export function formatDate(d) {
+  return d.toISOString();
+}
+`,
+      'remix/app/routes/index.jsx': `import { formatDate } from 'utils/format';
+
+export default function Index() {
+  return formatDate(new Date());
+}
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true, maxRetries: 5 });
+  });
+
+  /** The files `file`'s nodes import, by path. */
+  const importedFiles = (file: string): string[] =>
+    cg.getOutgoingEdgesFrom(cg.getNodesInFile(file).map((n) => n.id))
+      .filter((e) => e.kind === 'imports')
+      .map((e) => cg.getNode(e.target)!.filePath);
+
+  /** What `file`'s import of `ref` (a module specifier or a binding) links to, as `kind:name@path`. */
+  const importTargets = (file: string, ref: string): string[] =>
+    cg.getOutgoingEdgesFrom(cg.getNodesInFile(file).map((n) => n.id))
+      .filter((e) => e.kind === 'imports' && (e.metadata as Record<string, unknown> | undefined)?.refName === ref)
+      .map((e) => `${cg.getNode(e.target)!.kind}:${cg.getNode(e.target)!.name}@${cg.getNode(e.target)!.filePath}`);
+
+  const routeLinks = (name: string, layout: boolean): string[] => {
+    const route = cg.getNodesByKind('route').find((r) => r.name === name);
+    if (!route) return [];
+    return cg.getOutgoingEdges(route.id)
+      .filter((e) => e.kind === 'references' && Boolean((e.metadata as Record<string, unknown> | undefined)?.layout) === layout)
+      .map((e) => `${cg.getNode(e.target)!.name}@${cg.getNode(e.target)!.filePath}`);
+  };
+
+  it('links an import written from baseUrl to the file it names', () => {
+    const file = 'vite/src/routes/MainRoutes.jsx';
+    expect(importTargets(file, 'layout/MainLayout')).toEqual(['file:index.jsx@vite/src/layout/MainLayout/index.jsx']);
+    expect(importTargets(file, 'ui-component/Loadable')).toEqual(['file:Loadable.jsx@vite/src/ui-component/Loadable.jsx']);
+  });
+
+  it('links a one-segment module, and reads a binding named like another module as the binding', () => {
+    const file = 'vite/src/layout/Customization/index.jsx';
+    expect(importTargets(file, 'config')).toEqual(['file:config.js@vite/src/config.js']);
+    expect(importTargets(file, 'themes')).toEqual(['constant:themes@vite/src/config.js']);
+    expect(importedFiles(file)).not.toContain('vite/src/themes/index.jsx');
+  });
+
+  it('calls the importing app’s own function, not the other app’s namesake', () => {
+    const callees = (fn: string, file: string) => {
+      const node = cg.getNodesInFile(file).find((n) => n.name === fn)!;
+      return cg.getCallees(node.id).map((c) => c.node.filePath);
+    };
+    expect(callees('Dashboard', 'vite/src/views/dashboard/Default/index.jsx')).toContain('vite/src/utils/format.js');
+    expect(callees('Dashboard', 'vite/src/views/dashboard/Default/index.jsx')).not.toContain('remix/app/utils/format.js');
+    expect(callees('Index', 'remix/app/routes/index.jsx')).toContain('remix/app/utils/format.js');
+    expect(callees('Index', 'remix/app/routes/index.jsx')).not.toContain('vite/src/utils/format.js');
+  });
+
+  it('renders a lazily loaded page and the layout around it', () => {
+    expect(routeLinks('/dashboard', false)).toEqual(['Dashboard@vite/src/views/dashboard/Default/index.jsx']);
+    expect(routeLinks('/dashboard', true)).toEqual(['MainLayout@vite/src/layout/MainLayout/index.jsx']);
+  });
+
+  it('keeps a declared package and a Node built-in out of same-named project files', () => {
+    const imported = importedFiles('vite/src/hooks/useSearch.js');
+    expect(imported).not.toContain('vite/src/lodash/index.js');
+    expect(imported).not.toContain('vite/src/events.js');
+  });
+
+  it('keeps the extends edge of a class whose base is imported from baseUrl', () => {
+    const panel = cg.getNodesInFile('vite/src/components/Panel.js').find((n) => n.name === 'Panel')!;
+    const supers = cg.getOutgoingEdges(panel.id).filter((e) => e.kind === 'extends').map((e) => cg.getNode(e.target)!.filePath);
+    expect(supers).toEqual(['vite/src/components/BasePanel.js']);
+  });
+});
+
+describe('a root catch-all "*" beside a folder named like a dependency', () => {
+  let root = '';
+  let cg: CodeGraph;
+
+  beforeAll(async () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-baseurl-star-'));
+    writeTree(root, {
+      'package.json': JSON.stringify({ name: 'star-app', dependencies: { axios: '^1', react: '^18' } }),
+      'jsconfig.json': JSON.stringify({ compilerOptions: { paths: { '*': ['./src/*'] } } }),
+      // The app's own configured client, in a folder named after the package it wraps.
+      'src/axios/index.js': `import axios from 'axios';
+
+const instance = axios.create({ baseURL: '/api' });
+
+export default instance;
+`,
+      'src/components/Button.jsx': `export default function Button() {
+  return <button />;
+}
+`,
+      'src/App.jsx': `import axios from 'axios';
+import Button from 'components/Button';
+
+export default function App() {
+  axios.get('/users');
+  return <Button />;
+}
+`,
+    });
+    cg = await CodeGraph.init(root, { index: true });
+  });
+
+  afterAll(() => {
+    cg?.close();
+    if (root) fs.rmSync(root, { recursive: true, force: true, maxRetries: 5 });
+  });
+
+  it('resolves the project’s own module and leaves the dependency alone', () => {
+    const ids = cg.getNodesInFile('src/App.jsx').map((n) => n.id);
+    const targets = cg.getOutgoingEdgesFrom(ids).map((e) => cg.getNode(e.target)!.filePath);
+    expect(targets).toContain('src/components/Button.jsx');
+    expect(targets).not.toContain('src/axios/index.js');
+  });
+});
+
+/** What a sync must link once a module imported from `baseUrl` appears after its importers. */
+const SYNC_IMPORTERS: Record<string, string> = {
+  'package.json': JSON.stringify({ name: 'late-app', dependencies: { react: '^18' } }),
+  'jsconfig.json': JSON.stringify({ compilerOptions: { baseUrl: 'src' } }),
+  // Bindings their modules never declare by that name: a default import, an
+  // aliased import, a member of a named import, and a one-segment module.
+  'src/call.js': "import runIt from 'handlers/run';\nexport function go() { return runIt(); }\n",
+  'src/draw.js': "import { Widget as W } from 'widgets/Widget';\nexport function paint() { return new W(); }\n",
+  'src/read.js': "import { store } from 'state/store';\nexport function read(k) { return store.get(k); }\n",
+  'src/use-config.js': "import config from 'config';\nexport const port = config.port;\n",
+};
+const SYNC_MODULES: Record<string, string> = {
+  'src/handlers/run.js': 'export default function handle() { return 1; }\n',
+  'src/widgets/Widget.js': 'export class Widget {}\n',
+  'src/state/store.js': 'export const store = { get(k) { return k; } };\n',
+  'src/config.js': 'const config = { port: 3000 };\nexport default config;\n',
+};
+
+describe('a sync links an import read from baseUrl once its module appears', () => {
+  const roots: string[] = [];
+  const graphs: CodeGraph[] = [];
+
+  afterAll(() => {
+    for (const graph of graphs) graph.close();
+    for (const dir of roots) fs.rmSync(dir, { recursive: true, force: true, maxRetries: 5 });
+  });
+
+  const indexed = async (files: Record<string, string>): Promise<{ root: string; cg: CodeGraph }> => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-baseurl-sync-'));
+    roots.push(root);
+    writeTree(root, files);
+    const cg = await CodeGraph.init(root, { index: true });
+    graphs.push(cg);
+    return { root, cg };
+  };
+
+  /** Every edge by its ends' natural keys, where it is written and how it resolved. */
+  const edgesOf = (cg: CodeGraph): string[] => {
+    const keys = new Map(
+      cg.getFiles()
+        .flatMap((file) => cg.getNodesInFile(file.path))
+        .map((n) => [n.id, `${n.kind} ${n.filePath}:${n.qualifiedName}:${n.startLine}`] as const)
+    );
+    return cg.getOutgoingEdgesFrom([...keys.keys()])
+      .map((e) => `${e.kind} ${keys.get(e.source)} -> ${keys.get(e.target) ?? e.target} @${e.line}:${e.column} ${JSON.stringify(e.metadata ?? {})}`)
+      .sort();
+  };
+
+  it('matches a fresh index of the same files', async () => {
+    const { root, cg } = await indexed(SYNC_IMPORTERS);
+    writeTree(root, SYNC_MODULES);
+    const result = await cg.sync();
+    expect(result.filesAdded).toBe(Object.keys(SYNC_MODULES).length);
+    expect(result.filesModified).toBe(0);
+
+    const fresh = await indexed({ ...SYNC_IMPORTERS, ...SYNC_MODULES });
+    const freshEdges = edgesOf(fresh.cg);
+    // The fresh index links every binding through its module.
+    expect(freshEdges.some((e) => e.startsWith('calls function src/call.js:go') && e.includes('-> function src/handlers/run.js:handle'))).toBe(true);
+    expect(freshEdges.some((e) => e.startsWith('instantiates function src/draw.js:paint') && e.includes('-> class src/widgets/Widget.js:Widget'))).toBe(true);
+    expect(freshEdges.some((e) => e.includes('src/use-config.js') && e.includes('-> file src/config.js'))).toBe(true);
+    expect(edgesOf(cg)).toEqual(freshEdges);
+  }, 120_000);
+
+  it('matches a fresh index when an edit gives the module what its importers import', async () => {
+    const stubs = Object.fromEntries(Object.keys(SYNC_MODULES).map((file) => [file, 'export const placeholder = 1;\n']));
+    const { root, cg } = await indexed({ ...SYNC_IMPORTERS, ...stubs });
+    writeTree(root, SYNC_MODULES);
+    const result = await cg.sync();
+    expect(result.filesModified).toBe(Object.keys(SYNC_MODULES).length);
+    expect(result.filesAdded).toBe(0);
+
+    const fresh = await indexed({ ...SYNC_IMPORTERS, ...SYNC_MODULES });
+    expect(edgesOf(cg)).toEqual(edgesOf(fresh.cg));
+  }, 120_000);
+});
diff --git a/__tests__/tsconfig-extends-aliases.test.ts b/__tests__/tsconfig-extends-aliases.test.ts
index 8010c081..2277e1cd 100644
--- a/__tests__/tsconfig-extends-aliases.test.ts
+++ b/__tests__/tsconfig-extends-aliases.test.ts
@@ -18,12 +18,14 @@
  *  - the nearest config wins: a child's own `paths` replaces (not merges with)
  *    the parent's, which is what `tsc` does
  *  - a cyclic `extends` terminates instead of blowing the stack
+ *  - a `baseUrl` with no `paths` still loads, and only a declared `baseUrl`
+ *    reads a bare specifier from its directory
  */
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { loadProjectAliases, applyAliases } from '../src/resolution/path-aliases';
+import { loadProjectAliases, applyAliases, aliasAndBaseUrlCandidates } from '../src/resolution/path-aliases';
 
 function write(file: string, content: unknown): void {
   fs.mkdirSync(path.dirname(file), { recursive: true });
@@ -180,3 +182,63 @@ describe('tsconfig `extends` chains (#1534)', () => {
     expect(loadProjectAliases(root)).toBeNull();
   });
 });
+
+describe('a baseUrl with no paths', () => {
+  let root: string;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'cg-tsbaseurl-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it('loads a jsconfig that sets only baseUrl (CRA / Vite admin templates)', () => {
+    write(path.join(root, 'jsconfig.json'), { compilerOptions: { baseUrl: 'src' } });
+
+    const aliases = loadProjectAliases(root);
+    expect(aliases).not.toBeNull();
+    expect(aliases!.patterns).toEqual([]);
+    expect(aliases!.declaresBaseUrl).toBe(true);
+    expect(aliasAndBaseUrlCandidates('layout/MainLayout', aliases!, root)).toEqual(['src/layout/MainLayout']);
+  });
+
+  it('takes a baseUrl inherited through extends, relative to the file that set it', () => {
+    write(path.join(root, 'config/tsconfig.base.json'), { compilerOptions: { baseUrl: '../src' } });
+    write(path.join(root, 'tsconfig.json'), { extends: './config/tsconfig.base.json' });
+
+    const aliases = loadProjectAliases(root);
+    expect(aliases?.declaresBaseUrl).toBe(true);
+    expect(aliasAndBaseUrlCandidates('utils/format', aliases!, root)).toEqual(['src/utils/format']);
+  });
+
+  it('tries the most specific paths pattern before baseUrl', () => {
+    write(path.join(root, 'tsconfig.json'), {
+      compilerOptions: { baseUrl: '.', paths: { 'shared/*': ['libs/shared/src/*'] } },
+    });
+
+    const aliases = loadProjectAliases(root);
+    expect(aliasAndBaseUrlCandidates('shared/date', aliases!, root)).toEqual(['libs/shared/src/date', 'shared/date']);
+    expect(aliasAndBaseUrlCandidates('components/Button', aliases!, root)).toEqual(['components/Button']);
+  });
+
+  it('reads a catch-all "*" pattern without a baseUrl, but nothing else from the config directory', () => {
+    // mantis-free-react-admin-template's vite/jsconfig.json: `paths` alone,
+    // anchored at the config's own directory (TypeScript 4.1+).
+    write(path.join(root, 'jsconfig.json'), { compilerOptions: { paths: { '*': ['./src/*'] } } });
+
+    const aliases = loadProjectAliases(root);
+    expect(aliases?.declaresBaseUrl).toBe(false);
+    expect(aliasAndBaseUrlCandidates('pages/auth/Register', aliases!, root)).toEqual(['src/pages/auth/Register']);
+
+    write(path.join(root, 'jsconfig.json'), { compilerOptions: { paths: { '@/*': ['./src/*'] } } });
+    expect(aliasAndBaseUrlCandidates('pages/auth/Register', loadProjectAliases(root)!, root)).toEqual([]);
+  });
+
+  it('drops a candidate that leaves the project', () => {
+    write(path.join(root, 'jsconfig.json'), { compilerOptions: { baseUrl: 'src' } });
+
+    expect(aliasAndBaseUrlCandidates('../../outside/x', loadProjectAliases(root)!, root)).toEqual([]);
+  });
+});
diff --git a/docs/design/framework-coverage.md b/docs/design/framework-coverage.md
index ec436843..82a0ed23 100644
--- a/docs/design/framework-coverage.md
+++ b/docs/design/framework-coverage.md
@@ -38,7 +38,7 @@ guessed.
 |---|---|---|---|---|
 | Expo Router | `frameworks/expo-router.ts` | `expo-router-synthesizer.ts` | `expo-router.test.ts` | — |
 | Next.js | `frameworks/nextjs.ts` | `next-router-synthesizer.ts` | `nextjs.test.ts` | next-saas-starter |
-| React Router | `frameworks/react-router.ts` | `react-router-synthesizer.ts` | `react-router.test.ts` | proshop (44 edges), proshop-v2 (28), react-redux-realworld (22), react-boilerplate (`styled(Link)`), takenote (v5 `<Redirect>`), bulletproof-react (nested `children`, `lazy` routes, `paths.x.path` constants through an app's own tsconfig alias: 0 → 9 named, linked routes), and its `paths.x.getHref(id)` links and `navigate(paths.x.getHref())` calls (0 → 11 navigates). Route tables another file hands the router (`tableRoutes` in `frameworks/react.ts`, trap 13): the ASP.NET Core React template's `AppRoutes.map(… <Route {...rest}>)` on jasontaylordev/CleanArchitecture's `ClientApp-React` (0 → 6 routes, 11 navigates), replaysMike/Binner (0 → 46, 87), GavinLonDigital/RankingApp, GarrettHays/PaydirtPickem, charlessolar/eShopOnContainersDDD; `useRoutes(routes)` from another file and `[...sessionRoutes]` on uilibrary/matx-react (0 → 7, 16); codedthemes' `createBrowserRouter([MainRoutes, LoginRoutes])` on berry and mantis (9 and 8 routes, no navigation they can resolve); a table `.map`ped inside `<Route path="/dashboard">` on RADeveloping/chickadeeinvest; `useRoutes([...])` in place on minimal-ui-kit/material-kit-react (0 → 7, bound through `lazy(() => import(…))` to each page). JSX index routes and layouts (trap 14): proshop-v2's `createRoutesFromElements` (`/` is HomeScreen inside App, not App; 30 layout edges, the `path=''` guards included; Screens 30 → 74 transitions, the guards' redirects drawn from the screens they guard), chickadeeinvest's table inside `<Route element={<DashboardLayout/>}>` (its 4 routes get the layout), React Router 6.29's own examples and tests, refine's 281 examples (one `/` per app, 191 layout edges, 21 new navigations), crwn-clothing, the vanlife course app, volun-mern (105 layout edges, six levels deep), spotify/vispana, react_persist_login, chushi (`path={"agents"}`: 2 → 6 routes), hathor-explorer (`path=""` at the root), cboard, react-router-auth-v6: 578 of 581 new layout edges name a component of an enclosing `<Route>` (vanlife's 3 inherit a default-import resolution bug that already misbinds its pages), 27 of 27 new navigations precise, no navigation lost, 16 control repos byte-identical. Lazy route modules that are barrels (`exportedComponent` in `frameworks/react.ts`): luci-go's milo/ui (`export * from './x'` index files and `export { X as Component }` clauses: 0 → 51 lazy routes linked; the other 40 load a file under `src/build/`, which the default ignore skips, export only a `loader` or a `handle`, or pick a named export in an async `lazy`), Medusa's admin dashboard (all 193 route-map modules resolve through its `export { X as Component } from` barrels, but its routes are not extracted: `getRouteMap()` returns the table), four more apps (9 routes), 16 control repos byte-identical. Lazy loaders that pick their page (`lazyRouteReference` in `frameworks/react.ts`, trap 18): milo/ui's three tabs (`const { TestTab } = await import('…/tabs')`), 20 apps from a GitHub survey of `createBrowserRouter` + `lazy` (636 picked-page edges, each checked against the target file's own export: 467 by name, 169 as its `export default`; 42 routes written with `async lazy()` now indexed, among them React Router's own `lazy-loading-router-provider` example), an AST oracle on the TypeScript compiler agreeing with the text reader on all 2,538 loaders of 876 surveyed router files, a late-file sync equal to a fresh index on 8 of those apps, and 26 control repos byte-identical, among them ghostfolio, whose 30 Angular lazy routes stay Angular's with React detected in the same project. Barrels that pass on a page they import (`import { UserLayout } from './UserLayout'; export { UserLayout }`, `import Login from './Login'; export default Login`; `exportedComponent` follows the import): Arshia76/DigiShop.Frontend (0 → 27 route and layout edges), 49 other repos byte-identical; `export default withAuth(Page)` is followed nowhere. A page in a folder below the barrel's (`pages/Home/index.tsx` behind `@/pages`) whose route failed waits under the barrel's module key (`module:pages`), which the page's own keys never give: a sync that adds the page, or gives it a definition, walks up the import edges to the barrels that pass it on (`reopenReferencesThroughBarrels` in `resolution/module-importers.ts`) and re-opens what waits under theirs. A late-file sync on DigiShop then equals a fresh index (13 of its routes stayed unlinked before), and 27 other repos sync exactly as before. A name the route file declares itself (trap 19), such as a lazy page or layout, a `Loadable(lazy(…))` or an `observer(…)` value, binds to what that declaration renders wherever the file uses it, in routes, layouts and JSX alike: outline (+31 edges, 7 moved off another file's namesake or onto the screen a lazy declaration loads), mastodon (+20, 9 moved: `lazy(() => import(…).then(({ Emoji }) => …))` values and `let Emoji` locals had gone to other files' components), SigNoz (+7, 4 moved), excalidraw (+3, 1 moved: the Next.js example's `<Excalidraw>` was the docs site's), bulletproof-react (+6), material-kit-react and create-t3-turbo (+1 each), with matx, mantis, proshop, next-saas-starter and berry byte-identical |
+| React Router | `frameworks/react-router.ts` | `react-router-synthesizer.ts` | `react-router.test.ts` | proshop (44 edges), proshop-v2 (28), react-redux-realworld (22), react-boilerplate (`styled(Link)`), takenote (v5 `<Redirect>`), bulletproof-react (nested `children`, `lazy` routes, `paths.x.path` constants through an app's own tsconfig alias: 0 → 9 named, linked routes), and its `paths.x.getHref(id)` links and `navigate(paths.x.getHref())` calls (0 → 11 navigates). Route tables another file hands the router (`tableRoutes` in `frameworks/react.ts`, trap 13): the ASP.NET Core React template's `AppRoutes.map(… <Route {...rest}>)` on jasontaylordev/CleanArchitecture's `ClientApp-React` (0 → 6 routes, 11 navigates), replaysMike/Binner (0 → 46, 87), GavinLonDigital/RankingApp, GarrettHays/PaydirtPickem, charlessolar/eShopOnContainersDDD; `useRoutes(routes)` from another file and `[...sessionRoutes]` on uilibrary/matx-react (0 → 7, 16), and its `[...materialRoutes]` once the jsconfig `"baseUrl": "src"` import naming it resolved (7 → 21 routes, each bound through `lazy(() => import(…))` to its page, trap 20); codedthemes' `createBrowserRouter([MainRoutes, LoginRoutes])` on berry and mantis (9 and 8 routes, no navigation they can resolve; each bound to its lazily loaded page and its layout since their `baseUrl` / `"*"` imports resolve, where before they named the local `Loadable(lazy(…))` value); a table `.map`ped inside `<Route path="/dashboard">` on RADeveloping/chickadeeinvest; `useRoutes([...])` in place on minimal-ui-kit/material-kit-react (0 → 7, bound through `lazy(() => import(…))` to each page). JSX index routes and layouts (trap 14): proshop-v2's `createRoutesFromElements` (`/` is HomeScreen inside App, not App; 30 layout edges, the `path=''` guards included; Screens 30 → 74 transitions, the guards' redirects drawn from the screens they guard), chickadeeinvest's table inside `<Route element={<DashboardLayout/>}>` (its 4 routes get the layout), React Router 6.29's own examples and tests, refine's 281 examples (one `/` per app, 191 layout edges, 21 new navigations), crwn-clothing, the vanlife course app, volun-mern (105 layout edges, six levels deep), spotify/vispana, react_persist_login, chushi (`path={"agents"}`: 2 → 6 routes), hathor-explorer (`path=""` at the root), cboard, react-router-auth-v6: 578 of 581 new layout edges name a component of an enclosing `<Route>` (vanlife's 3 inherit a default-import resolution bug that already misbinds its pages), 27 of 27 new navigations precise, no navigation lost, 16 control repos byte-identical. Lazy route modules that are barrels (`exportedComponent` in `frameworks/react.ts`): luci-go's milo/ui (`export * from './x'` index files and `export { X as Component }` clauses: 0 → 51 lazy routes linked; the other 40 load a file under `src/build/`, which the default ignore skips, export only a `loader` or a `handle`, or pick a named export in an async `lazy`), Medusa's admin dashboard (all 193 route-map modules resolve through its `export { X as Component } from` barrels, but its routes are not extracted: `getRouteMap()` returns the table), four more apps (9 routes), 16 control repos byte-identical. Lazy loaders that pick their page (`lazyRouteReference` in `frameworks/react.ts`, trap 18): milo/ui's three tabs (`const { TestTab } = await import('…/tabs')`), 20 apps from a GitHub survey of `createBrowserRouter` + `lazy` (636 picked-page edges, each checked against the target file's own export: 467 by name, 169 as its `export default`; 42 routes written with `async lazy()` now indexed, among them React Router's own `lazy-loading-router-provider` example), an AST oracle on the TypeScript compiler agreeing with the text reader on all 2,538 loaders of 876 surveyed router files, a late-file sync equal to a fresh index on 8 of those apps, and 26 control repos byte-identical, among them ghostfolio, whose 30 Angular lazy routes stay Angular's with React detected in the same project. Barrels that pass on a page they import (`import { UserLayout } from './UserLayout'; export { UserLayout }`, `import Login from './Login'; export default Login`; `exportedComponent` follows the import): Arshia76/DigiShop.Frontend (0 → 27 route and layout edges), 49 other repos byte-identical; `export default withAuth(Page)` is followed nowhere. A page in a folder below the barrel's (`pages/Home/index.tsx` behind `@/pages`) whose route failed waits under the barrel's module key (`module:pages`), which the page's own keys never give: a sync that adds the page, or gives it a definition, walks up the import edges to the barrels that pass it on (`reopenReferencesThroughBarrels` in `resolution/module-importers.ts`) and re-opens what waits under theirs. A late-file sync on DigiShop then equals a fresh index (13 of its routes stayed unlinked before), and 27 other repos sync exactly as before. A name the route file declares itself (trap 19), such as a lazy page or layout, a `Loadable(lazy(…))` or an `observer(…)` value, binds to what that declaration renders wherever the file uses it, in routes, layouts and JSX alike: outline (+31 edges, 7 moved off another file's namesake or onto the screen a lazy declaration loads), mastodon (+20, 9 moved: `lazy(() => import(…).then(({ Emoji }) => …))` values and `let Emoji` locals had gone to other files' components), SigNoz (+7, 4 moved), excalidraw (+3, 1 moved: the Next.js example's `<Excalidraw>` was the docs site's), bulletproof-react (+6), material-kit-react and create-t3-turbo (+1 each), with matx, mantis, proshop, next-saas-starter and berry byte-identical |
 | TanStack Router | `frameworks/tanstack-router.ts` | `tanstack-router-synthesizer.ts` | `tanstack-router.test.ts` | TanStack examples, fastapi-template frontend |
 | Vue Router / Nuxt | `frameworks/vue-router.ts` (Nuxt file routes: `nuxtResolver` in `frameworks/vue.ts`) | `vue-router-synthesizer.ts` | `vue-router.test.ts` | vue-realworld (23 edges); vue-element-admin (62 routes), vue-admin-template (14), vben (192), halo console (34) — named tables, module files, `children` + layouts; Nuxt: mealie, elk, nuxt/movies |
 | SvelteKit | `frameworks/sveltekit-router.ts` | `sveltekit-synthesizer.ts` | `sveltekit-router.test.ts`, `sveltekit-route-names.test.ts` | sveltekit-realworld (31 edges); shadcn-svelte and skeleton (`(group)` layouts: 13 and 23 edges), svelte.dev (74), kit's test apps (47) |
@@ -386,6 +386,20 @@ Each of these cost real debugging time; they are not hypothetical.
    modules the file's lazy values load, so those are synthesis inputs
    (`lazyValueModules`): a sync that gives one its default export redraws the
    tag, as a fresh index would draw it.
+20. **An import that looks like a package can be a path.** Create React App
+   and Vite admin templates (berry, mantis, matx) set `"baseUrl": "src"` or
+   `"paths": { "*": ["./src/*"] }` in a jsconfig and write every cross-file
+   import as `layout/MainLayout` or `pages/auth/Register`. Taken for npm
+   packages, those imports linked nothing: a route table imported that way
+   was never read, and a `lazy(() => import('views/x'))` route bound to the
+   local `Loadable(…)` value instead of its page. The import resolver now
+   reads such a specifier through the importing app's own config and binds it
+   only to an indexed file (`fileExists` also answers for folders and
+   `node_modules`). A package that app's `package.json` declares, or a Node
+   built-in, never reaches a project module that way, only a `.d.ts` the
+   project keeps for it (`"*": ["./typings/*"]`, as tsc reads it). A route
+   resolves its lazy module as TypeScript whatever the file is written in,
+   which is why the TypeScript extension list probes `/index.jsx` last.
 
 ---
 
diff --git a/src/resolution/import-resolver.ts b/src/resolution/import-resolver.ts
index 3cd62cc3..c87b61f7 100644
--- a/src/resolution/import-resolver.ts
+++ b/src/resolution/import-resolver.ts
@@ -8,7 +8,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { Language, Node } from '../types';
 import { UnresolvedRef, ResolvedRef, ResolutionContext, ImportMapping, ReExport } from './types';
-import { applyAliases } from './path-aliases';
+import { applyAliases, aliasAndBaseUrlCandidates } from './path-aliases';
 import { extractLocalExportAliases } from './alias-binding';
 import { resolveWorkspaceImport } from './workspace-packages';
 import { stripCommentsForRegex } from './strip-comments';
@@ -32,14 +32,18 @@ import { JS_ARRAY_METHODS } from './js-builtins';
  * Extension resolution order by language
  */
 const EXTENSION_RESOLUTION: Record<string, string[]> = {
-  typescript: ['.ts', '.tsx', '.d.ts', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js'],
+  // `/index.jsx` last, as tsc probes a directory: a route table resolves the
+  // module its `lazy(() => import('views/x'))` loads as TypeScript, whatever
+  // the file is written in, and admin templates keep their pages in
+  // `views/x/index.jsx`.
+  typescript: ['.ts', '.tsx', '.d.ts', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js', '/index.jsx'],
   // ArkTS imports both `.ets` components and plain `.ts` logic modules —
   // HarmonyOS projects are always a mix. `/Index.ets` (capital I) is ohpm's
   // module-entry convention, hit when a bare workspace import ("data") is
   // rewritten to the member's directory; lowercase variants for safety.
   arkts: ['.ets', '.ts', '.d.ts', '.js', '/Index.ets', '/index.ets', '/index.ts', '/index.js'],
   javascript: ['.js', '.jsx', '.mjs', '.cjs', '.xsjs', '.xsjslib', '/index.js', '/index.jsx'],
-  tsx: ['.tsx', '.ts', '.d.ts', '.js', '.jsx', '/index.tsx', '/index.ts', '/index.js'],
+  tsx: ['.tsx', '.ts', '.d.ts', '.js', '.jsx', '/index.tsx', '/index.ts', '/index.js', '/index.jsx'],
   jsx: ['.jsx', '.js', '/index.jsx', '/index.js'],
   // SFC consumers import plain TS/JS, sibling components, and barrels
   // (`./lib` → `./lib/index.ts`). Without a list, relative imports from a
@@ -366,9 +370,10 @@ function resolveImportPathUncached(
   // Skip external/npm packages — but pass the context so the
   // bare-specifier heuristic can consult the project's tsconfig
   // alias map first (custom prefixes like `@components/*` would
-  // otherwise be misclassified as npm).
+  // otherwise be misclassified as npm). What still looks like a package
+  // may name a file through the importing app's own config.
   if (isExternalImport(importPath, language, context)) {
-    return null;
+    return resolveFromOwnConfig(importPath, fromFile, language, context);
   }
 
   const projectRoot = context.getProjectRoot();
@@ -561,11 +566,13 @@ export function isExternalImport(
     if (['fs', 'path', 'os', 'crypto', 'http', 'https', 'url', 'util', 'events', 'stream', 'child_process', 'buffer'].includes(importPath)) {
       return true;
     }
-    // Project-defined alias prefix? Treat as local.
+    // Project-defined alias prefix? Treat as local. A catch-all `"*"` has no
+    // prefix and matches `react` too: what it names is left to
+    // resolveFromOwnConfig, which keeps the app's packages out.
     const aliases = options.aliasPrefixes === false ? null : context?.getProjectAliases?.();
     if (aliases) {
       for (const pat of aliases.patterns) {
-        if (importPath.startsWith(pat.prefix)) return false;
+        if (pat.prefix !== '' && importPath.startsWith(pat.prefix)) return false;
       }
     }
     // Scoped packages or bare specifiers that don't start with aliases
@@ -727,15 +734,7 @@ function resolveAliasedImport(
   context: ResolutionContext,
   fromFile?: string
 ): string | null {
-  const extensions = EXTENSION_RESOLUTION[language] || [];
-  const tryWithExt = (basePath: string): string | null => {
-    for (const ext of extensions) {
-      const candidate = basePath + ext;
-      if (context.fileExists(candidate)) return candidate;
-    }
-    if (context.fileExists(basePath)) return basePath;
-    return findSourceForEmittedSpecifier(basePath, language, context);
-  };
+  const tryWithExt = (basePath: string): string | null => tryWithExtensions(basePath, language, context);
 
   // 1. tsconfig/jsconfig paths: the config nearest the importing file (an
   //    app of a monorepo keeps its own `@/*`), then the project root's.
@@ -783,6 +782,84 @@ function resolveAliasedImport(
   return tryWithExt(importPath);
 }
 
+/** The file `basePath` names: with the language's extensions or index files, as is, or as an emitted `.js`. */
+function tryWithExtensions(basePath: string, language: Language, context: ResolutionContext): string | null {
+  for (const ext of EXTENSION_RESOLUTION[language] || []) {
+    const candidate = basePath + ext;
+    if (context.fileExists(candidate)) return candidate;
+  }
+  if (context.fileExists(basePath)) return basePath;
+  return findSourceForEmittedSpecifier(basePath, language, context);
+}
+
+/**
+ * A bare specifier `isExternalImport` takes for a package, resolved through
+ * the importing app's own tsconfig / jsconfig — the one nearest the file,
+ * else the root's — as tsc and a paths-aware bundler resolve it: the most
+ * specific `paths` pattern it matches (a catch-all `"*": ["./src/*"]`, an
+ * alias only a nested app declares), then `baseUrl` (`"baseUrl": "src"`
+ * makes `layout/MainLayout` read `src/layout/MainLayout`). CRA and Vite
+ * admin templates import nearly everything this way.
+ *
+ * Only an indexed file binds: `fileExists` also answers for a folder and
+ * for `node_modules`. A package — one the file's package.json or an
+ * enclosing one declares, or a Node built-in — never binds to a project
+ * module (`lodash` stays lodash even beside a `src/lodash/`), only to a
+ * declaration file the project keeps for it, which is the package as tsc
+ * reads it: `legacy-widgets` under `"*": ["./typings/*"]` is
+ * `typings/legacy-widgets.d.ts`.
+ */
+function resolveFromOwnConfig(
+  importPath: string,
+  fromFile: string,
+  language: Language,
+  context: ResolutionContext
+): string | null {
+  const candidates = ownConfigCandidates(importPath, fromFile, language, context);
+  if (!candidates) return null;
+  const indexed = (file: string): boolean => context.isIndexedFile?.(file) !== false;
+  if (context.isDeclaredPackage?.(importPath, fromFile) !== false) {
+    if (!EXTENSION_RESOLUTION[language]?.includes('.d.ts')) return null;
+    for (const candidate of candidates) {
+      const declarations = `${candidate}.d.ts`;
+      if (context.fileExists(declarations) && indexed(declarations)) return declarations;
+    }
+    return null;
+  }
+  for (const candidate of candidates) {
+    const hit = tryWithExtensions(candidate, language, context);
+    if (hit && indexed(hit)) return hit;
+  }
+  return null;
+}
+
+/** Where the importing app's own config reads a bare specifier from (see resolveFromOwnConfig), or null when it reads none. */
+function ownConfigCandidates(
+  importPath: string,
+  fromFile: string,
+  language: Language,
+  context: ResolutionContext
+): string[] | null {
+  if (!ESM_IMPORT_LANGUAGES.has(language) || !importPath || importPath.startsWith('/') || /^[A-Za-z][\w+.-]*:/.test(importPath)) return null;
+  const config = context.getNearestAliases?.(fromFile) ?? context.getProjectAliases?.();
+  if (!config) return null;
+  const candidates = aliasAndBaseUrlCandidates(importPath, config, context.getProjectRoot());
+  return candidates.length > 0 ? candidates : null;
+}
+
+/**
+ * Whether a bare specifier names one of the project's files through the
+ * importing app's own config: its `paths` or `baseUrl` map it to a file the
+ * index holds, and no package the app declares goes by it
+ * (`layout/MainLayout` under `"baseUrl": "src"`). Not a name that maps to
+ * nothing yet: under `"baseUrl": "."` an undeclared `express` is far likelier
+ * a package the manifest leaves out than a module still to come.
+ */
+function namesOwnConfigModule(importPath: string, fromFile: string, language: Language, context: ResolutionContext): boolean {
+  return context.isDeclaredPackage?.(importPath, fromFile) === false &&
+    resolveImportPath(importPath, fromFile, language, context) !== null;
+}
+
 /**
  * C/C++ include directory cache (keyed by project root).
  * Loaded once per resolver instance, shared across calls.
@@ -1743,6 +1820,20 @@ export function isJsPathImportRef(ref: UnresolvedRef): boolean {
   return ref.referenceKind === 'imports' && ESM_IMPORT_LANGUAGES.has(ref.language) && isJsPathSpecifier(ref.referenceName);
 }
 
+/**
+ * A JS/TS `imports` reference to the module of an import named by one bare
+ * segment — `'config'` in `import { DEFAULT_THEME_MODE } from 'config'` under
+ * `"baseUrl": "src"`. Shaped like a package, it names a file only when
+ * resolveImportPath finds one (the app's `baseUrl` or catch-all `paths`, a
+ * workspace member); a real package stays unresolved. A name some import
+ * binds locally is that binding, not the module, and resolves as one.
+ */
+function isJsBareModuleRef(ref: UnresolvedRef, context: ResolutionContext): boolean {
+  if (ref.referenceKind !== 'imports' || !ESM_IMPORT_LANGUAGES.has(ref.language) || isJsPathSpecifier(ref.referenceName)) return false;
+  const imports = context.getImportMappings(ref.filePath, ref.language);
+  return imports.some((m) => m.source === ref.referenceName) && !imports.some((m) => m.localName === ref.referenceName);
+}
+
 /** PHP reference kinds whose name is a class name, written as in the source. */
 const PHP_CLASS_NAME_REFS: ReadonlySet<string> = new Set(['instantiates', 'extends', 'implements', 'references']);
 
@@ -1819,7 +1910,7 @@ export function resolveViaImport(
   // found the way the runtime finds it: extensions, `index` files, path
   // aliases. Matching the basename instead missed every extensionless one
   // (the common spelling) and could land on a same-named file elsewhere.
-  if (isJsPathImportRef(ref)) {
+  if (isJsPathImportRef(ref) || isJsBareModuleRef(ref, context)) {
     const file = resolveImportPath(ref.referenceName, ref.filePath, ref.language, context);
     const fileNode = file && file !== ref.filePath ? context.getNodesInFile(file).find((n) => n.kind === 'file') : undefined;
     if (fileNode) return { original: ref, targetNodeId: fileNode.id, confidence: 0.9, resolvedBy: 'import' };
@@ -3083,7 +3174,9 @@ function collectRustUseBindings(content: string): Map<string, string> {
  *    has no `src/ports/` directory to walk yet is entirely in-repo — that
  *    generalization measured 13 real trait implementations deleted.
  *  - **ES modules** — `isExternalImport`, which already accounts for tsconfig
- *    path aliases and monorepo workspace packages.
+ *    path aliases and monorepo workspace packages, unless the specifier still
+ *    names a project file through the importing app's `baseUrl` or catch-all
+ *    `paths` (`import Base from 'components/Base'`).
  *
  * Everything else returns false and resolves exactly as before. JVM and Python
  * imports notably do NOT go through `resolveImportPath` (they have dedicated
@@ -3111,7 +3204,8 @@ export function isBoundToOutOfRepoImport(
   if (!ESM_IMPORT_LANGUAGES.has(ref.language)) return false;
   for (const imp of context.getImportMappings(ref.filePath, ref.language)) {
     if (imp.localName !== name) continue;
-    return isExternalImport(imp.source, ref.language, context);
+    return isExternalImport(imp.source, ref.language, context) &&
+      resolveImportPath(imp.source, ref.filePath, ref.language, context) === null;
   }
   return false;
 }
@@ -3151,10 +3245,13 @@ export function isBoundToOutOfRepoImport(
  * key a sync looks up for every file it adds or changes, so the file that
  * appears or gains the export finds it.
  *
- * Only for a module of the project: a package's binding keeps its tail.
- * Undefined for every other reference, and for the whole name of an
- * unaliased named import, which is the name its module declares. A Python
- * reference is {@link pythonImportBindingTail}'s, by its whole name only.
+ * Only for a module of the project: a package's binding keeps its tail. A
+ * bare specifier is the project's when the importing app's own config
+ * (`baseUrl`, a catch-all `"*"`) maps it to a file the index holds and no
+ * package the app declares goes by it. Undefined for every other reference,
+ * and for the whole name of an unaliased named import, which is the name its
+ * module declares. A Python reference is {@link pythonImportBindingTail}'s,
+ * by its whole name only.
  */
 export function importBindingTail(ref: UnresolvedRef, context: ResolutionContext): string | undefined {
   if (ref.language === 'python') return pythonImportBindingTail(ref, context);
@@ -3169,7 +3266,9 @@ export function importBindingTail(ref: UnresolvedRef, context: ResolutionContext
   if (!binding || (!receiver && !binding.isDefault && !binding.isNamespace && binding.exportedName === binding.localName)) return undefined;
   if (isExternalImport(binding.source, ref.language, context) &&
       // A monorepo app's own tsconfig alias (`#/views/…`): isExternalImport reads the root's only.
-      !context.getNearestAliases?.(ref.filePath)?.patterns.some((p) => p.prefix !== '' && binding.source.startsWith(p.prefix))) {
+      !context.getNearestAliases?.(ref.filePath)?.patterns.some((p) => p.prefix !== '' && binding.source.startsWith(p.prefix)) &&
+      // A module the app's `baseUrl` or catch-all `paths` reads (`layout/MainLayout`).
+      !namesOwnConfigModule(binding.source, ref.filePath, ref.language, context)) {
     return undefined;
   }
   // `..` names a folder through the importing file's own location.
diff --git a/src/resolution/index.ts b/src/resolution/index.ts
index 42276be9..97fc2fa6 100644
--- a/src/resolution/index.ts
+++ b/src/resolution/index.ts
@@ -307,7 +307,7 @@ export class ReferenceResolver {
   // `null` = computed and absent. Treated as immutable for the
   // resolver's lifetime; callers re-create the resolver if config changes.
   private projectAliases: AliasMap | null | undefined = undefined;
-  // Per directory: the aliases of the nearest non-root tsconfig declaring `paths`.
+  // Per directory: the aliases of the nearest non-root tsconfig declaring `paths` or `baseUrl`.
   private dirAliases = new Map<string, AliasMap | null>();
   // Per project-relative directory ('' = the root): the module of the nearest
   // go.mod at or above it, up to the project root. Same lazy/immutable
@@ -692,6 +692,8 @@ export class ReferenceResolver {
         if (resolved !== null && this.isIndexedFile(resolved)) return false;
         return this.isDeclaredOutsidePackage(source, fromFile);
       },
+      isDeclaredPackage: (source, fromFile) => this.isDeclaredOutsidePackage(source, fromFile),
+      isIndexedFile: (filePath) => this.isIndexedFile(filePath),
       getNodesInFile: (filePath: string) => {
         if (!this.nodeCache.has(filePath)) {
           this.nodeCache.set(filePath, this.queries.getNodesByFile(filePath));
diff --git a/src/resolution/path-aliases.ts b/src/resolution/path-aliases.ts
index 73e366e7..60de648b 100644
--- a/src/resolution/path-aliases.ts
+++ b/src/resolution/path-aliases.ts
@@ -13,7 +13,10 @@
  *
  * Scope:
  *   - reads tsconfig.json, then jsconfig.json, then tsconfig.base.json
- *   - honours `compilerOptions.baseUrl` and `compilerOptions.paths`
+ *   - honours `compilerOptions.baseUrl` and `compilerOptions.paths`; a
+ *     `baseUrl` with no `paths` still loads, because it alone makes
+ *     `layout/MainLayout` name `src/layout/MainLayout` (CRA / Vite admin
+ *     templates)
  *   - follows `extends` chains, nearest config wins (#1534) — Nx-style
  *     monorepos keep every alias in a `tsconfig.base.json` the root
  *     config merely inherits, so without this they resolved nothing
@@ -49,9 +52,17 @@ export interface AliasPattern {
 export interface AliasMap {
   /** Absolute path. The directory `compilerOptions.paths` is rooted at. */
   baseUrl: string;
+  /**
+   * Whether the config (or one it extends) sets `compilerOptions.baseUrl`.
+   * A non-relative specifier is then also read from {@link baseUrl}, after
+   * `paths`, the way tsc reads it. `paths` alone anchors only its own
+   * targets (TypeScript 4.1+), so a map without a `baseUrl` never does.
+   */
+  declaresBaseUrl?: boolean;
   /**
    * Patterns ordered by specificity: longer prefix first, then literal-
    * before-wildcard, so the resolver tries the most-specific match.
+   * Empty for a config that sets only `baseUrl`.
    */
   patterns: AliasPattern[];
 }
@@ -245,7 +256,8 @@ function splitWildcard(pattern: string): {
 
 /**
  * Load aliases for `projectRoot`. Returns `null` when no tsconfig /
- * jsconfig is present or when the file has no usable `paths`.
+ * jsconfig is present or when the file has neither usable `paths` nor a
+ * `baseUrl`.
  *
  * Cheap to call repeatedly — caching is the caller's job (the
  * resolver does it via {@link aliasCache}).
@@ -283,25 +295,24 @@ export function loadProjectAliases(projectRoot: string): AliasMap | null {
   // declared them — which is the project root only when that config is the
   // root one (the pre-`extends` assumption).
   const baseUrl = effective.baseUrl ?? effective.pathsDir ?? projectRoot;
-
-  const paths = effective.paths;
-  if (!paths || typeof paths !== 'object') {
-    // baseUrl alone isn't an "alias" per se; with no paths we'd just
-    // be redirecting the whole tree. Skip — the existing resolver
-    // already handles relative imports.
-    return null;
-  }
+  const declaresBaseUrl = effective.baseUrl !== undefined;
 
   const patterns: AliasPattern[] = [];
-  for (const [pattern, targets] of Object.entries(paths)) {
-    if (!Array.isArray(targets) || targets.length === 0) continue;
-    const filtered = targets.filter((t): t is string => typeof t === 'string');
-    if (filtered.length === 0) continue;
-    const { prefix, suffix, hasWildcard } = splitWildcard(pattern);
-    patterns.push({ prefix, suffix, hasWildcard, replacements: filtered });
+  const paths = effective.paths;
+  if (paths && typeof paths === 'object') {
+    for (const [pattern, targets] of Object.entries(paths)) {
+      if (!Array.isArray(targets) || targets.length === 0) continue;
+      const filtered = targets.filter((t): t is string => typeof t === 'string');
+      if (filtered.length === 0) continue;
+      const { prefix, suffix, hasWildcard } = splitWildcard(pattern);
+      patterns.push({ prefix, suffix, hasWildcard, replacements: filtered });
+    }
   }
 
-  if (patterns.length === 0) return null;
+  // A `baseUrl` with no `paths` is still a map: the resolver reads a bare
+  // specifier from it, but only one that names a project file and no package
+  // the app depends on (see resolveFromOwnConfig in import-resolver.ts).
+  if (patterns.length === 0 && !declaresBaseUrl) return null;
 
   // Specificity sort: longer prefix first; literal patterns before
   // wildcard patterns of the same prefix length. TypeScript itself
@@ -315,10 +326,11 @@ export function loadProjectAliases(projectRoot: string): AliasMap | null {
   logDebug('path-aliases loaded', {
     file: usedFile,
     baseUrl,
+    declaresBaseUrl,
     patternCount: patterns.length,
   });
 
-  return { baseUrl, patterns };
+  return { baseUrl, declaresBaseUrl, patterns };
 }
 
 /**
@@ -362,3 +374,24 @@ export function applyAliases(
   }
   return [];
 }
+
+/**
+ * Where a non-relative specifier can live under `aliases`, in the order tsc
+ * tries them: the targets of the most specific pattern it matches, then the
+ * specifier read from `baseUrl` when the config declares one. Relative to
+ * `projectRoot`; a candidate that escapes it is dropped.
+ */
+export function aliasAndBaseUrlCandidates(
+  importPath: string,
+  aliases: AliasMap,
+  projectRoot: string
+): string[] {
+  const out = applyAliases(importPath, aliases, projectRoot);
+  if (aliases.declaresBaseUrl) {
+    const relative = path.relative(projectRoot, path.resolve(aliases.baseUrl, importPath));
+    if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
+      out.push(relative.replace(/\\/g, '/'));
+    }
+  }
+  return out;
+}
diff --git a/src/resolution/types.ts b/src/resolution/types.ts
index d61c9a40..dfd11cb1 100644
--- a/src/resolution/types.ts
+++ b/src/resolution/types.ts
@@ -185,8 +185,23 @@ export interface ResolutionContext {
    */
   isOutOfRepoImport?(source: string, fromFile: string, language: Language): boolean;
   /**
-   * Project import-path aliases (tsconfig/jsconfig `paths`). Returns
-   * `null` when the project doesn't define any. Cached per resolver
+   * Whether `source`, imported from `fromFile`, is a package: one the file's
+   * package.json or an enclosing one declares, a Node built-in, or a
+   * runtime's virtual module (`node:`, `bun:`, `astro:`…). Such an import
+   * never binds to a same-named project module, only to a declaration file
+   * the project keeps for the package. Supplied by the coordinator.
+   */
+  isDeclaredPackage?(source: string, fromFile: string): boolean;
+  /**
+   * Whether `filePath` (project-relative) is one of the files the index holds.
+   * `fileExists` also answers for a directory and for a file on disk the
+   * index never read, such as one under `node_modules`. Supplied by the
+   * coordinator; a minimal context can omit it.
+   */
+  isIndexedFile?(filePath: string): boolean;
+  /**
+   * Project import-path aliases (tsconfig/jsconfig `paths`, and `baseUrl`).
+   * Returns `null` when the project doesn't define any. Cached per resolver
    * instance — safe to call from any resolver code path. Optional so
    * existing test fixtures and external context implementations
    * compile without modification; production resolver implements it.
@@ -194,7 +209,8 @@ export interface ResolutionContext {
   getProjectAliases?(): import('./path-aliases').AliasMap | null;
   /**
    * The aliases of the tsconfig / jsconfig nearest `fromFile` below the
-   * project root that declares `paths` — a monorepo app's own `@/*` — or null.
+   * project root that declares `paths` or `baseUrl` — a monorepo app's own
+   * `@/*`, a nested Vite app's `"baseUrl": "src"` — or null.
    */
   getNearestAliases?(fromFile: string): import('./path-aliases').AliasMap | null;
   /**