diff --git a/CHANGELOG.md b/CHANGELOG.md
index c9f22f046..a9c7d4a00 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -610,6 +610,8 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 - In Python, `super().get_ip()` called in a method, and `super(Adapter, self).get_ip()` written on one line, now link to the method the class inherits, except where Python would raise or only runtime could tell which method runs; re-index to pick up the new links.
 - In C#, a `global using static` brings its type's members into reach only in the project that declares it, the files under the nearest `.csproj`. A bare name in another project of the same repository no longer links to them as a trusted call.
 - In `codegraph_explore`, an override that hands off to the method it overrides no longer leads the Flow when the question names only the bare method (`pre_sql_setup`), so the Flow starts at the base method instead.
+- In React and Vue, a tag for a component the file imports from a package, like `<Button>` from antd, `<Typography>` from `@mui/material/Typography`, `<Link>` from react-router-dom or `<Card>` from ant-design-vue, no longer links to a component, function or class in your repository that only shares its name. Before, the tag linked to whatever the repository had by that name, so `codegraph_explore`, callers and impact followed renders that never happen: in SigNoz, antd's `<Button>` tags showed up as callers of a styled link on its 404 page, and in Material UI dashboards like mantis and berry, `<Typography>` and `<Button>` tags showed up as callers of the theme's style overrides. A package here is one that a `package.json` above the file lists and that no file in the repository answers to. A tag imported through a path alias like `components/Modal`, from a workspace package of the repository, or under a name no `package.json` lists still links as before. Re-index React and Vue projects after upgrading.
+- In React with TypeScript, a component that renders a generic component and passes it type arguments, like outline's `<PaginatedList<Document> items={…} />` or excalidraw's `<DropdownMenuItemContentRadio<"contain" | "overlap"> …>`, now links to the component it renders. Before, a tag followed by type arguments was skipped, so the generic component looked unused by the screens that render it, and `codegraph_explore`'s call paths, callers and impact stopped short of it. Re-index React projects after upgrading.
 
 ## [1.6.2] - 2026-10-03
 
diff --git a/README.md b/README.md
index 128ddb1ee..bd9de166e 100644
--- a/README.md
+++ b/README.md
@@ -52,7 +52,7 @@ Follow [@getcodegraph](https://x.com/getcodegraph) on X for updates.
 
 ## About this fork
 
-This is **bompus/codegraph**, a fork of [colbymchenry/codegraph](https://github.com/colbymchenry/codegraph). Its default branch, `fork/consolidated`, contains upstream `main` through [`c0f45c7d`](https://github.com/colbymchenry/codegraph/commit/c0f45c7d) (after v1.6.2) plus the fork's own work, and it takes upstream changes as they land. Changes that suit upstream are also offered there as pull requests.
+This is **bompus/codegraph**, a fork of [colbymchenry/codegraph](https://github.com/colbymchenry/codegraph). Its default branch, `fork/consolidated`, contains upstream `main` through [`09511055`](https://github.com/colbymchenry/codegraph/commit/09511055) (after v1.6.2) plus the fork's own work, and it takes upstream changes as they land. Changes that suit upstream are also offered there as pull requests.
 
 The fork publishes no releases. The install scripts, npm package, badges and `codegraph upgrade` further down this page install **upstream's** releases. To run the fork, build it from source (below).
 
@@ -80,7 +80,7 @@ Session search uses `.codegraph/sessions-v2.db`. The first session search import
 
 ### What the fork adds
 
-Compared with upstream `main` at `c0f45c7d` (after v1.6.2). Each item here and in the dispatch and framework lists below was checked against upstream's tree at that commit.
+Compared with upstream `main` at `09511055` (after v1.6.2). Each item here and in the dispatch and framework lists below was checked against upstream's tree at that commit.
 
 | Feature | Upstream | Fork | What it does |
 |---|:-:|:-:|---|
diff --git a/__tests__/jsx-child-disambiguation.test.ts b/__tests__/jsx-child-disambiguation.test.ts
index 4655bcd06..2ba41b058 100644
--- a/__tests__/jsx-child-disambiguation.test.ts
+++ b/__tests__/jsx-child-disambiguation.test.ts
@@ -235,9 +235,12 @@ export const Table = <Entry extends BaseEntity>({ data }: { data: Entry[] }) =>
     );
     await index();
     // `Badge` is written as a type argument too, but a tag of it is enough.
-    // A generic tag's own name is not read at all: no tag ends after
-    // `<PaginatedList` (its type arguments follow).
-    expect(renders('DocumentList')).toEqual(['Badge app/components/Badge.tsx:2']);
+    // `<PaginatedList<Document>` is a tag that passes a type argument: it
+    // renders PaginatedList, and its `Document` stays a type.
+    expect(renders('DocumentList')).toEqual([
+      'Badge app/components/Badge.tsx:2',
+      'PaginatedList app/components/PaginatedList.tsx:1',
+    ]);
     expect(renders('Table')).toEqual([]);
   });
 
