@mui/internal-code-infra 0.0.4-canary.56 → 0.0.4-canary.58

package/src/utils/build.test.mjs

@@ -1,9 +1,9 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
 import { makeTempDir } from './testUtils.mjs';
-import { createPackageBin, createPackageExports } from './build.mjs';
+import { createPackageBin, createPackageExports, createPackageImports } from './build.mjs';
 
 /**
  * @param {string} filePath
@@ -29,20 +29,22 @@ describe('createPackageExports', () => {
     ]);
 
     // Pass cjs before esm to verify the key order is still 'import' then 'require'
-    const { exports: packageExports } = await createPackageExports({
-      exports: {
+    const { exports: packageExports } = await createPackageExports(
+      {
         '.': './src/index.ts',
         './feature': './src/feature.ts',
       },
-      bundles: [
-        { type: 'cjs', dir: '.' },
-        { type: 'esm', dir: '.' },
-      ],
-      outputDir,
-      cwd,
-      isFlat: true,
-      packageType: 'module',
-    });
+      {
+        bundles: [
+          { type: 'cjs', dir: '.' },
+          { type: 'esm', dir: '.' },
+        ],
+        outputDir,
+        cwd,
+        isFlat: true,
+        packageType: 'module',
+      },
+    );
 
     expect(Object.keys(/** @type {Record<string, unknown>} */ (packageExports['.']))).toEqual([
       'import',
@@ -86,18 +88,20 @@ describe('createPackageExports', () => {
       exports: packageExports,
       main,
       types,
-    } = await createPackageExports({
-      exports: {
+    } = await createPackageExports(
+      {
         '.': './src/index.ts',
         './feature': './src/feature.ts',
       },
-      bundles,
-      outputDir,
-      cwd,
-      addTypes: true,
-      isFlat: true,
-      packageType: 'module',
-    });
+      {
+        bundles,
+        outputDir,
+        cwd,
+        addTypes: true,
+        isFlat: true,
+        packageType: 'module',
+      },
+    );
 
     expect(main).toBe('./index.cjs');
     expect(types).toBe('./index.d.cts');
@@ -123,17 +127,19 @@ describe('createPackageExports', () => {
       exports: packageExports2,
       main: main2,
       types: types2,
-    } = await createPackageExports({
-      exports: {
+    } = await createPackageExports(
+      {
         '.': './src/index.ts',
         './feature': './src/feature.ts',
       },
-      bundles: [bundles[1]], // only CJS bundle
-      outputDir,
-      cwd,
-      addTypes: true,
-      isFlat: true,
-    });
+      {
+        bundles: [bundles[1]], // only CJS bundle
+        outputDir,
+        cwd,
+        addTypes: true,
+        isFlat: true,
+      },
+    );
 
     expect(main2).toBe('./index.js');
     expect(types2).toBe('./index.d.ts');
@@ -181,17 +187,19 @@ describe('createPackageExports', () => {
         createFile(path.join(outputDir, 'TextField.d.cts')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
+      const { exports: packageExports } = await createPackageExports(
+        {
           './*': './src/*.ts',
         },
-        bundles,
-        outputDir,
-        cwd,
-        addTypes: true,
-        isFlat: true,
-        packageType: 'module',
-      });
+        {
+          bundles,
+          outputDir,
+          cwd,
+          addTypes: true,
+          isFlat: true,
+          packageType: 'module',
+        },
+      );
 
       expect(packageExports['./Button']).toEqual({
         import: { types: './Button.d.ts', default: './Button.js' },
@@ -227,17 +235,19 @@ describe('createPackageExports', () => {
         createFile(path.join(outputDir, 'Button.d.mts')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
+      const { exports: packageExports } = await createPackageExports(
+        {
           './*': './src/*.ts',
         },
-        bundles,
-        outputDir,
-        cwd,
-        addTypes: true,
-        isFlat: true,
-        packageType: 'commonjs',
-      });
+        {
+          bundles,
+          outputDir,
+          cwd,
+          addTypes: true,
+          isFlat: true,
+          packageType: 'commonjs',
+        },
+      );
 
       expect(packageExports['./Button']).toEqual({
         import: { types: './Button.d.mts', default: './Button.mjs' },
@@ -257,17 +267,19 @@ describe('createPackageExports', () => {
         createFile(path.join(outputDir, 'Button.d.ts')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
+      const { exports: packageExports } = await createPackageExports(
+        {
           './*': './src/*.ts',
         },
-        bundles: [{ type: 'cjs', dir: '.' }],
-        outputDir,
-        cwd,
-        addTypes: true,
-        isFlat: true,
-        packageType: 'commonjs',
-      });
+        {
+          bundles: [{ type: 'cjs', dir: '.' }],
+          outputDir,
+          cwd,
+          addTypes: true,
+          isFlat: true,
+          packageType: 'commonjs',
+        },
+      );
 
       expect(packageExports['./Button']).toEqual({
         require: { types: './Button.d.ts', default: './Button.js' },
@@ -275,7 +287,7 @@ describe('createPackageExports', () => {
       });
     });
 
-    it('expands glob patterns with mui-src object values', async () => {
+    it('rewrites source paths inside sibling conditions when expanding globs', async () => {
       const cwd = await makeTempDir();
       const outputDir = path.join(cwd, 'build');
       /**
@@ -288,30 +300,39 @@ describe('createPackageExports', () => {
 
       await Promise.all([
         createFile(path.join(cwd, 'src/Alert.ts')),
-
-        createFile(path.join(outputDir, 'Alert.js')),
-        createFile(path.join(outputDir, 'Alert.cjs')),
+        createFile(path.join(cwd, 'src/node/Alert.ts')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
-          './*': { 'mui-src': './src/*.ts' },
+      const { exports: packageExports } = await createPackageExports(
+        {
+          './*': { node: './src/node/*.ts', default: './src/*.ts' },
         },
-        bundles,
-        outputDir,
-        cwd,
-        isFlat: true,
-        packageType: 'module',
-      });
+        {
+          bundles,
+          outputDir,
+          cwd,
+          isFlat: true,
+          packageType: 'module',
+        },
+      );
 
+      // Every condition's source path is rewritten (no verbatim `./src/...`),
+      // and conditions stay outer with the import/require split at the leaves.
       expect(packageExports['./Alert']).toEqual({
-        import: './Alert.js',
-        require: './Alert.cjs',
-        default: './Alert.js',
+        node: {
+          import: './node/Alert.js',
+          require: './node/Alert.cjs',
+          default: './node/Alert.js',
+        },
+        default: {
+          import: './Alert.js',
+          require: './Alert.cjs',
+          default: './Alert.js',
+        },
       });
     });
 
-    it('preserves extra conditions from mui-src object values', async () => {
+    it('omits a sibling condition for stems its glob does not match', async () => {
       const cwd = await makeTempDir();
       const outputDir = path.join(cwd, 'build');
       /**
@@ -324,29 +345,97 @@ describe('createPackageExports', () => {
 
       await Promise.all([
         createFile(path.join(cwd, 'src/Alert.ts')),
-
-        createFile(path.join(outputDir, 'Alert.js')),
-        createFile(path.join(outputDir, 'Alert.cjs')),
+        createFile(path.join(cwd, 'src/Button.ts')),
+        // Only Alert has a node variant.
+        createFile(path.join(cwd, 'src/node/Alert.ts')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
-          './*': { 'mui-src': './src/*.ts', node: './src/node/*.ts' },
+      const { exports: packageExports } = await createPackageExports(
+        {
+          './*': { node: './src/node/*.ts', default: './src/*.ts' },
         },
-        bundles,
-        outputDir,
-        cwd,
-        isFlat: true,
-        packageType: 'module',
-      });
+        {
+          bundles,
+          outputDir,
+          cwd,
+          isFlat: true,
+          packageType: 'module',
+        },
+      );
 
+      // Alert keeps its node condition.
       expect(packageExports['./Alert']).toEqual({
-        import: { node: './src/node/*.ts', default: './Alert.js' },
-        require: { node: './src/node/*.ts', default: './Alert.cjs' },
-        default: './Alert.js',
+        node: {
+          import: './node/Alert.js',
+          require: './node/Alert.cjs',
+          default: './node/Alert.js',
+        },
+        default: { import: './Alert.js', require: './Alert.cjs', default: './Alert.js' },
+      });
+      // Button has no node variant, so the node condition is dropped rather than
+      // pointing at a non-existent source (which would fail the build).
+      expect(packageExports['./Button']).toEqual({
+        default: { import: './Button.js', require: './Button.cjs', default: './Button.js' },
+      });
+    });
+
+    it('enumerates a wildcard directory pattern', async () => {
+      const cwd = await makeTempDir();
+      const outputDir = path.join(cwd, 'build');
+
+      await Promise.all([
+        createFile(path.join(cwd, 'src/tabs/script.ts')),
+        createFile(path.join(cwd, 'src/menu/script.ts')),
+      ]);
+
+      const { exports: packageExports } = await createPackageExports(
+        {
+          './*': './src/*/script.ts',
+        },
+        {
+          bundles: [{ type: 'cjs', dir: '.' }],
+          outputDir,
+          cwd,
+          isFlat: true,
+        },
+      );
+
+      expect(packageExports['./tabs']).toEqual({
+        require: './tabs/script.js',
+        default: './tabs/script.js',
+      });
+      expect(packageExports['./menu']).toEqual({
+        require: './menu/script.js',
+        default: './menu/script.js',
       });
     });
 
+    it('warns and produces nothing when a glob matches no files', async () => {
+      const cwd = await makeTempDir();
+      const outputDir = path.join(cwd, 'build');
+      createFile(path.join(cwd, 'src/.gitkeep'));
+
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      try {
+        const { exports: packageExports } = await createPackageExports(
+          {
+            './*': './src/*.ts',
+          },
+          {
+            bundles: [{ type: 'cjs', dir: '.' }],
+            outputDir,
+            cwd,
+            isFlat: true,
+          },
+        );
+
+        expect(Object.keys(packageExports)).toEqual(['./package.json']);
+        expect(warn).toHaveBeenCalled();
+      } finally {
+        warn.mockRestore();
+      }
+    });
+
     it('mixes glob and non-glob exports', async () => {
       const cwd = await makeTempDir();
       const outputDir = path.join(cwd, 'build');
@@ -368,17 +457,19 @@ describe('createPackageExports', () => {
         createFile(path.join(outputDir, 'Chip.cjs')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
+      const { exports: packageExports } = await createPackageExports(
+        {
           '.': './src/index.ts',
           './*': './src/*.ts',
         },
-        bundles,
-        outputDir,
-        cwd,
-        isFlat: true,
-        packageType: 'module',
-      });
+        {
+          bundles,
+          outputDir,
+          cwd,
+          isFlat: true,
+          packageType: 'module',
+        },
+      );
 
       // Explicit export still works
       expect(packageExports['.']).toBeDefined();
@@ -411,16 +502,18 @@ describe('createPackageExports', () => {
         createFile(path.join(outputDir, 'utils/size.cjs')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
+      const { exports: packageExports } = await createPackageExports(
+        {
           './utils/*': './src/utils/*.ts',
         },
-        bundles,
-        outputDir,
-        cwd,
-        isFlat: true,
-        packageType: 'module',
-      });
+        {
+          bundles,
+          outputDir,
+          cwd,
+          isFlat: true,
+          packageType: 'module',
+        },
+      );
 
       expect(packageExports['./utils/color']).toEqual({
         import: './utils/color.js',
@@ -441,15 +534,17 @@ describe('createPackageExports', () => {
       // Create the src directory but no .ts files in it
       createFile(path.join(cwd, 'src/.gitkeep'));
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
+      const { exports: packageExports } = await createPackageExports(
+        {
           './*': './src/*.ts',
         },
-        bundles: [{ type: 'cjs', dir: '.' }],
-        outputDir,
-        cwd,
-        isFlat: true,
-      });
+        {
+          bundles: [{ type: 'cjs', dir: '.' }],
+          outputDir,
+          cwd,
+          isFlat: true,
+        },
+      );
 
       // Only the default ./package.json entry should be present
       expect(Object.keys(packageExports)).toEqual(['./package.json']);
@@ -469,15 +564,17 @@ describe('createPackageExports', () => {
         createFile(path.join(outputDir, 'Mango.js')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
+      const { exports: packageExports } = await createPackageExports(
+        {
           './*': './src/*.ts',
         },
-        bundles: [{ type: 'cjs', dir: '.' }],
-        outputDir,
-        cwd,
-        isFlat: true,
-      });
+        {
+          bundles: [{ type: 'cjs', dir: '.' }],
+          outputDir,
+          cwd,
+          isFlat: true,
+        },
+      );
 
       const exportKeys = Object.keys(packageExports).filter((k) => k !== './package.json');
       expect(exportKeys).toEqual(['./Apple', './Mango', './Zebra']);
@@ -507,17 +604,19 @@ describe('createPackageExports', () => {
         createFile(path.join(outputDir, 'ButtonBase.cjs')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
+      const { exports: packageExports } = await createPackageExports(
+        {
           './*': './src/*.ts',
           './Button*': null,
         },
-        bundles,
-        outputDir,
-        cwd,
-        isFlat: true,
-        packageType: 'module',
-      });
+        {
+          bundles,
+          outputDir,
+          cwd,
+          isFlat: true,
+          packageType: 'module',
+        },
+      );
 
       expect(packageExports['./Accordion']).toBeDefined();
       expect(packageExports['./Button']).toBeUndefined();
@@ -540,16 +639,18 @@ describe('createPackageExports', () => {
         createFile(path.join(outputDir, 'Button.js')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
+      const { exports: packageExports } = await createPackageExports(
+        {
           './*': './src/*.ts',
           './Alert*': null,
         },
-        bundles: [{ type: 'cjs', dir: '.' }],
-        outputDir,
-        cwd,
-        isFlat: true,
-      });
+        {
+          bundles: [{ type: 'cjs', dir: '.' }],
+          outputDir,
+          cwd,
+          isFlat: true,
+        },
+      );
 
       const exportKeys = Object.keys(packageExports).filter((k) => k !== './package.json');
       expect(exportKeys).toEqual(['./Button']);
@@ -564,16 +665,18 @@ describe('createPackageExports', () => {
         createFile(path.join(outputDir, 'Button.js')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
+      const { exports: packageExports } = await createPackageExports(
+        {
           './*': './src/*.ts',
           './internal/*': null,
         },
-        bundles: [{ type: 'cjs', dir: '.' }],
-        outputDir,
-        cwd,
-        isFlat: true,
-      });
+        {
+          bundles: [{ type: 'cjs', dir: '.' }],
+          outputDir,
+          cwd,
+          isFlat: true,
+        },
+      );
 
       // Button is kept since it doesn't match the negation
       expect(packageExports['./Button']).toBeDefined();
@@ -581,7 +684,7 @@ describe('createPackageExports', () => {
       expect(packageExports['./internal/*']).toBeNull();
     });
 
-    it('does not expand glob patterns when isFlat is false', async () => {
+    it('does not expand glob patterns when expand is false', async () => {
       const cwd = await makeTempDir();
       const outputDir = path.join(cwd, 'build');
 
@@ -590,15 +693,18 @@ describe('createPackageExports', () => {
         createFile(path.join(cwd, 'src/TextField.ts')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
+      const { exports: packageExports } = await createPackageExports(
+        {
           './*': './src/*.ts',
         },
-        bundles: [{ type: 'cjs', dir: '.' }],
-        outputDir,
-        cwd,
-        isFlat: false,
-      });
+        {
+          bundles: [{ type: 'cjs', dir: '.' }],
+          outputDir,
+          cwd,
+          isFlat: false,
+          expand: false,
+        },
+      );
 
       // Glob should NOT be expanded to individual files
       expect(packageExports['./Button']).toBeUndefined();
@@ -619,15 +725,17 @@ describe('createPackageExports', () => {
         createFile(path.join(outputDir, 'index.js')),
       ]);
 
-      const { exports: packageExports } = await createPackageExports({
-        exports: {
+      const { exports: packageExports } = await createPackageExports(
+        {
           './*': './src/index.ts',
         },
-        bundles: [{ type: 'cjs', dir: '.' }],
-        outputDir,
-        cwd,
-        isFlat: true,
-      });
+        {
+          bundles: [{ type: 'cjs', dir: '.' }],
+          outputDir,
+          cwd,
+          isFlat: true,
+        },
+      );
 
       // When the value has no *, the glob key is passed through as-is
       expect(packageExports['./*']).toBeDefined();
@@ -644,17 +752,19 @@ describe('createPackageExports', () => {
       createFile(path.join(outputDir, 'index.d.ts')),
     ]);
 
-    const { exports: packageExports } = await createPackageExports({
-      exports: {
+    const { exports: packageExports } = await createPackageExports(
+      {
         '.': './src/index.ts',
       },
-      bundles: [{ type: 'cjs', dir: '.' }],
-      outputDir,
-      cwd,
-      addTypes: true,
-      isFlat: true,
-      packageType: 'commonjs',
-    });
+      {
+        bundles: [{ type: 'cjs', dir: '.' }],
+        outputDir,
+        cwd,
+        addTypes: true,
+        isFlat: true,
+        packageType: 'commonjs',
+      },
+    );
 
     // Single CJS bundle should have both require and default pointing to the same files
     expect(packageExports['.']).toEqual({
@@ -670,6 +780,265 @@ describe('createPackageExports', () => {
   });
 });
 
+describe('createPackageExports leaf rewriting', () => {
+  it('rewrites a standard conditions object (conditions-outer)', async () => {
+    const cwd = await makeTempDir();
+    const outputDir = path.join(cwd, 'build');
+    /**
+     * @type {{ type: import('./build.mjs').BundleType; dir: string }[]}
+     */
+    const bundles = [
+      { type: 'esm', dir: '.' },
+      { type: 'cjs', dir: '.' },
+    ];
+
+    await Promise.all([
+      createFile(path.join(cwd, 'src/feature.ts')),
+      createFile(path.join(cwd, 'src/node/feature.ts')),
+    ]);
+
+    const { exports: packageExports } = await createPackageExports(
+      {
+        './feature': { node: './src/node/feature.ts', default: './src/feature.ts' },
+      },
+      {
+        bundles,
+        outputDir,
+        cwd,
+        isFlat: true,
+        packageType: 'module',
+      },
+    );
+
+    expect(packageExports['./feature']).toEqual({
+      node: {
+        import: './node/feature.js',
+        require: './node/feature.cjs',
+        default: './node/feature.js',
+      },
+      default: {
+        import: './feature.js',
+        require: './feature.cjs',
+        default: './feature.js',
+      },
+    });
+  });
+
+  it('passes through paths that are not under src/ verbatim', async () => {
+    const cwd = await makeTempDir();
+    const outputDir = path.join(cwd, 'build');
+
+    await Promise.all([
+      createFile(path.join(outputDir, 'assets/logo.svg')),
+      createFile(path.join(outputDir, 'vendor/legacy.js')),
+    ]);
+
+    const { exports: packageExports } = await createPackageExports(
+      {
+        './logo': './assets/logo.svg',
+        './legacy': './vendor/legacy.js',
+      },
+      {
+        bundles: [{ type: 'cjs', dir: '.' }],
+        outputDir,
+        cwd,
+        isFlat: true,
+      },
+    );
+
+    // Already present in the published output: emitted unchanged.
+    expect(packageExports['./logo']).toBe('./assets/logo.svg');
+    expect(packageExports['./legacy']).toBe('./vendor/legacy.js');
+  });
+
+  it('treats src/ without a leading ./ as a source path', async () => {
+    const cwd = await makeTempDir();
+    const outputDir = path.join(cwd, 'build');
+
+    await createFile(path.join(cwd, 'src/index.ts'));
+
+    const { exports: packageExports } = await createPackageExports(
+      {
+        './entry': 'src/index.ts',
+      },
+      {
+        bundles: [{ type: 'cjs', dir: '.' }],
+        outputDir,
+        cwd,
+        isFlat: true,
+      },
+    );
+
+    expect(packageExports['./entry']).toEqual({
+      require: './index.js',
+      default: './index.js',
+    });
+  });
+
+  it('rewrites the prefix of a non-JS asset under src/ without an extension swap', async () => {
+    const cwd = await makeTempDir();
+    const outputDir = path.join(cwd, 'build');
+
+    await createFile(path.join(cwd, 'src/theme.css'));
+
+    const { exports: packageExports } = await createPackageExports(
+      {
+        './theme.css': './src/theme.css',
+      },
+      {
+        bundles: [{ type: 'cjs', dir: '.' }],
+        outputDir,
+        cwd,
+        isFlat: true,
+      },
+    );
+
+    expect(packageExports['./theme.css']).toBe('./theme.css');
+  });
+
+  it('preserves a user-authored default alongside import/require conditions', async () => {
+    const cwd = await makeTempDir();
+    const outputDir = path.join(cwd, 'build');
+    /**
+     * @type {{ type: import('./build.mjs').BundleType; dir: string }[]}
+     */
+    const bundles = [
+      { type: 'esm', dir: '.' },
+      { type: 'cjs', dir: '.' },
+    ];
+
+    await Promise.all([
+      createFile(path.join(cwd, 'src/esm.ts')),
+      createFile(path.join(cwd, 'src/fallback.ts')),
+    ]);
+
+    const { exports: packageExports } = await createPackageExports(
+      {
+        './x': { import: './src/esm.ts', default: './src/fallback.ts' },
+      },
+      {
+        bundles,
+        outputDir,
+        cwd,
+        isFlat: true,
+        packageType: 'module',
+      },
+    );
+
+    // The synthesized default must not clobber the user's `default` branch.
+    expect(packageExports['./x']).toEqual({
+      import: { import: './esm.js', require: './esm.cjs', default: './esm.js' },
+      default: { import: './fallback.js', require: './fallback.cjs', default: './fallback.js' },
+    });
+  });
+});
+
+describe('createPackageExports resolution semantics', () => {
+  /**
+   * Seeds the worked example with files so the shallow and deep patterns match.
+   * @param {string} cwd
+   */
+  async function seedWorkedExample(cwd) {
+    await Promise.all([
+      createFile(path.join(cwd, 'src/foo/x.ts')),
+      createFile(path.join(cwd, 'src/foo/bar/baz/z.ts')),
+    ]);
+  }
+
+  const workedExampleExports = {
+    './foo/*': './src/foo/*.ts',
+    './foo/bar/*': null,
+    './foo/bar/baz/*': './src/foo/bar/baz/*.ts',
+  };
+
+  it('enumerates with Node-faithful, non-cascading negation (expand: true)', async () => {
+    const cwd = await makeTempDir();
+    const outputDir = path.join(cwd, 'build');
+    await seedWorkedExample(cwd);
+
+    const { exports: packageExports } = await createPackageExports(workedExampleExports, {
+      bundles: [{ type: 'cjs', dir: '.' }],
+      outputDir,
+      cwd,
+      isFlat: true,
+    });
+
+    // ./foo/x resolves (matched only by the shallow pattern)
+    expect(packageExports['./foo/x']).toEqual({
+      require: './foo/x.js',
+      default: './foo/x.js',
+    });
+    // ./foo/bar/baz/z resolves even though it sits under the null'd ./foo/bar/*
+    expect(packageExports['./foo/bar/baz/z']).toEqual({
+      require: './foo/bar/baz/z.js',
+      default: './foo/bar/baz/z.js',
+    });
+    // nothing whose most-specific match is the null is emitted as a concrete entry
+    expect(packageExports['./foo/bar/z']).toBeUndefined();
+    // the null pattern is carried through to keep blocking its subtree at runtime
+    expect(packageExports['./foo/bar/*']).toBeNull();
+  });
+
+  it('keeps patterns and the null verbatim (expand: false)', async () => {
+    const cwd = await makeTempDir();
+    const outputDir = path.join(cwd, 'build');
+    await seedWorkedExample(cwd);
+
+    const { exports: packageExports } = await createPackageExports(workedExampleExports, {
+      bundles: [{ type: 'cjs', dir: '.' }],
+      outputDir,
+      cwd,
+      isFlat: true,
+      expand: false,
+    });
+
+    expect(packageExports['./foo/*']).toEqual({
+      require: './foo/*.js',
+      default: './foo/*.js',
+    });
+    expect(packageExports['./foo/bar/baz/*']).toEqual({
+      require: './foo/bar/baz/*.js',
+      default: './foo/bar/baz/*.js',
+    });
+    expect(packageExports['./foo/bar/*']).toBeNull();
+  });
+
+  it('lets an exact key win over a matching pattern', async () => {
+    const cwd = await makeTempDir();
+    const outputDir = path.join(cwd, 'build');
+
+    await Promise.all([
+      createFile(path.join(cwd, 'src/Other.ts')),
+      createFile(path.join(cwd, 'src/override.ts')),
+    ]);
+
+    const { exports: packageExports } = await createPackageExports(
+      {
+        // Exact key collides with what `./*` would expand to, but points elsewhere.
+        './Other': './src/override.ts',
+        './*': './src/*.ts',
+      },
+      {
+        bundles: [{ type: 'cjs', dir: '.' }],
+        outputDir,
+        cwd,
+        isFlat: true,
+      },
+    );
+
+    // The exact key keeps its own target rather than the pattern's stem.
+    expect(packageExports['./Other']).toEqual({
+      require: './override.js',
+      default: './override.js',
+    });
+    // The pattern still expands its other matches.
+    expect(packageExports['./override']).toEqual({
+      require: './override.js',
+      default: './override.js',
+    });
+  });
+});
+
 describe('createPackageBin', () => {
   it('prefers the ESM bundle when available', async () => {
     const cwd = await makeTempDir();
@@ -683,8 +1052,7 @@ describe('createPackageBin', () => {
 
     await Promise.all([createFile(path.join(cwd, 'src/cli.ts'))]);
 
-    let bin = await createPackageBin({
-      bin: './src/cli.ts',
+    let bin = await createPackageBin('./src/cli.ts', {
       bundles,
       cwd,
       isFlat: true,
@@ -693,8 +1061,7 @@ describe('createPackageBin', () => {
 
     expect(bin).toBe('./cli.js');
 
-    bin = await createPackageBin({
-      bin: './src/cli.ts',
+    bin = await createPackageBin('./src/cli.ts', {
       bundles: [bundles[1]], // only CJS bundle
       cwd,
       isFlat: true,
@@ -702,8 +1069,7 @@ describe('createPackageBin', () => {
 
     expect(bin).toBe('./cli.js');
 
-    bin = await createPackageBin({
-      bin: './src/cli.ts',
+    bin = await createPackageBin('./src/cli.ts', {
       bundles, // only CJS bundle
       cwd,
       isFlat: true,
@@ -713,3 +1079,206 @@ describe('createPackageBin', () => {
     expect(bin).toBe('./cli.mjs');
   });
 });
+
+describe('createPackageImports', () => {
+  it('returns undefined when there is no imports field', async () => {
+    const cwd = await makeTempDir();
+
+    const imports = await createPackageImports(undefined, {
+      bundles: [{ type: 'esm', dir: '.' }],
+      cwd,
+      isFlat: true,
+      packageType: 'module',
+    });
+
+    expect(imports).toBeUndefined();
+  });
+
+  it('throws when an import key does not start with "#"', async () => {
+    const cwd = await makeTempDir();
+
+    await expect(
+      createPackageImports(
+        /** @type {any} */ ({
+          'internal/utils': './src/internal/utils.ts',
+        }),
+        {
+          bundles: [{ type: 'esm', dir: '.' }],
+          cwd,
+          isFlat: true,
+          packageType: 'module',
+        },
+      ),
+    ).rejects.toThrow('must start with "#"');
+  });
+
+  it('rewrites internal subpath imports for a dual bundle module package', async () => {
+    const cwd = await makeTempDir();
+    const outputDir = path.join(cwd, 'build');
+    /**
+     * @type {{ type: import('./build.mjs').BundleType; dir: string }[]}
+     */
+    const bundles = [
+      { type: 'esm', dir: '.' },
+      { type: 'cjs', dir: '.' },
+    ];
+
+    await Promise.all([
+      createFile(path.join(cwd, 'src/internal/utils.ts')),
+      createFile(path.join(outputDir, 'internal/utils.js')),
+      createFile(path.join(outputDir, 'internal/utils.cjs')),
+      createFile(path.join(outputDir, 'internal/utils.d.ts')),
+      createFile(path.join(outputDir, 'internal/utils.d.cts')),
+    ]);
+
+    const imports = await createPackageImports(
+      {
+        '#internal/utils': './src/internal/utils.ts',
+      },
+      {
+        bundles,
+        cwd,
+        addTypes: true,
+        isFlat: true,
+        packageType: 'module',
+      },
+    );
+
+    expect(imports).toEqual({
+      '#internal/utils': {
+        import: { types: './internal/utils.d.ts', default: './internal/utils.js' },
+        require: { types: './internal/utils.d.cts', default: './internal/utils.cjs' },
+        default: { types: './internal/utils.d.ts', default: './internal/utils.js' },
+      },
+    });
+  });
+
+  it('puts import before require regardless of bundle array order', async () => {
+    const cwd = await makeTempDir();
+    const outputDir = path.join(cwd, 'build');
+
+    await Promise.all([
+      createFile(path.join(cwd, 'src/internal/utils.ts')),
+      createFile(path.join(outputDir, 'internal/utils.js')),
+      createFile(path.join(outputDir, 'internal/utils.cjs')),
+    ]);
+
+    const imports = await createPackageImports(
+      {
+        '#internal/utils': './src/internal/utils.ts',
+      },
+      {
+        // Pass cjs before esm to verify the key order is still 'import' then 'require'
+        bundles: [
+          { type: 'cjs', dir: '.' },
+          { type: 'esm', dir: '.' },
+        ],
+        cwd,
+        isFlat: true,
+        packageType: 'module',
+      },
+    );
+
+    expect(
+      Object.keys(/** @type {Record<string, unknown>} */ (imports?.['#internal/utils'])),
+    ).toEqual(['import', 'require', 'default']);
+  });
+
+  it('passes bare specifiers through unchanged', async () => {
+    const cwd = await makeTempDir();
+
+    const imports = await createPackageImports(
+      {
+        '#error-formatter': '@custom/error-formatter',
+      },
+      {
+        bundles: [
+          { type: 'esm', dir: '.' },
+          { type: 'cjs', dir: '.' },
+        ],
+        cwd,
+        isFlat: true,
+        packageType: 'module',
+      },
+    );
+
+    expect(imports).toEqual({
+      '#error-formatter': '@custom/error-formatter',
+    });
+  });
+
+  it('expands glob patterns in import keys and values', async () => {
+    const cwd = await makeTempDir();
+    const outputDir = path.join(cwd, 'build');
+
+    await Promise.all([
+      createFile(path.join(cwd, 'src/internal/foo.ts')),
+      createFile(path.join(cwd, 'src/internal/bar.ts')),
+      createFile(path.join(outputDir, 'internal/foo.js')),
+      createFile(path.join(outputDir, 'internal/bar.js')),
+    ]);
+
+    const imports = await createPackageImports(
+      {
+        '#internal/*': './src/internal/*.ts',
+      },
+      {
+        bundles: [{ type: 'esm', dir: '.' }],
+        cwd,
+        isFlat: true,
+        packageType: 'module',
+      },
+    );
+
+    expect(imports).toEqual({
+      '#internal/bar': { import: './internal/bar.js', default: './internal/bar.js' },
+      '#internal/foo': { import: './internal/foo.js', default: './internal/foo.js' },
+    });
+  });
+
+  it('rewrites every condition of a conditions object (conditions-outer)', async () => {
+    const cwd = await makeTempDir();
+    /**
+     * @type {{ type: import('./build.mjs').BundleType; dir: string }[]}
+     */
+    const bundles = [
+      { type: 'esm', dir: '.' },
+      { type: 'cjs', dir: '.' },
+    ];
+
+    await Promise.all([
+      createFile(path.join(cwd, 'src/internal/utils.ts')),
+      createFile(path.join(cwd, 'src/internal/node/utils.ts')),
+    ]);
+
+    const imports = await createPackageImports(
+      {
+        '#internal/utils': {
+          node: './src/internal/node/utils.ts',
+          default: './src/internal/utils.ts',
+        },
+      },
+      {
+        bundles,
+        cwd,
+        isFlat: true,
+        packageType: 'module',
+      },
+    );
+
+    expect(imports).toEqual({
+      '#internal/utils': {
+        node: {
+          import: './internal/node/utils.js',
+          require: './internal/node/utils.cjs',
+          default: './internal/node/utils.js',
+        },
+        default: {
+          import: './internal/utils.js',
+          require: './internal/utils.cjs',
+          default: './internal/utils.js',
+        },
+      },
+    });
+  });
+});