fix: resolve bare package imports against the "." exports subpath (#1276)

`resolveExportPath('')` — the call made for bare package imports like
`import x from 'foo'` — used to blindly prepend './' to the lookup key,
turning '' into './'. That never matched the '.' key stored in the
resolved exports map, so the export lookup silently returned zero paths.

In practice the bug was masked for packages that also declared a `main`
field, because `resolveSourceFile` falls back to `mainPaths` when the
exports lookup returns nothing and `exportPath === ''`. Packages that
only declared `exports` (no `main`) would not resolve their bare entry
point and the parser would fail to walk their dependency graph.

Normalize both '' and '.' to '.' so the lookup matches the canonical
'.' subpath key used by both the string-shorthand `exports: "./foo.js"`
form and the object form `exports: { ".": "./foo.js" }`. Subpath imports
(either bare 'sub' or './sub') continue to work unchanged.

Tests added:
- Plain string exports resolved via bare import
- Object exports with '.' key resolved via bare import
- Single-level conditional exports under '.' resolved via bare import
- Explicit '.' exportPath accepted
- Regression guard for non-bare subpath imports

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: thebiglabasky

packages/cli/src/services/check-parser/package-files/__tests__/package-json-file.spec.ts

@@ -278,5 +278,80 @@ describe('package.json file', () => {
       expect(paths).toHaveLength(1)
       expect(paths[0].target.path).toBe('./esm.mjs')
     })
+
+    // The resolver is called with exportPath = '' for bare package imports
+    // (e.g. `import x from 'foo'`), which should map to the "." subpath in
+    // the package's exports field. Before the fix, the prefix-prepending
+    // logic turned '' into './', which never matched the '.' key and made
+    // the export lookup silently return zero paths — masked at runtime by
+    // the main-field fallback for packages that also declared `main`.
+
+    it('resolves a plain string exports value on a bare import', () => {
+      const testFile = PackageJsonFile.make('/pkg/package.json', {
+        name: 'foo',
+        version: '1.0.0',
+        exports: './index.js',
+      })
+
+      const { paths } = testFile.resolveExportPath('', importConditions)
+
+      expect(paths).toHaveLength(1)
+      expect(paths[0].target.path).toBe('./index.js')
+    })
+
+    it('resolves the "." subpath on a bare import', () => {
+      const testFile = PackageJsonFile.make('/pkg/package.json', {
+        name: 'foo',
+        version: '1.0.0',
+        exports: {
+          '.': './lib/main.js',
+        },
+      })
+
+      const { paths } = testFile.resolveExportPath('', importConditions)
+
+      expect(paths).toHaveLength(1)
+      expect(paths[0].target.path).toBe('./lib/main.js')
+    })
+
+    it('resolves the "." subpath with single-level conditions on a bare import', () => {
+      const testFile = PackageJsonFile.make('/pkg/package.json', {
+        name: 'foo',
+        version: '1.0.0',
+        exports: {
+          '.': {
+            import: './lib/main.mjs',
+            require: './lib/main.cjs',
+            default: './lib/main.js',
+          },
+        } as any,
+      })
+
+      const importResult = testFile.resolveExportPath('', importConditions)
+      expect(importResult.paths).toHaveLength(1)
+      expect(importResult.paths[0].target.path).toBe('./lib/main.mjs')
+
+      const requireResult = testFile.resolveExportPath('', requireConditions)
+      expect(requireResult.paths).toHaveLength(1)
+      expect(requireResult.paths[0].target.path).toBe('./lib/main.cjs')
+    })
+
+    it('accepts "." as an explicit bare-import path', () => {
+      // Callers sometimes pass '.' directly instead of ''. Both should
+      // resolve the same root export without introducing a spurious './.'
+      // lookup.
+      const testFile = PackageJsonFile.make('/pkg/package.json', {
+        name: 'foo',
+        version: '1.0.0',
+        exports: {
+          '.': './index.js',
+        },
+      })
+
+      const { paths } = testFile.resolveExportPath('.', importConditions)
+
+      expect(paths).toHaveLength(1)
+      expect(paths[0].target.path).toBe('./index.js')
+    })
   })
 })

packages/cli/src/services/check-parser/package-files/package-json-file.ts

@@ -84,9 +84,19 @@ export class PackageJsonFile {
       this.#resolveExports(this.jsonFile.data.exports ?? {}, conditions),
     )
 
-    // Exports must always start with "./" - make sure that the path we're
-    // matching against also starts with that prefix.
-    if (!exportPath.startsWith('./')) {
+    // Normalize the export path to the canonical subpath form used by
+    // `exports` keys. Per the Node.js spec, the root subpath is "." and
+    // all other subpaths start with "./". An empty string means the bare
+    // package import (`import x from 'foo'`) and maps to the root subpath.
+    //
+    // Previously the code blindly prepended "./" to everything, turning
+    // "" into "./", which never matched the "." key and made bare imports
+    // silently resolve to zero paths. Packages that also declared `main`
+    // worked anyway because of the fallback in `resolveSourceFile`; other
+    // packages did not.
+    if (exportPath === '' || exportPath === '.') {
+      exportPath = '.'
+    } else if (!exportPath.startsWith('./')) {
       exportPath = `./${exportPath}`
     }