@@ -346,3 +349,163 @@ export function Toolbar({ actions }) {
     expect(renders('ExampleApp')).toEqual(['WelcomeScreen packages/excalidraw/components/WelcomeScreen.tsx:1']);
   });
 });
+
+/**
+ * A generic component's tag passes its type arguments right after its name:
+ * outline's lists render `<PaginatedList<Document> items={…} />`, excalidraw's
+ * property panels `<RadioSelection<TextAlign | false> …>`. The pass read a
+ * tag's name only where whitespace, `/` or `>` ended it, so a tag that `<`
+ * ends was never read, and the parent had no edge to the component it renders.
+ * The type arguments stay types.
+ */
+describe('JSX child: a tag that passes type arguments', () => {
+  let dir: string;
+  let cg: any;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsx-generic-'));
+    fs.writeFileSync(path.join(dir, 'package.json'), '{"dependencies":{"react":"^18.0.0"}}');
+  });
+
+  afterEach(() => {
+    cg?.close?.();
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  const write = (rel: string, body: string) => {
+    const p = path.join(dir, rel);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, body);
+  };
+
+  async function index(): Promise<void> {
+    cg = await CodeGraph.init(dir, { silent: true });
+    await cg.indexAll();
+  }
+
+  /** `name file:line` of each node a jsx-render edge out of `parent` points at. */
+  const renders = (parent: string): string[] =>
+    cg.db.db
+      .prepare(
+        `SELECT t.name || ' ' || t.file_path || ':' || t.start_line AS r FROM edges e
+           JOIN nodes s ON s.id = e.source
+           JOIN nodes t ON t.id = e.target
+          WHERE s.name = ? AND json_extract(e.metadata, '$.synthesizedBy') = 'jsx-render'
+          ORDER BY r`
+      )
+      .all(parent)
+      .map((row: any) => row.r);
+
+  it('renders the component a generic tag names, however its type arguments are written', async () => {
+    write('app/models/Document.ts', 'export default class Document {\n  title = "";\n}\n');
+    write('app/models/Mode.ts', 'export class Mode {\n  name = "";\n}\n');
+    write(
+      'app/components/PaginatedList.tsx',
+      `type PaginatedItem = { id: string };
+
+const PaginatedList = <T extends PaginatedItem>({ items }: { items: T[] }) => {
+  return <ul>{items.length}</ul>;
+};
+
+export default PaginatedList;
+`
+    );
+    write(
+      'app/components/RadioSelection.tsx',
+      'export const RadioSelection = <T extends Object>({ value }: { value: T }) => {\n  return <div>{String(value)}</div>;\n};\n'
+    );
+    write(
+      'app/components/DataTable.tsx',
+      'export function DataTable<Row, Column>({ children }: { rows: Row[]; columns: Column[]; children?: unknown }) {\n  return <table>{children}</table>;\n}\n'
+    );
+    write(
+      'app/components/DocumentList.tsx',
+      `import PaginatedList from './PaginatedList';
+import { RadioSelection } from './RadioSelection';
+import { DataTable } from './DataTable';
+import Document from '../models/Document';
+import { Mode } from '../models/Mode';
+
+export function DocumentList({ documents, mode }: { documents: Document[]; mode: Mode }) {
+  return (
+    <section>
+      <PaginatedList<Document>
+        items={documents}
+      />
+      <RadioSelection<Exclude<Mode, "auto"> | false> value={mode} />
+      <DataTable<Document, string> rows={documents} columns={[]}>
+        <p>{documents.length}</p>
+      </DataTable>
+    </section>
+  );
+}
+`
+    );
+    await index();
+    // `Document` and `Mode` are classes the tags pass as types, not children.
+    expect(renders('DocumentList')).toEqual([
+      'DataTable app/components/DataTable.tsx:1',
+      'PaginatedList app/components/PaginatedList.tsx:3',
+      'RadioSelection app/components/RadioSelection.tsx:1',
+    ]);
+  });
+
+  it('still renders nothing for a generic type written as a type argument', async () => {
+    write(
+      'app/components/Grid.tsx',
+      `import * as React from 'react';
+
+export class Grid<Row> extends React.Component<{ rows: Row[] }> {
+  render() {
+    return <table>{this.props.rows.length}</table>;
+  }
+}
+`
+    );
+    write(
+      'app/components/Report.tsx',
+      `import * as React from 'react';
+import { Grid } from './Grid';
+
+export function Report({ rows }: { rows: string[] }) {
+  const grid = React.useRef<Grid<string>>(null);
+  const [grids] = React.useState<Array<Grid<string>>>([]);
+  return <section>{rows.length + grids.length}</section>;
+}
+`
+    );
+    await index();
+    expect(renders('Report')).toEqual([]);
+  });
+
+  it('renders nothing for a generic tag the file imports from a package', async () => {
+    // refine's examples: react95's `<Select<number>>` and antd's
+    // `<Table<IPost>>` are the packages' own components, not another app's
+    // Select or Table that shares the name.
+    fs.writeFileSync(
+      path.join(dir, 'package.json'),
+      '{"dependencies":{"react":"^18.0.0","react95":"^4.0.0","antd":"^5.0.0"}}'
+    );
+    write('apps/shadcn/components/ui/select.tsx', 'export function Select() {\n  return <select />;\n}\n');
+    write('apps/shadcn/components/ui/table.tsx', 'export function Table() {\n  return <table />;\n}\n');
+    write(
+      'apps/win95/pages/posts.tsx',
+      `import { Select } from 'react95';
+import { Table } from 'antd';
+
+type IPost = { id: number };
+
+export function PostList({ posts }: { posts: IPost[] }) {
+  return (
+    <div>
+      <Select<number> options={[]} />
+      <Table<IPost> dataSource={posts} />
+    </div>
+  );
+}
+`
+    );
+    await index();
+    expect(renders('PostList')).toEqual([]);
+  });
+});
diff --git a/__tests__/jsx-package-imports.test.ts b/__tests__/jsx-package-imports.test.ts
new file mode 100644
index 000000000..1d33038c9
--- /dev/null
+++ b/__tests__/jsx-package-imports.test.ts
@@ -0,0 +1,250 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { CodeGraph } from '../src';
+
+/**
+ * A tag the file imports from a package — antd's `<Button>`, react-router's
+ * `<Link>`, a Vue SFC's `<Card>` from ant-design-vue — renders that package's
+ * component, which the index does not hold. Any project symbol that happens
+ * to share the name is a stranger. The JSX pass took that namesake, and when
+ * the name was unique it never looked at the file's imports at all. On SigNoz
+ * that bound about a thousand tags: 431 antd and @signozhq/ui `<Button>`s
+ * rendered `export const Button = styled(Link)` from a 404 page's styles.
+ *
+ * "A package" is what the name matcher already means by it for calls and
+ * values: a specifier no project file answers, which a package.json on the
+ * file's way to the root declares. An alias that reads like a package
+ * (`components/Modal`), an undeclared bare specifier and a workspace package
+ * of the repository all stay the project's.
+ */
+describe('JSX and Vue template tags imported from a package', { timeout: 60_000 }, () => {
+  let dir: string;
+  let cg: any;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsx-pkg-'));
+  });
+
+  afterEach(() => {
+    cg?.close?.();
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  const write = (rel: string, body: string) => {
+    const p = path.join(dir, rel);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, body);
+  };
+
+  async function index(): Promise<void> {
+    cg = await CodeGraph.init(dir, { silent: true });
+    await cg.indexAll();
+  }
+
+  /** `name file:line` of each node an edge of `synthesizedBy` out of `parent` points at. */
+  const targets = (parent: string, synthesizedBy: string): string[] =>
+    cg.db.db
+      .prepare(
+        `SELECT t.name || ' ' || t.file_path || ':' || t.start_line AS r FROM edges e
+           JOIN nodes s ON s.id = e.source
+           JOIN nodes t ON t.id = e.target
+          WHERE s.name = ? AND json_extract(e.metadata, '$.synthesizedBy') = ?
+          ORDER BY r`
+      )
+      .all(parent, synthesizedBy)
+      .map((row: any) => row.r);
+  const renders = (parent: string) => targets(parent, 'jsx-render');
+
+  it('renders nothing for a tag imported from a declared package, whether one or several project symbols share its name', async () => {
+    write('package.json', JSON.stringify({ dependencies: { react: '^18.0.0', antd: '^5.0.0' } }));
+    write(
+      'src/components/NotFound/styles.ts',
+      `import styled from 'styled-components';
+import { Link } from 'react-router-dom';
+
+export const Button = styled(Link)\`
+  color: inherit;
+\`;
+`
+    );
+    write('src/lib/uPlot/Tooltip.tsx', 'export function Tooltip() {\n  return <div />;\n}\n');
+    write('src/lib/charts/Tooltip.tsx', 'export function Tooltip() {\n  return <div />;\n}\n');
+    write(
+      'src/pages/Settings.tsx',
+      `import { Button, Tooltip } from 'antd';
+
+export function Settings() {
+  return (
+    <Tooltip title="Save">
+      <Button type="primary">Save</Button>
+    </Tooltip>
+  );
+}
+`
+    );
+    await index();
+    expect(renders('Settings')).toEqual([]);
+  });
+
+  it('reads package.json again after it is edited, so a dropped dependency makes the tag the project\'s', async () => {
+    write('package.json', JSON.stringify({ dependencies: { react: '^18.0.0', antd: '^5.0.0' } }));
+    write('src/ui/Button.tsx', 'export function Button() {\n  return <button />;\n}\n');
+    write(
+      'src/pages/Settings.tsx',
+      `import { Button } from 'antd';\n\nexport function Settings() {\n  return <Button>Save</Button>;\n}\n`
+    );
+    await index();
+    expect(renders('Settings')).toEqual([]);
+
+    write('package.json', JSON.stringify({ dependencies: { react: '^18.0.0' } }));
+    write(
+      'src/pages/Settings.tsx',
+      `import { Button } from 'antd';\n\nexport function Settings() {\n  return <Button>Save!</Button>;\n}\n`
+    );
+    await cg.sync();
+    expect(renders('Settings')).toEqual(['Button src/ui/Button.tsx:1']);
+  });
+
+  it('renders nothing for a default import from a package subpath, or a package import under another name', async () => {
+    // mantis/berry: `import Typography from '@mui/material/Typography'` beside
+    // the theme's own `Typography` override; a router link renamed on import.
+    write(
+      'package.json',
+      JSON.stringify({ dependencies: { react: '^18.0.0', '@mui/material': '^5.0.0', 'react-router-dom': '^6.0.0' } })
+    );
+    write(
+      'src/themes/overrides/Typography.js',
+      'export default function Typography(theme) {\n  return { MuiTypography: { styleOverrides: {} } };\n}\n'
+    );
+    write('src/components/RouterLink.tsx', 'export function RouterLink() {\n  return <a />;\n}\n');
+    write(
+      'src/pages/Login.tsx',
+      `import Typography from '@mui/material/Typography';
+import { Link as RouterLink } from 'react-router-dom';
+
+export function Login() {
+  return (
+    <Typography variant="h3">
+      <RouterLink to="/register">Sign up</RouterLink>
+    </Typography>
+  );
+}
+`
+    );
+    await index();
+    expect(renders('Login')).toEqual([]);
+  });
+
+  it('keeps a tag imported through an alias that reads like a package, or through a bare specifier no package.json declares', async () => {
+    write('package.json', JSON.stringify({ dependencies: { react: '^18.0.0', antd: '^5.0.0' } }));
+    write(
+      'tsconfig.json',
+      JSON.stringify({ compilerOptions: { baseUrl: '.', paths: { 'components/*': ['src/components/*'] } } })
+    );
+    write('src/components/Modal/index.tsx', 'export default function Modal() {\n  return <div />;\n}\n');
+    write('src/layouts/Header.tsx', 'export default function Header() {\n  return <header />;\n}\n');
+    write(
+      'src/container/Alerts.tsx',
+      `import Modal from 'components/Modal';
+
+export function Alerts() {
+  return <Modal />;
+}
+`
+    );
+    write(
+      'src/container/Confirm.tsx',
+      `import { Modal } from 'antd';
+
+export function Confirm() {
+  return <Modal />;
+}
+`
+    );
+    // No alias maps `layouts/*` and no package.json declares `layouts`: the
+    // resolver can't follow it, which does not make it a package.
+    write(
+      'src/App.tsx',
+      `import Header from 'layouts/Header';
+
+export function App() {
+  return <Header />;
+}
+`
+    );
+    await index();
+    expect(renders('Alerts')).toEqual(['Modal src/components/Modal/index.tsx:1']);
+    expect(renders('Confirm')).toEqual([]);
+    expect(renders('App')).toEqual(['Header src/layouts/Header.tsx:1']);
+  });
+
+  it('keeps a tag imported from a workspace package of the repository', async () => {
+    write('package.json', JSON.stringify({ private: true, workspaces: ['packages/*', 'apps/*'] }));
+    write('packages/ui/package.json', JSON.stringify({ name: '@acme/ui', version: '1.0.0' }));
+    write('packages/ui/index.tsx', 'export function Button() {\n  return <button />;\n}\n');
+    // The app depends on it by version, as a published package would be.
+    write(
+      'apps/web/package.json',
+      JSON.stringify({ name: 'web', dependencies: { '@acme/ui': '^1.0.0', react: '^18.0.0' } })
+    );
+    write(
+      'apps/web/src/Page.tsx',
+      `import { Button } from '@acme/ui';
+
+export function Page() {
+  return <Button />;
+}
+`
+    );
+    await index();
+    expect(renders('Page')).toEqual(['Button packages/ui/index.tsx:1']);
+  });
+
+  it('binds nothing in a Vue template for a tag or a composable imported from a package', async () => {
+    write(
+      'package.json',
+      JSON.stringify({ dependencies: { vue: '^3.4.0', 'ant-design-vue': '^4.0.0', '@vueuse/core': '^10.0.0' } })
+    );
+    write(
+      'src/components/ui/card/Card.vue',
+      '<script setup lang="ts">\ndefineProps<{ title?: string }>();\n</script>\n\n<template>\n  <div class="card"><slot /></div>\n</template>\n'
+    );
+    write(
+      'src/components/ui/button/Button.vue',
+      '<script setup lang="ts">\ndefineProps<{ variant?: string }>();\n</script>\n\n<template>\n  <button><slot /></button>\n</template>\n'
+    );
+    write(
+      'src/components/AppHeader.vue',
+      '<script setup lang="ts">\nconst title = "App";\n</script>\n\n<template>\n  <header>{{ title }}</header>\n</template>\n'
+    );
+    write(
+      'src/composables/useFullscreen.ts',
+      'export function useFullscreen() {\n  function toggle() {\n    return document.fullscreenElement;\n  }\n  return { toggle };\n}\n'
+    );
+    // The handler is what the package's composable returns, not the project's
+    // composable of the same name.
+    write(
+      'src/views/Dashboard.vue',
+      `<script setup lang="ts">
+import { Button, Card } from 'ant-design-vue';
+import { useFullscreen } from '@vueuse/core';
+import AppHeader from '../components/AppHeader.vue';
+
+const { toggle: toggleFullscreen } = useFullscreen();
+</script>
+
+<template>
+  <AppHeader />
+  <Card title="Usage">
+    <Button @click="toggleFullscreen">Full screen</Button>
+  </Card>
+</template>
+`
+    );
+    await index();
+    expect(renders('Dashboard')).toEqual(['AppHeader src/components/AppHeader.vue:1']);
+    expect(targets('Dashboard', 'vue-handler')).toEqual([]);
+  });
+});
diff --git a/__tests__/jsx-render-work.test.ts b/__tests__/jsx-render-work.test.ts
index 68f5ae4b8..dd12b0a09 100644
--- a/__tests__/jsx-render-work.test.ts
+++ b/__tests__/jsx-render-work.test.ts
@@ -14,7 +14,7 @@ import * as path from 'path';
 import { CodeGraph } from '../src';
 
 /** The source of the pass's tag pattern, to count its scans by. */
