>,
+ conditions: readonly string[] = ['import', 'browser'],
+): string | undefined {
+ const resolver = enhancedResolve.ResolverFactory.createResolver({
+ fileSystem: fs,
+ useSyncFileSystemCalls: true,
+ extensions: ['.js'],
+ alias,
+ conditionNames: conditions,
+ })
+ try {
+ return resolver.resolveSync({}, dirname(entry), request) || undefined
+ } catch (cause) {
+ if (cause instanceof Error && /Can't resolve/.test(cause.message))
+ return undefined
+ throw cause
+ }
+}
+
+it('matches installed resolver declaration order, exact keys and subpath boundaries', () => {
+ const broad = file('broad/index.js')
+ const broadSub = file('broad/feature.js')
+ const specific = file('specific.js')
+ const dir = dirname(broad)
+ const cases = [
+ {
+ request: '@x/feature',
+ alias: { '@x': dir, '@x/feature': specific },
+ expected: broadSub,
+ },
+ {
+ request: '@x/feature',
+ alias: { '@x/feature': specific, '@x': dir },
+ expected: specific,
+ },
+ {
+ request: '@x',
+ alias: { '@x$': specific, '@x': dir },
+ expected: specific,
+ },
+ {
+ request: '@x/feature',
+ alias: { '@x$': specific, '@x': dir },
+ expected: broadSub,
+ },
+ { request: '@xyz', alias: { '@x': dir }, expected: undefined },
+ { request: '@x', alias: { '@x': dir }, expected: broad },
+ ]
+ for (const { request, alias, expected } of cases) {
+ expect(installed(request, alias)).toBe(expected)
+ expect(
+ createModuleResolver({ cwd: root, alias })(request, entry)?.path,
+ ).toBe(expected)
+ }
+})
+
+it.each([
+ { conditions: ['browser', 'import'] },
+ { conditions: ['import'] },
+ { conditions: [] },
+])(
+ 'matches package exports conditions after alias rewrite (%j)',
+ ({ conditions }) => {
+ file(
+ 'node_modules/target/package.json',
+ JSON.stringify({
+ exports: {
+ '.': {
+ browser: './browser.js',
+ import: './import.js',
+ default: './default.js',
+ },
+ './feature': './feature.js',
+ },
+ }),
+ )
+ const browser = file('node_modules/target/browser.js')
+ const imported = file('node_modules/target/import.js')
+ const fallback = file('node_modules/target/default.js')
+ const feature = file('node_modules/target/feature.js')
+ const alias = { '@x': 'target' }
+ const expected = conditions.includes('browser')
+ ? browser
+ : conditions.includes('import')
+ ? imported
+ : fallback
+ expect(installed('@x', alias, conditions)).toBe(expected)
+ expect(
+ createModuleResolver({ cwd: root, alias, conditions })('@x', entry)?.path,
+ ).toBe(expected)
+ expect(installed('@x/feature', alias, conditions)).toBe(feature)
+ expect(
+ createModuleResolver({ cwd: root, alias, conditions })(
+ '@x/feature',
+ entry,
+ )?.path,
+ ).toBe(feature)
+ },
+)
+
+it('matches missing-target terminal failure even when the original and a later alias exist', () => {
+ file('node_modules/original/package.json', '{"main":"index.js"}')
+ file('node_modules/original/index.js')
+ const later = file('later.js')
+ const alias = { original: join(root, 'missing'), original$: later }
+ expect(installed('original', alias)).toBeUndefined()
+ expect(() =>
+ createModuleResolver({ cwd: root, alias })('original', entry),
+ ).toThrow(
+ `${entry}:1:1: Module alias original cannot resolve candidates ${JSON.stringify([alias.original])}`,
+ )
+})
+
+it('matches finite chains and self-alias skips', () => {
+ const target = file('target.js')
+ const alias = { '@a': '@a', '@a/feature': '@b', '@b': target }
+ expect(installed('@a/feature', alias)).toBe(target)
+ expect(
+ createModuleResolver({ cwd: root, alias })('@a/feature', entry)?.path,
+ ).toBe(target)
+})
+
+it('fails alias cycles at the real importer location', () => {
+ const alias = { '@a': '@b', '@b': '@a' }
+ expect(() => installed('@a', alias)).toThrow()
+ expect(() => createModuleResolver({ cwd: root, alias })('@a', entry)).toThrow(
+ `${entry}:1:1`,
+ )
+})
+
+it('matches installed self-target subpath guards without an unbounded rewrite', () => {
+ file(
+ 'node_modules/pkg/package.json',
+ '{"exports":{"./feature":"./feature.js"}}',
+ )
+ const feature = file('node_modules/pkg/feature.js')
+ const alias = { pkg: 'pkg/feature' }
+ expect(installed('pkg', alias)).toBe(feature)
+ expect(createModuleResolver({ cwd: root, alias })('pkg', entry)?.path).toBe(
+ feature,
+ )
+})
+
+it('follows the actual aliased included-package closure rather than the alias name', () => {
+ fs.writeFileSync(entry, "import 'provider'")
+ file('node_modules/actual/package.json', '{"main":"index.js"}')
+ const provider = file(
+ 'node_modules/actual/index.js',
+ "import './nested/value.generated'",
+ )
+ const leaf = file('node_modules/actual/nested/value.generated.mjs')
+ const graph = buildStaticImportGraph('src', undefined, {
+ cwd: root,
+ alias: { provider: 'actual' },
+ include: ['actual'],
+ })
+ expect(graph.files).toEqual([entry, provider, leaf].sort())
+ expect(
+ buildStaticImportGraph('src', undefined, {
+ cwd: root,
+ alias: { provider: 'actual' },
+ }).files,
+ ).toEqual([entry])
+})
+
+it('follows an absolute alias into the actual included package and honors its exclusions', () => {
+ fs.writeFileSync(entry, "import 'provider'")
+ file('node_modules/actual/package.json', '{"main":"index.js"}')
+ const provider = file(
+ 'node_modules/actual/index.js',
+ "import './nested/leaf'",
+ )
+ const leaf = file('node_modules/actual/nested/leaf.mjs')
+ const options = { cwd: root, alias: { provider }, include: ['actual'] }
+ expect(buildStaticImportGraph('src', undefined, options).files).toEqual(
+ [entry, provider, leaf].sort(),
+ )
+ expect(
+ buildStaticImportGraph('src', undefined, {
+ ...options,
+ exclude: [dirname(leaf)],
+ }).files,
+ ).toEqual([entry, provider].sort())
+})
diff --git a/packages/plugin-utils/src/__tests__/nested-jsx-graph.test.ts b/packages/plugin-utils/src/__tests__/nested-jsx-graph.test.ts
new file mode 100644
index 000000000..f2d37040f
--- /dev/null
+++ b/packages/plugin-utils/src/__tests__/nested-jsx-graph.test.ts
@@ -0,0 +1,79 @@
+import { readFileSync } from 'node:fs'
+
+import { expect, it, mock } from 'bun:test'
+
+import { __setOxcParserForTest, buildStaticImportGraph } from '../import-graph'
+import { ConfigLoadError } from '../load-config'
+import { createPreparedFixture } from './prepared-graph-fixture'
+
+let root: string
+const file = createPreparedFixture((directory) => {
+ root = directory
+})
+
+it.each(
+ [
+ "const jsx = {import('phantom') && import('./real')}{require('phantom') && require('./required')}
;",
+ "const jsx = {(import('phantom')) && import('./real')}{(require('phantom')) && require('./required')}
;",
+ "const jsx = import('phantom')} next={require('phantom')}>require('phantom'){import('./real')}{require('./required')};",
+ ].flatMap((code) =>
+ [false, true].flatMap((enabled) =>
+ [false, true].map((prepared) => ({ code, enabled, prepared })),
+ ),
+ ),
+)(
+ 'resolves only real nested JSX files with diagnostics=$enabled prepared=$prepared in $code',
+ async ({ code, enabled, prepared }) => {
+ // Given: independently created targets and a manifest that fails if resolved.
+ new Bun.Transpiler({ loader: 'tsx' }).transformSync(code)
+ const entry = file('src/main.tsx', code)
+ const real = file('src/real.ts', 'export const real = 1')
+ const required = file('src/required.ts', 'export const required = 2')
+ file('node_modules/phantom/package.json', '{')
+ const programRead = mock(() => ({
+ type: 'ImportExpression',
+ source: { value: 'phantom' },
+ }))
+ const parseSync = mock(() => ({
+ errors: [],
+ get program() {
+ return programRead()
+ },
+ }))
+ const loaded: string[] = []
+ __setOxcParserForTest(enabled ? { parseSync } : false)
+ // When: traverse the real filesystem, never executing a fixture module.
+ const graph = prepared
+ ? await buildStaticImportGraph('src', undefined, {
+ cwd: root,
+ prepareSource: (filename: string) => {
+ loaded.push(filename)
+ return readFileSync(filename, 'utf8')
+ },
+ })
+ : buildStaticImportGraph('src', undefined, { cwd: root })
+ // Then: real edges load real files; no textual/AST phantom reaches resolution.
+ expect(graph.dynamicImports.get(entry)).toEqual(new Set([real]))
+ expect(graph.staticImports.get(entry)).toEqual(new Set([required]))
+ expect(graph.staticImporters.get(required)).toEqual(new Set([entry]))
+ expect(graph.dynamicTargets).toEqual(new Set([real]))
+ expect(graph.files).toEqual([entry, real, required].sort())
+ expect(graph.externalImports?.get(entry)).toEqual(new Set())
+ expect(loaded.sort()).toEqual(
+ prepared ? [entry, real, required].sort() : [],
+ )
+ expect(parseSync).toHaveBeenCalledTimes(enabled ? 3 : 0)
+ expect(programRead).not.toHaveBeenCalled()
+ },
+)
+
+it('rejects the poisoned manifest when an actual literal edge requests phantom', () => {
+ // Given: the same poison is reachable by a real dependency, not excluded.
+ file('src/main.tsx', "import('phantom')")
+ file('node_modules/phantom/package.json', '{')
+ __setOxcParserForTest(false)
+ // When/Then: resolution of that real edge must fail.
+ expect(() => buildStaticImportGraph('src', undefined, { cwd: root })).toThrow(
+ ConfigLoadError,
+ )
+})
diff --git a/packages/plugin-utils/src/__tests__/numbering.test.ts b/packages/plugin-utils/src/__tests__/numbering.test.ts
new file mode 100644
index 000000000..86d7d09df
--- /dev/null
+++ b/packages/plugin-utils/src/__tests__/numbering.test.ts
@@ -0,0 +1,186 @@
+import * as fs from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+import {
+ afterEach,
+ beforeEach,
+ describe,
+ expect,
+ it,
+ mock,
+ spyOn,
+} from 'bun:test'
+
+import { listSourceFiles } from '../import-graph'
+import {
+ collectNumberedFiles,
+ extractedNeedles,
+ seedFileNumbers,
+} from '../numbering'
+
+describe('collectNumberedFiles', () => {
+ let root: string
+
+ const write = (path: string) => {
+ fs.mkdirSync(dirname(join(root, path)), { recursive: true })
+ fs.writeFileSync(join(root, path), 'export {}')
+ }
+
+ beforeEach(() => {
+ root = fs.mkdtempSync(join(tmpdir(), 'devup-ui-numbering-'))
+ write('src/b.tsx')
+ write('src/a.tsx')
+ write('src/nested/c.ts')
+ write('src/readme.md')
+ write('node_modules/@acme/ui/Button.tsx')
+ write('node_modules/@acme/ui/node_modules/dep/skipped.tsx')
+ })
+
+ afterEach(() => {
+ fs.rmSync(root, { recursive: true, force: true })
+ })
+
+ it('lists the project source and the included packages in path order', () => {
+ const files = collectNumberedFiles({
+ roots: [join(root, 'src'), join(root, 'missing')],
+ include: ['@acme/ui', 'not-installed'],
+ cwd: root,
+ })
+ expect(
+ files.map((file) => file.slice(file.indexOf('devup-ui-numbering-'))),
+ ).toEqual(
+ [...files]
+ .sort()
+ .map((file) => file.slice(file.indexOf('devup-ui-numbering-'))),
+ )
+ expect(files.filter((file) => file.includes('/src/'))).toHaveLength(3)
+ expect(files.some((file) => file.endsWith('/@acme/ui/Button.tsx'))).toBe(
+ true,
+ )
+ expect(files.some((file) => file.includes('skipped'))).toBe(false)
+ })
+
+ it('numbers only the files that mention what the build extracts', () => {
+ fs.writeFileSync(join(root, 'src/a.tsx'), "import '@devup-ui/react'")
+ const files = collectNumberedFiles({
+ roots: [join(root, 'src')],
+ cwd: root,
+ needles: extractedNeedles('@devup-ui/react', {
+ '@emotion/styled': 'styled',
+ }),
+ toId: (path) => path.slice(root.length).replaceAll('\\', '/'),
+ })
+ expect(files).toEqual(['/src/a.tsx'])
+ expect(extractedNeedles('p', { a: 1, b: 2 })).toEqual([
+ 'p',
+ '@stylexjs/stylex',
+ 'a',
+ 'b',
+ ])
+ })
+ it('does not depend on the order of the roots', () => {
+ const first = collectNumberedFiles({
+ roots: [join(root, 'src'), join(root, 'node_modules/@acme/ui')],
+ cwd: root,
+ })
+ const second = collectNumberedFiles({
+ roots: [join(root, 'node_modules/@acme/ui'), join(root, 'src')],
+ cwd: root,
+ })
+ expect(first).toEqual(second)
+ })
+
+ it.each([undefined, false, true])(
+ 'numbers project and included-package MDX only when includeMdx is true (%s)',
+ (includeMdx) => {
+ // Given source and package candidates with matching extraction needles.
+ write('src/docs/page.mdx')
+ write('node_modules/@acme/ui/Guide.mdx')
+ for (const path of [
+ 'src/a.tsx',
+ 'src/docs/page.mdx',
+ 'node_modules/@acme/ui/Button.tsx',
+ 'node_modules/@acme/ui/Guide.mdx',
+ ]) {
+ fs.writeFileSync(
+ join(root, path),
+ "import '@devup-ui/react'\n# Raw MDX",
+ )
+ }
+
+ // When numbering uses the plugin's deterministic extraction IDs.
+ const files = collectNumberedFiles({
+ roots: [join(root, 'src'), join(root, 'src/docs')],
+ include: ['@acme/ui'],
+ cwd: root,
+ needles: ['@devup-ui/react'],
+ ...(includeMdx === undefined ? {} : { includeMdx }),
+ toId: (path) => `id:${path.slice(root.length).replaceAll('\\', '/')}`,
+ })
+
+ // Then only explicit MDX extraction admits the raw MDX candidates.
+ expect(files).toEqual(
+ includeMdx
+ ? [
+ 'id:/node_modules/@acme/ui/Button.tsx',
+ 'id:/node_modules/@acme/ui/Guide.mdx',
+ 'id:/src/a.tsx',
+ 'id:/src/docs/page.mdx',
+ ]
+ : ['id:/node_modules/@acme/ui/Button.tsx', 'id:/src/a.tsx'],
+ )
+ },
+ )
+
+ it('excludes raw MDX before reading source for extraction needles', () => {
+ // Given uncompiled MDX that remains visible to the standalone scanner.
+ write('src/page.mdx')
+ fs.writeFileSync(
+ join(root, 'src/page.mdx'),
+ "import '@devup-ui/react'\n# <",
+ )
+ expect(
+ listSourceFiles(join(root, 'src'), [], { includeMdx: true }),
+ ).toContain(join(root, 'src/page.mdx'))
+ const read = spyOn(fs, 'readFileSync')
+ try {
+ // When a caller uses the default non-MDX extraction set.
+ const files = collectNumberedFiles({
+ roots: [join(root, 'src')],
+ needles: ['@devup-ui/react'],
+ })
+
+ // Then no MDX source read occurs and no MDX ID is numbered.
+ expect(files).toEqual([])
+ expect(
+ read.mock.calls.some(([path]) => path === join(root, 'src/page.mdx')),
+ ).toBe(false)
+ } finally {
+ read.mockRestore()
+ }
+ })
+
+ it('names files the way the plugin extracts them', () => {
+ const files = collectNumberedFiles({
+ roots: [join(root, 'src')],
+ cwd: root,
+ toId: (path) => `id:${path.slice(root.length).replaceAll('\\', '/')}`,
+ })
+ expect(files).toEqual([
+ 'id:/src/a.tsx',
+ 'id:/src/b.tsx',
+ 'id:/src/nested/c.ts',
+ ])
+ })
+})
+
+describe('seedFileNumbers', () => {
+ it('seeds files, and nothing when there are none', () => {
+ const seedFileMap = mock()
+ seedFileNumbers({ seedFileMap }, [])
+ expect(seedFileMap).not.toHaveBeenCalled()
+ seedFileNumbers({ seedFileMap }, ['a'])
+ expect(seedFileMap).toHaveBeenCalledWith(['a'])
+ })
+})
diff --git a/packages/plugin-utils/src/__tests__/oracle-scanner-fixtures.ts b/packages/plugin-utils/src/__tests__/oracle-scanner-fixtures.ts
new file mode 100644
index 000000000..bcfb9e530
--- /dev/null
+++ b/packages/plugin-utils/src/__tests__/oracle-scanner-fixtures.ts
@@ -0,0 +1,122 @@
+export const oracleScannerFixtures: readonly {
+ readonly code: string
+ readonly loader: 'js' | 'jsx' | 'ts' | 'tsx'
+ readonly edges: readonly string[]
+}[] = [
+ ...[
+ "const x = a < import('./real') > (b);",
+ "const x = a < import('./real') > b;",
+ "const x = a < import('./real') > (import('./body'));",
+ "const x = a < import('./real') > (b) / 2;",
+ "const x = a < import('./real') > (b); const node = import('phantom'){require('./required')}
;",
+ ].map((code) => ({
+ code,
+ loader: code.includes('') ? ('jsx' as const) : ('js' as const),
+ edges: code.includes('./required')
+ ? ['dynamic:./real', 'static:./required']
+ : code.includes('./body')
+ ? ['dynamic:./real', 'dynamic:./body']
+ : ['dynamic:./real'],
+ })),
+ ...[
+ "type X = string\nfoo(import('./real'));",
+ "type X = string\nvoid import('./real');",
+ "type X = string\n(() => import('./real'))();",
+ "type X = import('./types').T\nfoo(import('./real'));",
+ "type X = {x: import('./types').T}\n(() => import('./real'))();",
+ "type X = string /* newline\n */ foo(import('./real'));",
+ "type X =\n import('./types').T\n | import('./types').U\nfoo(import('./real'));",
+ "type X = T\n & import('./types').T\nvoid import('./real');",
+ "type X = import('./types').T\n['x']\nfoo(import('./real'));",
+ "type X = T extends\n import('./types').T\n ? import('./types').U\n : import('./types').V\nfoo(import('./real'));",
+ "type X = (x: import('./types').T)\n => import('./types').U\nfoo(import('./real'));",
+ "type X = \n(x: T) => import('./types').U\nfoo(import('./real'));",
+ "type X = typeof import('./types')\nfoo(import('./real'));",
+ "type X = keyof\n import('./types').T\nvoid import('./real');",
+ "type X = new\n(x: import('./types').T) => import('./types').U\nfoo(import('./real'));",
+ "let x: import('./types').T\nfoo(import('./real'));",
+ "const x = value as import('./types').T\nvoid import('./real');",
+ "const x = foo! as import('./types').T; import('./real');",
+ "const x = foo! satisfies import('./types').T; import('./real');",
+ "const x = import('./real')! as import('./types').T;",
+ "const x = import('./real')! satisfies import('./types').T;",
+ "const x = !import('./real') as import('./types').T;",
+ "const x = 'text' as import('./types').T; import('./real');",
+ "const x = {} satisfies import('./types').T; import('./real');",
+ "const x = foo! / import('./real');",
+ "const x = !import('./real');",
+ "const x = import('./real') as import('./types').T;",
+ "declare function f(): import('./types').T; import('./real');",
+ "declare function f(): import('./types').T; import('./real');",
+ "declare function f>(x: import('./types').T): import('./types').T; import('./real');",
+ "declare function f(): import('./types').T\nimport('./real');",
+ "function f(): import('./types').T; function f() {return import('./real')}",
+ "function f(x: import('./types').T = import('./real')): import('./types').T {return import('./body')}",
+ "const f = (x = import('./real')): import('./types').T => import('./body');",
+ "const x = f(import('./real'));",
+ "const x = ok ? (f()) : import('./real');",
+ "const x = a < import('./real') > b;",
+ "const x = import('./real');",
+ "const x = value / import('./real');",
+ ].map((code) => ({
+ code,
+ loader: 'ts' as const,
+ edges: code.includes('./body')
+ ? ['dynamic:./real', 'dynamic:./body']
+ : ['dynamic:./real'],
+ })),
+ ...[
+ "const x = foo! as import('./types').T;",
+ "const x = foo! satisfies import('./types').T;",
+ "declare function f
-