bundlerbus 1.0.0

package/README.md

@@ -0,0 +1,351 @@
+# 📦🚍 Bundlerbus
+
+**Universal native bindings bundler for Bun's `--compile` flag**
+
+Bundlerbus solves the critical problem of compiling Bun projects that use native Node.js modules (like Sharp, Canvas, serialport, etc.) into single-file executables. Bun's built-in `--compile` flag fails when these libraries try to load `.node` bindings from the virtual filesystem.
+
+The only exception is better-sqlite3 that still didn't work.
+
+## The Problem
+
+```bash
+# This fails when your project uses Sharp, Canvas, or other native modules
+bun build --compile ./app.js --outfile ./app.exe
+
+# Error: Cannot find module '/path/to/$bunfs/node_modules/sharp/...'
+```
+
+Native modules expect to load binaries from a **real filesystem path**, but Bun's `$bunfs` is virtual.
+
+## The Solution
+
+Bundlerbus extracts your application and `node_modules` to a real directory at runtime (on first launch), then loads your code from there. Native bindings work perfectly because they see real filesystem paths.
+
+```bash
+# This works!
+bundlerbus ./app.js --outfile ./app.exe
+```
+
+## Installation
+
+```bash
+npm install -g bundlerbus
+
+# Or use with bunx (no installation)
+bunx bundlerbus ./app.js --outfile ./app.exe
+```
+
+## Usage
+
+Bundlerbus is a **drop-in replacement** for `bun build --compile`:
+
+```bash
+# Instead of:
+bun build --compile ./src/cli.js --target bun-windows-x64 --outfile ./dist/app.exe
+
+# Use:
+bundlerbus ./src/cli.js --target bun-windows-x64 --outfile ./dist/app.exe
+```
+
+All flags are forwarded directly to Bun, so it works with:
+- `--target` (platform selection)
+- `--outfile` (output path)
+- `--minify`, `--sourcemap`
+- `--define` (compile-time constants)
+- `--windows-icon`, `--windows-publisher`, etc.
+- Any future Bun flags
+
+## Entry Point Resolution
+
+Bundlerbus automatically detects your entry point using this priority:
+
+1. **Explicit argument:** `bundlerbus ./src/cli.js`
+2. **package.json "bin":** If you have a single binary defined
+3. **package.json "main":** Fallback to main entry
+4. **Convention:** Checks `./index.js` or `./src/index.js`
+
+### Multiple Binaries
+
+If your `package.json` has multiple bins:
+
+```json
+{
+  "bin": {
+    "app": "./src/cli.js",
+    "server": "./src/server.js"
+  }
+}
+```
+
+You must specify which one to build:
+
+```bash
+bundlerbus ./src/cli.js --outfile ./dist/app.exe
+bundlerbus ./src/server.js --outfile ./dist/server.exe
+```
+
+## What Gets Packed
+
+Bundlerbus respects the npm standard `package.json` "files" field:
+
+```json
+{
+  "files": [
+    "src/",
+    "templates/",
+    "config/"
+  ]
+}
+```
+
+This acts as a whitelist. Only these directories/files are packed into the executable (plus `node_modules` which is always included).
+
+### Standard Files
+
+These are always included (following npm conventions):
+- `package.json`
+- `README.md` / `README`
+- `LICENSE` / `LICENCE`
+- `NOTICE`
+
+### Always Excluded
+
+These are never packed:
+- `node_modules` (handled separately)
+- `.git`, `.github`
+- `.vscode`, `.idea`
+- `dist/`, `build/`
+- `*.log`
+- `.env` files
+
+### No "files" Field?
+
+If your `package.json` doesn't have a "files" field, Bundlerbus will:
+1. Pack the directory containing your entry point
+2. Show a warning suggesting you add the "files" field
+
+```bash
+[BUNDLER] Warning: No "files" field in package.json, packing src/
+```
+
+## How It Works
+
+Bundlerbus uses a three-stage approach:
+
+### 1. Build Time (Your Machine)
+
+```bash
+bundlerbus ./src/cli.js --outfile ./app.exe
+```
+
+- Packs your source files + `node_modules` into `payload.tar.gz`
+- Generates a `bootstrap.js` loader with your entry point injected
+- Calls `bun build --compile bootstrap.js` (with all your flags)
+- Cleans up temporary files
+
+### 2. First Run (User's Machine)
+
+```bash
+./app.exe
+```
+
+- Bootstrap extracts payload to OS-specific cache directory:
+  - **Windows:** `%LOCALAPPDATA%\your-app\1.0.0\`
+  - **macOS:** `~/Library/Application Support/your-app/1.0.0/`
+  - **Linux:** `~/.cache/your-app/1.0.0/`
+- Calculates MD5 hash of payload
+- Injects native library paths into `PATH`/`LD_LIBRARY_PATH`
+- Loads your entry point
+
+### 3. Subsequent Runs
+
+- Bootstrap compares payload hash
+- If unchanged, skips extraction (instant startup)
+- If changed (new version), re-extracts
+
+## Cache Management
+
+### Version Organization
+
+```
+AppData/
+  your-app/
+    1.0.0/          ← Current version
+      .hash         ← Payload hash (triggers re-extract)
+      node_modules/
+      src/
+    0.9.0/          ← Old version (still there)
+```
+
+Old versions accumulate but don't interfere. Users can manually delete old version folders if needed.
+
+### Cache Invalidation
+
+Cache is invalidated when:
+- Your code changes
+- Dependencies change
+- Anything in the payload changes
+
+This is **hash-based**, not version-based, so even if you forget to bump your version number, changes will trigger re-extraction.
+
+## Examples
+
+### Basic Usage
+
+```bash
+# Simple project
+bundlerbus ./index.js --outfile ./dist/app.exe
+
+# With minification
+bundlerbus ./src/main.js --minify --outfile ./build/app
+
+# Cross-compilation
+bundlerbus ./cli.js --target bun-windows-x64 --outfile ./dist/app-win.exe
+bundlerbus ./cli.js --target bun-darwin-arm64 --outfile ./dist/app-mac
+bundlerbus ./cli.js --target bun-linux-x64 --outfile ./dist/app-linux
+```
+
+### Real-World Project (THYPRESS)
+
+```javascript
+// build-exe.js
+import { execSync } from 'child_process';
+import pkg from './package.json' assert { type: 'json' };
+
+const configs = {
+  win32: {
+    flags: [
+      '--windows-icon=./icon.ico',
+      '--windows-publisher="THYPRESS™"',
+      `--windows-version="${pkg.version}"`,
+      '--target=bun-windows-x64',
+      '--outfile=./dist/THYPRESS-BINDER.exe'
+    ]
+  },
+  darwin: {
+    flags: [
+      '--target=bun-darwin-arm64',
+      '--outfile=./dist/thypress-binder-mac'
+    ]
+  }
+};
+
+const target = process.platform;
+const config = configs[target];
+
+const cmd = [
+  'bundlerbus ./src/cli.js',
+  `--define globalThis.__VERSION__='"${pkg.version}"'`,
+  ...config.flags
+].join(' ');
+
+execSync(cmd, { stdio: 'inherit' });
+```
+
+## Troubleshooting
+
+### Native Module Not Found
+
+```
+Error: Cannot find module 'sharp'
+```
+
+**Solution:** Ensure the module is in `dependencies` (not `devDependencies`) and run `npm install` before building.
+
+### Extraction Failed
+
+```
+[BOOTSTRAP] Fatal Error: EACCES: permission denied
+```
+
+**Solution:** User needs write access to:
+- Windows: `%LOCALAPPDATA%`
+- macOS: `~/Library/Application Support`
+- Linux: `~/.cache` or `$XDG_CACHE_HOME`
+
+### Wrong Entry Point
+
+```
+[FAILURE] Could not determine entry point
+```
+
+**Solution:** Specify entry point explicitly:
+
+```bash
+bundlerbus ./src/index.js [flags...]
+```
+
+Or add to `package.json`:
+
+```json
+{
+  "bin": "./src/cli.js"
+}
+```
+
+## Comparison to Bun's --compile
+
+| Feature | Bun --compile | Bundlerbus |
+|---------|---------------|------------|
+| Pure JS projects | ✅ Works | ✅ Works |
+| Native bindings (Sharp, Canvas) | ❌ Fails | ✅ Works |
+| Startup time | Instant | Slight delay on first run |
+| Distribution size | Smaller | Larger (includes full node_modules) |
+| Cache invalidation | N/A | Hash-based (robust) |
+| Flag compatibility | Native | Transparent forwarding |
+
+## Technical Details
+
+### Why Extraction Works
+
+Many native modules use `__dirname` or similar to locate their binaries:
+
+```javascript
+// Inside sharp/lib/constructor.js
+const libvips = require(path.join(__dirname, '../build/Release/sharp.node'));
+```
+
+In Bun's `$bunfs`, `__dirname` points to a fake path like:
+```
+$bunfs/node_modules/sharp/lib
+```
+
+Native code can't read from `$bunfs`. It needs a real path like:
+```
+C:\Users\Alice\AppData\Local\myapp\1.0.0\node_modules\sharp\lib
+```
+
+Bundlerbus provides that real path by extracting to disk.
+
+### Path Injection
+
+After extraction, Bundlerbus scans `node_modules` for `.dll`, `.so`, `.dylib`, `.node` files and injects their directories into:
+- **Windows:** `PATH`
+- **macOS:** `DYLD_LIBRARY_PATH`
+- **Linux:** `LD_LIBRARY_PATH`
+
+This ensures native binaries can find their dependencies.
+
+## Limitations
+
+- **First-run extraction:** Adds ~1-2 seconds on first launch
+- **Disk space:** Full `node_modules` is extracted (can be 100MB+)
+- **Write permissions:** Users need write access to cache directory
+
+These tradeoffs are acceptable for the **100% reliability** with native bindings.
+
+## Future Enhancements
+
+- [x] Glob pattern support in "files" field
+- [ ] Lazy extraction (only extract modules actually `require()`'d)
+- [ ] Delta updates (only re-extract changed files)
+- [ ] `bundlerbus clean` command to purge old caches
+- [ ] Compression options (brotli, zstd)
+
+## License
+
+MIT
+
+## Credits
+
+Inspired by Electron's ASAR format, but designed specifically for Bun's compilation model and native binding requirements. Cooked by [@phteocos](http://x.com/phteocos)

package/bootstrap.template.js

@@ -0,0 +1,104 @@
+// bootstrap.template.js
+import { existsSync, mkdirSync, writeFileSync, readdirSync, readFileSync, createWriteStream, rmSync, chmodSync } from 'fs';
+import { join, dirname, extname } from 'path';
+import { homedir } from 'os';
+import { createGunzip } from 'zlib';
+import { Readable } from 'stream';
+import tar from 'tar-stream';
+import { createHash } from 'crypto';
+
+// The embedded archive
+import payloadArchive from './payload.tar.gz' with { type: 'file' };
+
+const APP_NAME = '___BUNDLERBUS_APP_NAME___';
+const APP_VERSION = '___BUNDLERBUS_APP_VERSION___';
+
+function getCacheDir() {
+    const platform = process.platform;
+    if (platform === 'win32') {
+        return join(process.env.LOCALAPPDATA || join(homedir(), 'AppData', 'Local'), APP_NAME, APP_VERSION);
+    } else if (platform === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', APP_NAME, APP_VERSION);
+    } else {
+        // Linux / Unix (XDG Spec)
+        const base = process.env.XDG_CACHE_HOME || join(homedir(), '.cache');
+        return join(base, APP_NAME, APP_VERSION);
+    }
+}
+
+async function bootstrap() {
+    try {
+        const cacheDir = getCacheDir();
+        const payloadBuffer = readFileSync(payloadArchive);
+
+        const currentHash = createHash('md5').update(payloadBuffer).digest('hex');
+        const hashFile = join(cacheDir, '.hash');
+        const existingHash = existsSync(hashFile) ? readFileSync(hashFile, 'utf8') : null;
+
+        if (currentHash !== existingHash) {
+            console.log('[BOOTSTRAP] Unfolding environment...');
+            if (existsSync(cacheDir)) rmSync(cacheDir, { recursive: true, force: true });
+            mkdirSync(cacheDir, { recursive: true });
+
+            await new Promise((resolve, reject) => {
+                const extract = tar.extract();
+                extract.on('entry', (header, stream, next) => {
+                    const outPath = join(cacheDir, header.name);
+                    if (header.type === 'directory') {
+                        mkdirSync(outPath, { recursive: true });
+                        stream.resume(); next();
+                    } else {
+                        mkdirSync(dirname(outPath), { recursive: true });
+                        const outStream = createWriteStream(outPath);
+                        stream.pipe(outStream);
+                        outStream.on('finish', () => {
+                            // On Unix, ensure binaries are executable
+                            if (process.platform !== 'win32') {
+                                const isBin = outPath.endsWith('.node') || outPath.endsWith('.so') ||
+                                              outPath.endsWith('.dylib') || outPath.includes('bin/');
+                                if (isBin) chmodSync(outPath, 0o755);
+                            }
+                            next();
+                        });
+                        outStream.on('error', reject);
+                    }
+                });
+                extract.on('finish', resolve);
+                Readable.from(payloadBuffer).pipe(createGunzip()).pipe(extract);
+            });
+            writeFileSync(hashFile, currentHash);
+        }
+
+        // --- NATIVE SEARCH PATH INJECTION ---
+        const nodeModules = join(cacheDir, 'node_modules');
+        const libPaths = new Set();
+        const scan = (dir) => {
+            if (!existsSync(dir)) return;
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const e of entries) {
+                const p = join(dir, e.name);
+                if (e.isDirectory()) scan(p);
+                else if (['.dll', '.so', '.node', '.dylib'].includes(extname(e.name).toLowerCase())) {
+                    libPaths.add(dir);
+                }
+            }
+        };
+        scan(nodeModules);
+
+        const platform = process.platform;
+        const envVar = platform === 'win32' ? 'PATH' : (platform === 'darwin' ? 'DYLD_LIBRARY_PATH' : 'LD_LIBRARY_PATH');
+        const sep = platform === 'win32' ? ';' : ':';
+
+        // Inject native paths into the OS environment
+        process.env[envVar] = Array.from(libPaths).join(sep) + sep + (process.env[envVar] || '');
+
+        const entryPoint = join(cacheDir, '___BUNDLERBUS_ENTRY___');
+        await import(entryPoint);
+
+    } catch (err) {
+        console.error('[BOOTSTRAP] Fatal Error:', err);
+        process.exit(1);
+    }
+}
+
+bootstrap();

package/bundler.js

@@ -0,0 +1,169 @@
+// bundler.js
+import { createWriteStream, existsSync, readdirSync, statSync, lstatSync, readFileSync, rmSync } from 'fs';
+import { createGzip } from 'zlib';
+import tar from 'tar-stream';
+import { join, resolve, relative } from 'path';
+import { minimatch } from 'minimatch';
+
+// Standard files npm always includes implicitly
+const NPM_STANDARD_FILES = [
+    'package.json',
+    'README.md',
+    'README',
+    'LICENSE',
+    'LICENCE',
+    'NOTICE'
+];
+
+// Directories/files to always exclude from the scan
+const ALWAYS_EXCLUDE = [
+    '.git',
+    '.github',
+    '.vscode',
+    '.idea',
+    'dist',
+    'build',
+    '.DS_Store',
+    'Thumbs.db',
+    '*.log',
+    '.env',
+    '.env.local',
+    'payload.tar.gz',
+    'bootstrap.js'
+];
+
+export async function createPayload(packageJson, entryPoint) {
+    console.log('[BUNDLER] Creating payload...');
+
+    const pack = tar.pack();
+    const gzip = createGzip();
+    const output = createWriteStream('payload.tar.gz');
+
+    pack.pipe(gzip).pipe(output);
+
+    const processedPaths = new Set();
+    const root = process.cwd();
+
+    // Prepare Whitelist Patterns
+    const hasFilesField = packageJson.files && Array.isArray(packageJson.files);
+    const patterns = hasFilesField ? packageJson.files : ['**/*'];
+
+    /**
+     * Checks if a relative path matches the package.json "files" whitelist
+     */
+    function isWhitelisted(relPath) {
+        const normalizedRel = relPath.replace(/\\/g, '/');
+
+        return patterns.some(pattern => {
+            // 1. Glob match (e.g., "src/**/*.js")
+            if (minimatch(normalizedRel, pattern)) return true;
+
+            // 2. Directory prefix match (e.g., pattern "src" matches "src/app.js")
+            const dirPrefix = pattern.endsWith('/') ? pattern : `${pattern}/`;
+            if (normalizedRel.startsWith(dirPrefix)) return true;
+
+            return false;
+        });
+    }
+
+    /**
+     * Global exclusion filter
+     */
+    function isGlobalExcluded(path) {
+        const baseName = path.split(/[\\/]/).pop().toLowerCase();
+        for (const pattern of ALWAYS_EXCLUDE) {
+            if (pattern.startsWith('*')) {
+                const ext = pattern.substring(1);
+                if (baseName.endsWith(ext)) return true;
+            } else if (baseName === pattern || path.includes(`/${pattern}/`) || path.includes(`\\${pattern}\\`)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    function addEntry(localPath, archivePath) {
+        if (!existsSync(localPath)) return;
+
+        // 1. Prevent duplicate packing and circular refs
+        const normalized = resolve(localPath);
+        if (processedPaths.has(normalized)) return;
+        processedPaths.add(normalized);
+
+        // 2. Symlink protection (Fixes infinite loops in 'bun link')
+        const lstats = lstatSync(localPath);
+        if (lstats.isSymbolicLink()) return;
+
+        // 3. Skip global junk
+        if (isGlobalExcluded(localPath) && !localPath.endsWith('node_modules')) {
+            return;
+        }
+
+        const relPath = relative(root, localPath);
+        const stats = statSync(localPath);
+        const isDirectory = stats.isDirectory();
+        const isNodeModules = localPath.includes('node_modules');
+
+        // 4. Whitelist Enforcement
+        // Directories are always entered to find files, but files must be whitelisted
+        if (!isNodeModules && !isDirectory && !isWhitelisted(relPath)) {
+            const baseName = relPath.split(/[\\/]/).pop();
+            const isImplicit = NPM_STANDARD_FILES.includes(baseName) || relPath === 'package.json';
+            if (!isImplicit) return;
+        }
+
+        if (isDirectory) {
+            try {
+                const items = readdirSync(localPath);
+                for (const item of items) {
+                    addEntry(join(localPath, item), join(archivePath, item));
+                }
+            } catch (err) {
+                console.warn(`[BUNDLER] Could not read directory ${localPath}: ${err.message}`);
+            }
+        } else {
+            // 5. File Packing & Optimization
+            const ext = localPath.split('.').pop().toLowerCase();
+
+            // Slim down node_modules by skipping heavy source/map files
+            if (isNodeModules) {
+                const isJunk = ['map', 'ts', 'tsx', 'h', 'cpp', 'c', 'cc', 'md', 'txt'].includes(ext);
+                if (isJunk) return;
+            }
+
+            try {
+                const content = readFileSync(localPath);
+                // Ensure TAR internal paths always use forward slashes for cross-platform extraction
+                const tarPath = archivePath.replace(/\\/g, '/');
+                pack.entry({ name: tarPath, mode: stats.mode }, content);
+            } catch (err) {
+                console.warn(`[BUNDLER] Failed to pack file ${localPath}: ${err.message}`);
+            }
+        }
+    }
+
+    // PHASE 1: Scan Project Root (Filters via Whitelist)
+    const rootEntries = readdirSync('.');
+    for (const item of rootEntries) {
+        if (item === 'node_modules' || item === 'dist') continue;
+        addEntry(item, item);
+    }
+
+    // PHASE 2: Pack node_modules (Implicitly required for native bindings)
+    console.log('[BUNDLER] Packing node_modules...');
+    addEntry('./node_modules', 'node_modules');
+
+    pack.finalize();
+
+    await new Promise((resolve, reject) => {
+        output.on('finish', resolve);
+        output.on('error', reject);
+    });
+
+    console.log('[BUNDLER] Payload created: payload.tar.gz');
+}
+
+export function cleanupPayload() {
+    if (existsSync('payload.tar.gz')) rmSync('payload.tar.gz');
+    if (existsSync('bootstrap.js')) rmSync('bootstrap.js');
+}

package/cli.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+// cli.js
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createPayload, cleanupPayload } from './bundler.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function resolveEntryPoint(args) {
+    // Try package.json first
+    let packageJson = {};
+    if (existsSync('./package.json')) {
+        try {
+            packageJson = JSON.parse(readFileSync('./package.json', 'utf8'));
+        } catch (err) {
+            console.error('[FAILURE] Could not parse package.json:', err.message);
+            process.exit(1);
+        }
+    }
+
+    // Check for explicit entry point in args
+    const firstArg = args[0];
+
+    // If first arg looks like a file (ends with .js/.ts/.mjs), use it
+    if (firstArg && !firstArg.startsWith('-') && /\.(js|mjs|ts|tsx)$/.test(firstArg)) {
+        if (!existsSync(firstArg)) {
+            console.error(`[FAILURE] Entry point not found: ${firstArg}`);
+            process.exit(1);
+        }
+        return { entryPoint: firstArg, packageJson, bunFlags: args.slice(1) };
+    }
+
+    // No explicit entry, check package.json
+    let entryPoint = null;
+
+    // Check "bin" field
+    if (packageJson.bin) {
+        if (typeof packageJson.bin === 'string') {
+            entryPoint = packageJson.bin;
+        } else if (typeof packageJson.bin === 'object') {
+            const binEntries = Object.values(packageJson.bin);
+            if (binEntries.length === 1) {
+                entryPoint = binEntries[0];
+            } else if (binEntries.length > 1) {
+                console.error('[FAILURE] Multiple bin entries found in package.json');
+                console.error('Please specify entry point explicitly:');
+                console.error('  bundlerbus <entry-point> [bun-flags...]');
+                process.exit(1);
+            }
+        }
+    }
+
+    // Check "main" field
+    if (!entryPoint && packageJson.main) {
+        entryPoint = packageJson.main;
+    }
+
+    // Fallback checks
+    if (!entryPoint) {
+        const fallbacks = ['./index.js', './src/index.js', './main.js'];
+        for (const fallback of fallbacks) {
+            if (existsSync(fallback)) {
+                entryPoint = fallback;
+                break;
+            }
+        }
+    }
+
+    if (!entryPoint) {
+        console.error('[FAILURE] Could not determine entry point');
+        console.error('Please specify entry point explicitly:');
+        console.error('  bundlerbus <entry-point> [bun-flags...]');
+        console.error('Or add "bin" or "main" field to package.json');
+        process.exit(1);
+    }
+
+    return { entryPoint, packageJson, bunFlags: args };
+}
+
+function generateBootstrap(entryPoint, packageJson) {
+    const templatePath = resolve(__dirname, 'bootstrap.template.js');
+    const template = readFileSync(templatePath, 'utf8');
+
+    // Normalize entry point (remove leading ./)
+    const normalizedEntry = entryPoint.replace(/^\.\//, '');
+
+    // Get app metadata
+    const appName = packageJson.name || 'bundlerbus-app';
+    const appVersion = packageJson.version || '0.0.0';
+
+    // Replace placeholders
+    const bootstrap = template
+        .replace('___BUNDLERBUS_ENTRY___', normalizedEntry)
+        .replace('___BUNDLERBUS_APP_NAME___', appName)
+        .replace('___BUNDLERBUS_APP_VERSION___', appVersion);
+
+    writeFileSync('./bootstrap.js', bootstrap);
+    console.log('[SUCCESS] Generated bootstrap.js');
+}
+
+async function build() {
+    console.log('='.repeat(50));
+    console.log('BUNDLERBUS - Native Bindings Bundler');
+    console.log('='.repeat(50));
+
+    const args = process.argv.slice(2);
+
+    if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+        console.log(`
+Usage:
+  bundlerbus <entry-point> [bun-flags...]
+  bundlerbus [bun-flags...]
+
+Examples:
+  bundlerbus ./src/cli.js --target bun-windows-x64
+  bundlerbus ./index.js --outfile ./dist/app.exe --minify
+  bundlerbus --target bun-linux-x64 --outfile ./dist/app
+
+Entry Point Resolution:
+  1. First positional argument (if it's a .js/.ts file)
+  2. package.json "bin" field
+  3. package.json "main" field
+  4. Fallback to ./index.js or ./src/index.js
+
+All flags after the entry point are forwarded to 'bun build --compile'
+`);
+        process.exit(0);
+    }
+
+    try {
+        // Step 1: Resolve entry point
+        const { entryPoint, packageJson, bunFlags } = resolveEntryPoint(args);
+        console.log(`[INFO] Entry point: ${entryPoint}`);
+        console.log(`[INFO] App: ${packageJson.name}@${packageJson.version}`);
+
+        // Step 2: Create payload
+        await createPayload(packageJson, entryPoint);
+
+        // Step 3: Generate bootstrap
+        generateBootstrap(entryPoint, packageJson);
+
+        // Step 4: Build with Bun
+        console.log('[INFO] Compiling with Bun...');
+        const bunCmd = ['bun', 'build', '--compile', './bootstrap.js', ...bunFlags].join(' ');
+        console.log(`[INFO] Running: ${bunCmd}`);
+
+        execSync(bunCmd, { stdio: 'inherit' });
+
+        console.log('[SUCCESS] Build complete!');
+
+    } catch (err) {
+        console.error('[FAILURE] Build failed:', err.message);
+        process.exit(1);
+    } finally {
+        // Step 5: Cleanup
+        console.log('[INFO] Cleaning up temporary files...');
+        cleanupPayload();
+    }
+
+    console.log('='.repeat(50));
+}
+
+build();

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "bundlerbus",
+  "version": "1.0.0",
+  "description": "Universal native bindings bundler for Bun's --compile flag",
+  "type": "module",
+  "bin": {
+    "bundlerbus": "./cli.js"
+  },
+  "main": "./cli.js",
+  "files": [
+    "cli.js",
+    "bundler.js",
+    "bootstrap.template.js"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "bun",
+    "compile",
+    "native",
+    "bindings",
+    "bundler",
+    "sharp",
+    "sqlite",
+    "canvas",
+    "serialport",
+    "single-executable",
+    "packaging"
+  ],
+  "author": "Pedro Costa <pedrohenriqueteodorodacosta@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/phtdacosta/bundlerbus.git"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "bun": ">=1.0.0"
+  },
+  "bugs": {
+    "url": "https://github.com/phtdacosta/bundlerbus/issues"
+  },
+  "homepage": "https://github.com/phtdacosta/bundlerbus#readme",
+  "dependencies": {
+    "minimatch": "^10.1.1",
+    "tar-stream": "^3.1.7"
+  },
+  "peerDependencies": {},
+  "devDependencies": {}
+}