-const JSX_TAG_SOURCE = String.raw`<([A-Z][A-Za-z0-9_]*)[\s/>]`;
+const JSX_TAG_SOURCE = String.raw`<([A-Z][A-Za-z0-9_]*)(?=[\s/><])`;
 
 describe('jsx-render pass work', () => {
   let tmpDir: string | undefined;
diff --git a/src/resolution/callback-synthesizer.ts b/src/resolution/callback-synthesizer.ts
index eebcee7da..7e2d5e8c4 100644
--- a/src/resolution/callback-synthesizer.ts
+++ b/src/resolution/callback-synthesizer.ts
@@ -64,7 +64,11 @@ const ON_INLINE_RE =
 const SETSTATE_RE = /this\.setState\s*\(/;
 const FLUTTER_SETSTATE_RE = /\bsetState\s*\(/; // Flutter: setState((){…}) / this.setState
 const JS_FAMILY = ['typescript', 'javascript', 'tsx', 'jsx'];
-const JSX_TAG_RE = /<([A-Z][A-Za-z0-9_]*)[\s/>]/g;
+// A tag's name ends at whitespace, `/` or `>`, or at the `<` of the type
+// arguments a generic component's tag passes: `<PaginatedList<Document>
+// items={…} />` renders PaginatedList. The lookahead leaves that `<` to open
+// the next match, which `opensTag` reads as a type argument, not a tag.
+const JSX_TAG_RE = /<([A-Z][A-Za-z0-9_]*)(?=[\s/><])/g;
 const MAX_JSX_CHILDREN = 30;
 // Vue SFC templates: kebab-case child components (<el-button> → ElButton) and
 // event bindings (@click="fn" / v-on:click="fn"). PascalCase children (<VPNav/>)
@@ -2066,6 +2070,19 @@ function importedFrom(ctx: ResolutionContext, file: string, language: Language):
   return out;
 }
 
+/**
+ * Does `file` import `name` from a package outside the repository (`import {
+ * Button } from 'antd'`)? A package means one the file's package.json, or an
+ * enclosing one, declares, under a specifier no project file answers. That is
+ * the test the name matcher applies to calls and values. What such a name
+ * renders is the package's, never a project symbol that shares the name.
+ */
+function importedFromPackage(ctx: ResolutionContext, name: string, file: string): boolean {
+  const language = languageForJsxFile(file);
+  const binding = ctx.getImportMappings(file, language).find((m) => m.localName === name);
+  return !!binding && ctx.isOutOfRepoImport?.(binding.source, file, language) === true;
+}
+
 /**
  * The component a JSX tag names, among every node that shares the name.
  *
@@ -2080,8 +2097,11 @@ function importedFrom(ctx: ResolutionContext, file: string, language: Language):
  * another sheet.
  *
  * Same file first — a small component declared beside its use is the commonest
- * shape, and the one an import can never disambiguate. Then the file the name
- * is imported from. Then the language, which only decides a tie: a `.tsx` tag
+ * shape, and the one an import can never disambiguate. Then a name the file
+ * imports from a package: that package's component, which is no node here, so
+ * nothing. On SigNoz, antd's `<Button>` rendered the one project `Button` there
+ * was, a styled link in a 404 page's styles. Then the file the name is
+ * imported from. Then the language, which only decides a tie: a `.tsx` tag
  * naming both a TS component and a same-named Swift class means the TS one.
  */
 function jsxChild(
@@ -2091,6 +2111,9 @@ function jsxChild(
   importsOf: () => Map<string, string>
 ): Node | undefined {
   const candidates = ctx.getNodesByName(name).filter((n) => JSX_CHILD_KINDS.has(n.kind));
+  const local = candidates.find((n) => n.filePath === file);
+  if (local) return local;
+  if (importedFromPackage(ctx, name, file)) return undefined;
   if (candidates.length === 0) {
     // A name nothing declares is the file's DEFAULT import of a module's one
     // component under another name: segmented-control renders
@@ -2114,8 +2137,6 @@ function jsxChild(
     return implicitDefault || declaredDefault || fabricDefault ? component : undefined;
   }
   if (candidates.length === 1) return candidates[0];
-  const local = candidates.find((n) => n.filePath === file);
-  if (local) return local;
   const from = importsOf().get(name);
   if (from) {
     const imported = candidates.find((n) => n.filePath === from);
@@ -2373,10 +2394,15 @@ async function vueTemplateEdges(ctx: ResolutionContext, onYield: MaybeYield): Pr
       added++;
     };
     // Prefer a target in THIS SFC (handlers live in the same file's script) —
-    // avoids cross-file mis-match when a name repeats across a monorepo.
-    const resolve = (name: string, kinds: Set<string>): Node | undefined => {
+    // avoids cross-file mis-match when a name repeats across a monorepo. A name
+    // the SFC imports from a package (`import { NButton } from 'naive-ui'`) is
+    // the package's: no other project symbol, nor a Nuxt auto-imported
+    // component (`fallback`), is what it renders or calls.
+    const resolve = (name: string, kinds: Set<string>, fallback?: Node): Node | undefined => {
       const matches = ctx.getNodesByName(name).filter((n) => kinds.has(n.kind));
-      return matches.find((n) => n.filePath === file) ?? matches[0];
+      const local = matches.find((n) => n.filePath === file);
+      if (local || importedFromPackage(ctx, name, file)) return local;
+      return matches[0] ?? fallback;
     };
 
     // This SFC's own `components: { 'my-comp': MyComp, Other }` registrations
@@ -2418,7 +2444,7 @@ async function vueTemplateEdges(ctx: ResolutionContext, onYield: MaybeYield): Pr
     while ((m = VUE_KEBAB_RE.exec(tpl))) {
       const tag = kebabToPascal(m[1]!);
       addEdge(
-        registered(m[1]!) ?? resolve(tag, COMPONENT_KINDS) ?? nuxtComponents.get(tag),
+        registered(m[1]!) ?? resolve(tag, COMPONENT_KINDS, nuxtComponents.get(tag)),
         { synthesizedBy: 'jsx-render', via: m[1] }
       );
     }
@@ -2429,7 +2455,7 @@ async function vueTemplateEdges(ctx: ResolutionContext, onYield: MaybeYield): Pr
     while ((m = VUE_PASCAL_RE.exec(tpl))) {
       const tag = m[1]!;
       addEdge(
-        registered(tag) ?? resolve(tag, COMPONENT_KINDS) ?? nuxtComponents.get(tag),
+        registered(tag) ?? resolve(tag, COMPONENT_KINDS, nuxtComponents.get(tag)),
         { synthesizedBy: 'jsx-render', via: tag }
       );
     }
diff --git a/src/resolution/import-resolver.ts b/src/resolution/import-resolver.ts
index 75669d9e7..d3281028b 100644
--- a/src/resolution/import-resolver.ts
+++ b/src/resolution/import-resolver.ts
@@ -230,11 +230,12 @@ const RUST_STDLIB_ROOTS = new Set(['std', 'core', 'alloc', 'proc_macro']);
  * like `@components/*` would fail the bare-specifier heuristic and
  * be classified as external before alias resolution can run.
  */
-function isExternalImport(
+export function isExternalImport(
   importPath: string,
   language: Language,
   context?: ResolutionContext,
-  fromFile?: string
+  fromFile?: string,
+  options: { aliasPrefixes?: boolean } = {}
 ): boolean {
   // Relative imports are not external
   if (importPath.startsWith('.')) {
@@ -256,8 +257,11 @@ 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.
-    if (context) {
+    // Project-defined alias prefix? Treat as local. (`aliasPrefixes: false`
+    // skips this, for a caller that has already asked `resolveImportPath`
+    // whether an alias maps the specifier to a file: a catch-all `"*"` pattern
+    // has an empty prefix and matches every package.)
+    if (context && options.aliasPrefixes !== false) {
       const { scoped, root } = aliasMapsFor(context, fromFile);
       for (const aliases of [scoped, root]) {
         if (aliases?.patterns.some(pat => importPath.startsWith(pat.prefix))) return false;
diff --git a/src/resolution/index.ts b/src/resolution/index.ts
index 942eace22..f937ecd68 100644
--- a/src/resolution/index.ts
+++ b/src/resolution/index.ts
@@ -23,7 +23,7 @@ import {
   CPP_DEFINE_SIGNATURE,
 } from './types';
 import { isBindingReceiverCall,  crossesKnownFamily, crossesCodeBoundary, resolveAmbiguousNameCeiling} from './gates';
-import { extractImportMappings, importMappingsFromBindings,  loadCppIncludeDirs, isBoundToOutOfRepoImport, importBindingTail, clearImportResolverMemos } from './import-resolver';
+import { isExternalImport, resolveImportPath, extractImportMappings, importMappingsFromBindings,  loadCppIncludeDirs, isBoundToOutOfRepoImport, importBindingTail, clearImportResolverMemos } from './import-resolver';
 import { gateSwiftTypeTarget, clearSwiftTypeVisibility } from './swift-type-visibility';
 import { gateTypeParameter, clearTypeParameterMemos } from './type-parameters';
 import { gateRustScope, clearRustScopeMemos } from './rust-scope';
@@ -42,6 +42,8 @@ import { loadWorkspacePackages, type WorkspacePackages } from './workspace-packa
 import { logDebug } from '../errors';
 import { lexicalPathWithinRoot, safeJsonParse } from '../utils';
 import { builtinModules } from 'module';
+import { parse as parseJsonc } from 'jsonc-parser';
+const NODE_BUILTINS = new Set(builtinModules);
 import { getKernel, type KernelResolverLike, type ResolveRefIn, type ResolveOutcome } from '../extraction/kernel/loader';
 import { LRUCache } from './lru-cache';
 import { SynthSkips, SYNTH_SKIPS_VERSION } from './synth-skips';
@@ -411,6 +413,7 @@ export class ReferenceResolver {
     this.goPackageDirs.clear();
     this.goModuleByDir.clear();
     this.allFilesCache = null;
+    this.manifestScopes.clear();
     this.cachesWarmed = false;
     // The import-resolver's per-context memos assume the
     // same stable window as the caches above — drop them together.
@@ -501,6 +504,75 @@ export class ReferenceResolver {
     }
   }
 
+  private isIndexedFile(filePath: string): boolean {
+    const normalized = filePath.replace(/\\/g, '/');
+    return this.knownFiles ? this.knownFiles.has(normalized) : this.queries.getFileByPath(normalized) !== null;
+  }
+
+  /** The repository's own package name, from its root package.json; null without one. */
+  /** Per directory: the package names its package.json and every enclosing one own and depend on. */
+  private manifestScopes = new Map<string, { own: Set<string>; deps: Set<string> }>();
+
+  /**
+   * Is `source` a package from outside the repository? Only when the importing
+   * file's package.json (or an enclosing one) declares it, or it is a Node
+   * built-in or a runtime's virtual module. A specifier nothing declares is
+   * an alias this resolver does not know — SvelteKit's `$lib/…`, Nuxt's
+   * `~/…`, a nested app's own `@/…` — and stays the project's.
+   */
+  private isDeclaredOutsidePackage(source: string, fromFile: string): boolean {
+    // Deno's standard library is `@std/…` from JSR.
+    if (/^(?:node|bun|jsr|npm|https?):/.test(source) || source.startsWith('@std/') || NODE_BUILTINS.has(source)) return true;
+    const name = source.startsWith('@') ? source.split('/').slice(0, 2).join('/') : source.split('/')[0]!;
+    const normalized = fromFile.replace(/\\/g, '/');
+    const scope = this.manifestScope(normalized.includes('/') ? normalized.slice(0, normalized.lastIndexOf('/')) : '');
+    if (scope.own.has(name)) return false;
+    if (scope.deps.has(name)) return true;
+    // SvelteKit's `$app/…` and Astro's `astro:…` belong to the framework —
+    // unless this repository is that framework.
+    const provider = source.startsWith('astro:') ? 'astro' : /^\$(?:app|env|service-worker)(?:\/|$)/.test(source) ? '@sveltejs/kit' : null;
+    return provider !== null && !scope.own.has(provider) && !this.context.getWorkspacePackages?.()?.byName.has(provider);
+  }
+
+  private manifestScope(dir: string): { own: Set<string>; deps: Set<string> } {
+    const memo = this.manifestScopes.get(dir);
+    if (memo) return memo;
+    const parent = dir === '' ? null : this.manifestScope(dir.includes('/') ? dir.slice(0, dir.lastIndexOf('/')) : '');
+    let scope = parent ?? { own: new Set<string>(), deps: new Set<string>() };
+    try {
+      const json = JSON.parse(this.context.readFile(dir ? `${dir}/package.json` : 'package.json') ?? 'null') as Record<string, unknown> | null;
+      if (json && typeof json === 'object') {
+        scope = { own: new Set(scope.own), deps: new Set(scope.deps) };
+        if (typeof json.name === 'string' && json.name.length > 0) scope.own.add(json.name);
+        for (const field of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+          const deps = json[field];
+          if (!deps || typeof deps !== 'object') continue;
+          for (const [dep, version] of Object.entries(deps)) {
+            // `workspace:*`, `file:../shared`, `link:…`: a package in this repository.
+            if (typeof version === 'string' && /^(?:workspace|file|link|portal):/.test(version)) scope.own.add(dep);
+            else scope.deps.add(dep);
+          }
+        }
+      }
+    } catch { /* no or unreadable package.json */ }
+    // A Deno import map names packages the same way — an entry that maps to a
+    // registry or a URL, not one that maps to a path in the repository.
+    for (const file of ['deno.json', 'deno.jsonc']) {
+      const raw = this.context.readFile(dir ? `${dir}/${file}` : file);
+      if (!raw) continue;
+      const json = parseJsonc(raw) as { imports?: Record<string, unknown> } | undefined;
+      const imports = json && typeof json === 'object' ? json.imports : undefined;
+      if (!imports || typeof imports !== 'object') continue;
+      for (const [key, target] of Object.entries(imports)) {
+        if (typeof target !== 'string' || !/^(?:jsr|npm|https?):/.test(target)) continue;
+        if (scope === parent) scope = { own: new Set(scope.own), deps: new Set(scope.deps) };
+        scope.deps.add(key.replace(/\/$/, ''));
+      }
+    }
+    this.manifestScopes.set(dir, scope);
+    return scope;
+  }
+
   /**
    * Create the resolution context
    */
@@ -530,6 +602,16 @@ export class ReferenceResolver {
           language: ref.language,
         }));
       },
+      // A path alias makes an import the project's only when it maps the
+      // import to a file the index holds. Matching its prefix is not enough:
+      // a catch-all `"*": ["./typings/*"]` matches every package, and a path
+      // that exists on disk may lie in `node_modules`.
+      isOutOfRepoImport: (source, fromFile, language) => {
+        if (!isExternalImport(source, language, this.context, fromFile, { aliasPrefixes: false })) return false;
+        const resolved = resolveImportPath(source, fromFile, language, this.context);
+        if (resolved !== null && this.isIndexedFile(resolved)) return false;
+        return this.isDeclaredOutsidePackage(source, fromFile);
+      },
       getNodesInFile: (filePath: string) => {
         if (!this.nodeCache.has(filePath)) {
           this.nodeCache.set(filePath, this.queries.getNodesByFile(filePath));
diff --git a/src/resolution/types.ts b/src/resolution/types.ts
index 743136acc..d2e9204ba 100644
--- a/src/resolution/types.ts
+++ b/src/resolution/types.ts
@@ -172,6 +172,13 @@ export interface ResolutionContext {
    * importing the import resolver (which itself uses name-matching helpers).
    * Minimal contexts without import resolution may omit this capability. */
   resolveImport?(ref: UnresolvedRef): ResolvedRef | null;
+  /**
+   * Whether an import specifier, written in `fromFile`, names a module outside
+   * the repository: a package that is not a relative path, a tsconfig alias, a
+   * workspace member or the repository's own package name, and that resolves
+   * to no project file. Supplied by the coordinator, like `resolveImport`.
+   */
+  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