feat(treeshake-check): resolve entry from exports field

Adds resolveEntry() which reads the exports field (subpath map, flat
conditions, or bare string) before falling back to module/main.
Conditions priority: import > module > default. require-only exports
correctly return MissingEntryPoint rather than silently using a CJS path.

Author: ryanbas21

tools/treeshake-check/src/lib/analysis.test.ts

@@ -1,6 +1,11 @@
 // tools/treeshake-check/src/lib/analysis.test.ts
 import { describe, it, expect } from '@effect/vitest';
-import { detectCauses, buildModuleAnalysis, analyzePackageJsonHints } from './analysis.js';
+import {
+  detectCauses,
+  buildModuleAnalysis,
+  analyzePackageJsonHints,
+  resolveEntry,
+} from './analysis.js';
 
 // ─── detectCauses ─────────────────────────────────────────────────────────────
 
@@ -210,3 +215,73 @@ describe('analyzePackageJsonHints', () => {
     expect(hints.recommendations).toHaveLength(0);
   });
 });
+
+// ─── resolveEntry ─────────────────────────────────────────────────────────────
+
+describe('resolveEntry', () => {
+  // exports field — subpath map with conditions
+  it('reads import condition from exports["."]]', () => {
+    expect(
+      resolveEntry({
+        exports: { '.': { import: './dist/esm/index.js', require: './dist/cjs/index.js' } },
+      }),
+    ).toBe('./dist/esm/index.js');
+  });
+
+  it('reads module condition from exports["."] when import is absent', () => {
+    expect(
+      resolveEntry({
+        exports: { '.': { module: './dist/esm/index.js', require: './dist/cjs/index.js' } },
+      }),
+    ).toBe('./dist/esm/index.js');
+  });
+
+  it('reads default condition from exports["."] when no esm-specific condition', () => {
+    expect(resolveEntry({ exports: { '.': { default: './dist/index.js' } } })).toBe(
+      './dist/index.js',
+    );
+  });
+
+  // exports field — flat conditions (no subpath key)
+  it('reads import condition from flat exports object', () => {
+    expect(
+      resolveEntry({ exports: { import: './dist/esm/index.js', require: './dist/cjs/index.js' } }),
+    ).toBe('./dist/esm/index.js');
+  });
+
+  // exports field — bare string shorthand
+  it('reads bare string exports field', () => {
+    expect(resolveEntry({ exports: './dist/index.js' })).toBe('./dist/index.js');
+  });
+
+  // exports field takes priority over module/main
+  it('prefers exports over module and main', () => {
+    expect(
+      resolveEntry({
+        exports: { '.': { import: './esm/index.js' } },
+        module: './module/index.js',
+        main: './main/index.js',
+      }),
+    ).toBe('./esm/index.js');
+  });
+
+  // fallback chain
+  it('falls back to module when no exports field', () => {
+    expect(resolveEntry({ module: './dist/index.js', main: './dist/cjs/index.js' })).toBe(
+      './dist/index.js',
+    );
+  });
+
+  it('falls back to main when no exports or module field', () => {
+    expect(resolveEntry({ main: './dist/index.js' })).toBe('./dist/index.js');
+  });
+
+  it('returns undefined when no entry can be resolved', () => {
+    expect(resolveEntry({ name: 'no-entry' })).toBeUndefined();
+  });
+
+  // CJS-only exports should be skipped (require-only map with no default)
+  it('returns undefined for require-only exports map with no default', () => {
+    expect(resolveEntry({ exports: { '.': { require: './dist/cjs/index.js' } } })).toBeUndefined();
+  });
+});

tools/treeshake-check/src/lib/analysis.ts

@@ -28,6 +28,39 @@ const detectTopLevelCall = (code: string): boolean => {
   });
 };
 
