Entry Points

Entry points define which files Packem should process as the starting points for your build. Packem can automatically detect entry points from your package.json or you can configure them explicitly.

Basic Configuration

Single Entry Point

import { defineConfig } from '@visulima/packem/config'

export default defineConfig({
  entries: ['./src/index.ts']
})

Multiple Entry Points

export default defineConfig({
  entries: [
    './src/index.ts',
    './src/cli.ts',
    './src/worker.ts'
  ]
})

Entry Objects

export default defineConfig({
  entries: [
    {
      input: './src/index.ts',
      name: 'main'
    },
    {
      input: './src/cli.ts',
      name: 'cli',
      executable: true
    }
  ]
})

Automatic Detection

From Package.json Exports

If no entries are specified, Packem automatically detects them from your package.json:

{
  "exports": {
    ".": "./src/index.ts",
    "./utils": "./src/utils.ts",
    "./cli": "./src/cli.ts"
  }
}

This automatically creates entries for all export paths.

From Package.json Fields

{
  "main": "./src/index.ts",
  "module": "./src/index.ts",
  "bin": {
    "my-cli": "./src/cli.ts"
  }
}

Packem detects entries from:

main field
module field
bin field (marked as executable)
exports field

Entry Configuration Options

Entry Object Properties

export default defineConfig({
  entries: [
    {
      input: './src/index.ts',      // Source file path
      name: 'index',                // Output name
      outDir: './dist',             // Custom output directory
      runtime: 'node',              // Target runtime
      declaration: true,            // Generate .d.ts files
      executable: true,             // Add shebang for CLI tools
      cjs: true,                    // Generate CJS output
      esm: true                     // Generate ESM output
    }
  ]
})

Manual Entry Configuration

You can override automatic detection by specifying entries in your configuration file:

Simple String Entries

export default defineConfig({
  entries: [
    './src/index.ts',
    './src/cli.ts'
  ]
})

Object Entries

export default defineConfig({
  entries: [
    {
      input: './src/index.ts',
      name: 'main',
      runtime: 'node'
    },
    {
      input: './src/browser.ts', 
      name: 'browser',
      runtime: 'browser'
    }
  ]
})

Mixed Entries

export default defineConfig({
  entries: [
    './src/index.ts',           // Simple string
    {                           // Object configuration
      input: './src/cli.ts',
      name: 'cli',
      executable: true
    }
  ]
})

Glob Patterns

Use glob patterns to match multiple files:

export default defineConfig({
  entries: [
    './src/components/*.ts',
    './src/utils/**/*.ts'
  ]
})

Conditional Entries

Environment-Based

export default defineConfig({
  entries: [
    './src/index.ts',
    ...(process.env.NODE_ENV === 'development' ? ['./src/dev.ts'] : []),
    ...(process.env.BUILD_CLI === 'true' ? ['./src/cli.ts'] : [])
  ]
})

Feature Flags

export default defineConfig({
  entries: [
    './src/index.ts',
    ...(process.env.ENABLE_WORKER ? [
      {
        input: './src/worker.ts',
        name: 'worker',
        runtime: 'browser'
      }
    ] : [])
  ]
})

Runtime-Specific Entries

Node.js Entries

export default defineConfig({
  entries: [
    {
      input: './src/server.ts',
      name: 'server',
      runtime: 'node',
      cjs: true
    }
  ]
})

Browser Entries

export default defineConfig({
  entries: [
    {
      input: './src/client.ts',
      name: 'client', 
      runtime: 'browser',
      esm: true
    }
  ]
})

Universal Entries

export default defineConfig({
  entries: [
    {
      input: './src/universal.ts',
      name: 'universal',
      cjs: true,
      esm: true
    }
  ]
})

Output Configuration

Custom Output Directory

export default defineConfig({
  entries: [
    {
      input: './src/index.ts',
      outDir: './build'
    }
  ]
})

Per-Entry Output

export default defineConfig({
  entries: [
    {
      input: './src/core.ts',
      outDir: './dist/core'
    },
    {
      input: './src/utils.ts', 
      outDir: './dist/utils'
    }
  ]
})

TypeScript Declaration Files

Enable Declarations

export default defineConfig({
  entries: [
    {
      input: './src/index.ts',
      declaration: true
    }
  ]
})

Declaration Modes

export default defineConfig({
  entries: [
    {
      input: './src/index.ts',
      declaration: 'compatible'  // or 'node16'
    }
  ]
})

Executable Entries

CLI Tools

export default defineConfig({
  entries: [
    {
      input: './src/cli.ts',
      name: 'cli',
      executable: true
    }
  ]
})

This automatically:

Adds shebang (#!/usr/bin/env node)
Sets executable permissions
Configures for Node.js runtime

Monorepo Entries

Workspace Packages

export default defineConfig({
  entries: [
    {
      input: './packages/core/src/index.ts',
      name: 'core',
      outDir: './packages/core/dist'
    },
    {
      input: './packages/utils/src/index.ts',
      name: 'utils', 
      outDir: './packages/utils/dist'
    }
  ]
})

Cross-Package Dependencies

export default defineConfig({
  entries: [
    './packages/*/src/index.ts'
  ],
  
  rollup: {
    external: ['@myorg/core', '@myorg/utils']
  }
})

Advanced Patterns

Dynamic Entry Generation

import { glob } from 'glob'

const componentEntries = glob.sync('./src/components/*/index.ts').map(file => ({
  input: file,
  name: file.split('/').slice(-2, -1)[0]
}))

export default defineConfig({
  entries: [
    './src/index.ts',
    ...componentEntries
  ]
})

Entry Aliases

export default defineConfig({
  entries: [
    {
      input: './src/index.ts',
      fileAlias: 'main'
    }
  ]
})

Export Key Mapping

export default defineConfig({
  entries: [
    {
      input: './src/index.ts',
      exportKey: new Set(['.', './main'])
    }
  ]
})

Validation and Debugging

Entry Validation

Packem automatically validates entries:

Checks if source files exist
Warns about missing files
Validates entry configuration
Checks for conflicts

Debug Entry Detection

export default defineConfig({
  debug: true,  // Shows entry detection process
  entries: [
    './src/index.ts'
  ]
})

Troubleshooting

Entry Not Found

If Packem can't find your entry files, check the file paths and ensure they exist.

// ❌ Wrong - file doesn't exist
export default defineConfig({
  entries: ['./src/missing.ts']
})

// ✅ Correct - file exists
export default defineConfig({
  entries: ['./src/index.ts']
})

Conflicting Entries

// ❌ Wrong - same output name
export default defineConfig({
  entries: [
    { input: './src/a.ts', name: 'main' },
    { input: './src/b.ts', name: 'main' }  // Conflict!
  ]
})

// ✅ Correct - unique names
export default defineConfig({
  entries: [
    { input: './src/a.ts', name: 'a' },
    { input: './src/b.ts', name: 'b' }
  ]
})

Missing Package.json Exports

If automatic detection isn't working:

{
  "exports": {
    ".": "./src/index.ts"
  }
}

Or specify entries manually:

export default defineConfig({
  entries: ['./src/index.ts']
})

Output Format - Configure output formats
Output Directory - Control output locations
Declaration Files - TypeScript declarations
Externals - External dependencies

Entry Points

On this page

Contribute to our work and keep us going

Ready to help us out?

Submit a pull request

Good first issues