+/**
+ * Resolve the ESM entry point from a package.json.
+ *
+ * Priority: exports["." | flat] → module → main
+ * Within the exports conditions, priority is: import → module → default
+ * Returns undefined when no usable ESM entry can be found (e.g. require-only).
+ */
+export const resolveEntry = (pkg: PackageJson): string | undefined => {
+  const { exports } = pkg;
+
+  if (exports !== undefined) {
+    if (typeof exports === 'string') return exports;
+
+    // exports is a record — determine whether it's a subpath map or flat conditions
+    const dotEntry = (exports as Record<string, unknown>)['.'];
+    const conditions: unknown = dotEntry !== undefined ? dotEntry : exports;
+
+    if (typeof conditions === 'string') return conditions;
+
+    if (conditions !== null && typeof conditions === 'object') {
+      const c = conditions as Record<string, unknown>;
+      const candidate = c['import'] ?? c['module'] ?? c['default'];
+      if (typeof candidate === 'string') return candidate;
+    }
+
+    // No usable ESM condition found in exports — don't fall through to module/main.
+    // Falling through would return a CJS path dressed as ESM.
+    return undefined;
+  }
+
+  return pkg.module ?? pkg.main;
+};
+
 export const detectCauses = (code: string): ReadonlyArray<SuspectedCause> => {
   const causes = new Set<SuspectedCause>();
 

tools/treeshake-check/src/lib/schemas.ts

@@ -5,10 +5,20 @@ import { Schema } from 'effect';
 
 export const SideEffectsValue = Schema.Union(Schema.Boolean, Schema.Array(Schema.String));
 
+// Conditions object: { import?: string, module?: string, require?: string, default?: string, ... }
+export const ExportsConditions = Schema.Record({
+  key: Schema.String,
+  value: Schema.Union(Schema.String, Schema.Unknown),
+});
+
+// exports field: string | conditions | { ".": conditions | string }
+export const ExportsField = Schema.Union(Schema.String, ExportsConditions);
+
 export const PackageJson = Schema.Struct({
   name: Schema.optional(Schema.String),
   module: Schema.optional(Schema.String),
   main: Schema.optional(Schema.String),
+  exports: Schema.optional(ExportsField),
   type: Schema.optional(Schema.Literal('module', 'commonjs')),
   sideEffects: Schema.optional(SideEffectsValue),
   dependencies: Schema.optional(Schema.Unknown),

tools/treeshake-check/src/lib/treeshake-check.test.ts

@@ -65,11 +65,33 @@ layer(NodeContext.layer)('getEntryFromPackageJson', (it) => {
     }),
   );
 
+  it.scoped('reads import condition from exports field', () =>
+    Effect.gen(function* () {
+      const dir = yield* writeTempPackage({
+        name: 'exports-pkg',
+        exports: { '.': { import: './dist/esm/index.js', require: './dist/cjs/index.js' } },
+      });
+      const result = yield* getEntryFromPackageJson(dir);
+      expect(result.entry).toBe('./dist/esm/index.js');
+    }),
+  );
+
   it.scoped('fails with MissingEntryPoint when neither module nor main are present', () =>
     Effect.gen(function* () {
       const dir = yield* writeTempPackage({ name: 'no-entry' });
       const error = yield* Effect.flip(getEntryFromPackageJson(dir));
       expect(error).toBeInstanceOf(MissingEntryPoint);
     }),
   );
+
+  it.scoped('fails with MissingEntryPoint when exports has only require condition', () =>
+    Effect.gen(function* () {
+      const dir = yield* writeTempPackage({
+        name: 'cjs-only',
+        exports: { '.': { require: './dist/cjs/index.js' } },
+      });
+      const error = yield* Effect.flip(getEntryFromPackageJson(dir));
+      expect(error).toBeInstanceOf(MissingEntryPoint);
+    }),
+  );
 });

tools/treeshake-check/src/lib/treeshake-check.ts

@@ -3,7 +3,12 @@ import { FileSystem, Path } from '@effect/platform';
 import { Data, Effect, Schema, pipe } from 'effect';
 import virtualPlugin from '@rollup/plugin-virtual';
 import { rollup, type RollupBuild } from 'rollup';
-import { analyzePackageJsonHints, buildModuleAnalysis, defaultHints } from './analysis.js';
+import {
+  analyzePackageJsonHints,
+  buildModuleAnalysis,
+  defaultHints,
+  resolveEntry,
+} from './analysis.js';
 import {
   PackageJsonFromString,
   type PackageJson,
@@ -51,7 +56,7 @@ export const getEntryFromPackageJson = (cwd?: string) =>
   pipe(
     readPackageJson(cwd ?? process.cwd()),
     Effect.flatMap(({ pkg, pkgPath }) => {
-      const entry = pkg.module ?? pkg.main;
+      const entry = resolveEntry(pkg);
       return entry !== undefined
         ? Effect.succeed({ entry, pkg } as const)
         : new MissingEntryPoint({ path: pkgPath });