@b9g/libuild 0.1.10 → 0.1.12

package/src/libuild.cjs

@@ -215088,6 +215088,21 @@ function externalEntrypointsPlugin(options) {
           };
         }
       });
+      build3.onResolve({ filter: /^\.\.\/(?:src|bin)\// }, (args) => {
+        const withoutExt = args.path.replace(/\.(ts|js)$/, "");
+        const match = withoutExt.match(/^\.\.\/(?:src|bin)\/(.+)$/);
+        if (match) {
+          const entryName = match[1];
+          if (externalEntries.includes(entryName)) {
+            const dir = withoutExt.match(/^(\.\.\/(?:src|bin))\//)?.[1];
+            return {
+              path: `${dir}/${entryName}${outputExtension}`,
+              external: true
+            };
+          }
+        }
+        return void 0;
+      });
     }
   };
 }
@@ -215113,27 +215128,34 @@ function dtsPlugin(options) {
         let TS;
         try {
           TS = await Promise.resolve().then(() => __toESM(require_typescript(), 1));
-        } catch {
+        } catch (error) {
           return;
         }
         const tsFiles = entryFiles.filter((file) => {
           if (!file.endsWith(".ts"))
             return false;
           return options.entryPoints.some((entryPoint) => {
-            const normalizedEntry = Path2.resolve(entryPoint);
-            const normalizedFile = Path2.resolve(file);
-            return normalizedEntry === normalizedFile;
+            try {
+              const fs = require("fs");
+              const normalizedEntry = fs.realpathSync(Path2.resolve(entryPoint));
+              const normalizedFile = fs.realpathSync(Path2.resolve(file));
+              return normalizedEntry === normalizedFile;
+            } catch {
+              const normalizedEntry = Path2.resolve(entryPoint);
+              const normalizedFile = Path2.resolve(file);
+              return normalizedEntry === normalizedFile;
+            }
           });
         });
         if (tsFiles.length === 0) {
           return;
         }
         try {
+          await FS2.mkdir(options.outDir, { recursive: true });
           const compilerOptions = {
             declaration: true,
             emitDeclarationOnly: true,
             outDir: options.outDir,
-            rootDir: options.rootDir,
             skipLibCheck: true,
             esModuleInterop: true,
             target: TS.ScriptTarget.ES2020,
@@ -215208,6 +215230,38 @@ ${content}`;
 }
 
 // src/libuild.ts
+function generateRuntimeBanner(pkg) {
+  const prefersBun = pkg.engines?.bun !== void 0;
+  if (prefersBun) {
+    return '//bin/true; exec "$({ [ "${npm_config_user_agent#bun/}" != "$npm_config_user_agent" ] || true; } && command -v bun || command -v node)" "$0" "$@"';
+  } else {
+    return '//bin/true; exec "$([ "${npm_config_user_agent#bun/}" != "$npm_config_user_agent" ] && command -v bun || command -v node)" "$0" "$@"';
+  }
+}
+async function processJavaScriptExecutable(filePath, runtimeBanner) {
+  try {
+    const contents = await FS3.readFile(filePath, "utf8");
+    const lines = contents.split("\n");
+    let modified = false;
+    if (lines[0]?.startsWith("#!")) {
+      const existingShebang = lines[0];
+      if (existingShebang.includes("python") || existingShebang.includes("bash") || !existingShebang.includes("node") && !existingShebang.includes("bun") && !existingShebang.includes("sh")) {
+        console.warn(`\u26A0\uFE0F  WARNING: ${filePath} has non-JavaScript shebang but is a JS file. Adding dual runtime support.`);
+      }
+      lines[0] = "#!/usr/bin/env sh";
+      lines.splice(1, 0, runtimeBanner);
+      modified = true;
+    } else {
+      lines.unshift("#!/usr/bin/env sh", runtimeBanner);
+      modified = true;
+    }
+    if (modified) {
+      await FS3.writeFile(filePath, lines.join("\n"));
+    }
+  } catch (error) {
+    console.warn(`\u26A0\uFE0F  WARNING: Could not process executable ${filePath}: ${error.message}`);
+  }
+}
 function isValidEntrypoint(filename) {
   if (!filename.endsWith(".ts") && !filename.endsWith(".js"))
     return false;
@@ -215234,6 +215288,22 @@ async function findEntrypoints(srcDir) {
     return isValidEntrypoint(dirent.name);
   }).map((dirent) => Path3.basename(dirent.name, Path3.extname(dirent.name))).sort();
 }
+async function findBinEntrypoints(binDir) {
+  try {
+    const files = await FS3.readdir(binDir, { withFileTypes: true });
+    return files.filter((dirent) => {
+      if (dirent.isDirectory()) {
+        return false;
+      }
+      return isValidEntrypoint(dirent.name);
+    }).map((dirent) => Path3.basename(dirent.name, Path3.extname(dirent.name))).sort();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
 function detectMainEntry(pkg, entries) {
   function extractEntryFromPath(path) {
     const match = path.match(/\.\/src\/([^.]+)/);
@@ -215331,18 +215401,38 @@ function checkIfExportIsStale(exportKey, exportValue, entries) {
   }
   return entryName ? !entries.includes(entryName) : false;
 }
-function generateExports(entries, mainEntry, options, existingExports = {}) {
+async function generateExports(entries, mainEntry, options, existingExports = {}, distDir, allBinEntries = []) {
   const exports2 = {};
   const staleExports = [];
-  function createExportEntry(entry) {
-    const exportEntry = {
-      types: `./src/${entry}.d.ts`,
-      import: `./src/${entry}.js`
-    };
-    if (options.formats.cjs) {
-      exportEntry.require = `./src/${entry}.cjs`;
+  async function createExportEntry(entry) {
+    if (entry.startsWith("bin/")) {
+      const binEntry = entry.replace("bin/", "");
+      const exportEntry = {
+        import: `./bin/${binEntry}.js`
+      };
+      if (distDir) {
+        const dtsPath = Path3.join(distDir, "bin", `${binEntry}.d.ts`);
+        if (await fileExists(dtsPath)) {
+          exportEntry.types = `./bin/${binEntry}.d.ts`;
+        }
+      }
+      return exportEntry;
+    } else {
+      const exportEntry = {
+        import: `./src/${entry}.js`
+      };
+      if (distDir) {
+        const dtsPath = Path3.join(distDir, "src", `${entry}.d.ts`);
+        const exists = await fileExists(dtsPath);
+        if (exists) {
+          exportEntry.types = `./src/${entry}.d.ts`;
+        }
+      }
+      if (options.formats.cjs) {
+        exportEntry.require = `./src/${entry}.cjs`;
+      }
+      return exportEntry;
     }
-    return exportEntry;
   }
   function expandExistingExport(existing, entryFromPath) {
     if (typeof existing === "string") {
@@ -215416,7 +215506,7 @@ function generateExports(entries, mainEntry, options, existingExports = {}) {
     }
   }
   if (!exports2["."]) {
-    exports2["."] = createExportEntry(mainEntry);
+    exports2["."] = await createExportEntry(mainEntry);
   } else {
     exports2["."] = expandExistingExport(exports2["."], mainEntry);
   }
@@ -215425,7 +215515,7 @@ function generateExports(entries, mainEntry, options, existingExports = {}) {
       continue;
     const key = `./${entry}`;
     if (!exports2[key]) {
-      exports2[key] = createExportEntry(entry);
+      exports2[key] = await createExportEntry(entry);
     } else {
       exports2[key] = expandExistingExport(exports2[key], entry);
     }
@@ -215463,67 +215553,96 @@ function transformSrcToDist(value) {
   }
   return value;
 }
-async function validateBinPaths(value, srcDir, fieldName = "bin") {
+async function validateBinPaths(value, cwd, save, fieldName = "bin") {
   if (typeof value === "string") {
-    await validateSingleBinPath(value, fieldName, srcDir);
+    await validateSingleBinPath(value, fieldName, cwd, save);
   } else if (typeof value === "object" && value !== null) {
     for (const [key, val] of Object.entries(value)) {
       if (typeof val === "string") {
-        await validateSingleBinPath(val, `${fieldName}.${key}`, srcDir);
+        await validateSingleBinPath(val, `${fieldName}.${key}`, cwd, save);
       }
     }
   }
 }
-async function validateSingleBinPath(binPath, fieldName, srcDir) {
-  if (binPath.startsWith("dist/") || binPath.startsWith("./dist/")) {
+async function validateSingleBinPath(binPath, fieldName, cwd, save) {
+  if (save) {
+    return;
+  }
+  if (binPath.startsWith("dist/src/") || binPath.startsWith("./dist/src/") || binPath.startsWith("dist/bin/") || binPath.startsWith("./dist/bin/")) {
+    const fullPath2 = Path3.join(cwd, binPath);
+    const distExists = await fileExists(fullPath2);
+    if (distExists) {
+      return;
+    }
     let srcPath;
+    let sourceDir;
     if (binPath.startsWith("./dist/src/")) {
       srcPath = binPath.replace("./dist/src/", "src/");
+      sourceDir = "src";
     } else if (binPath.startsWith("dist/src/")) {
       srcPath = binPath.replace("dist/src/", "src/");
-    } else if (binPath.startsWith("./dist/")) {
-      srcPath = binPath.replace("./dist/", "src/");
-    } else if (binPath.startsWith("dist/")) {
-      srcPath = binPath.replace("dist/", "src/");
+      sourceDir = "src";
+    } else if (binPath.startsWith("./dist/bin/")) {
+      srcPath = binPath.replace("./dist/bin/", "bin/");
+      sourceDir = "bin";
+    } else if (binPath.startsWith("dist/bin/")) {
+      srcPath = binPath.replace("dist/bin/", "bin/");
+      sourceDir = "bin";
     } else {
-      srcPath = "";
+      srcPath = binPath;
+      sourceDir = "src";
     }
-    const basePath = srcPath.replace(/\.(js|cjs)$/, "");
-    const tsPath = Path3.join(srcDir, "..", basePath + ".ts");
-    const jsPath = Path3.join(srcDir, "..", basePath + ".js");
+    const basePath = srcPath.replace(/\.(js|cjs|mjs)$/, "");
+    const tsPath = Path3.join(cwd, basePath + ".ts");
+    const jsPath = Path3.join(cwd, basePath + ".js");
     const srcExists = await fileExists(tsPath) || await fileExists(jsPath);
     if (!srcExists) {
-      throw new Error(`${fieldName} field points to dist/ directory: "${binPath}"
-
-The bin field should reference source files that libuild will build and transform:
-  CORRECT:   "bin": {"tool": "src/cli.js"}
-  INCORRECT: "bin": {"tool": "dist/cli.js"}
-
-Libuild workflow:
-1. Point bin entries to src/ files
-2. Run 'libuild build --save' to update package.json with dist/ paths
-3. Set "private": true in your development package.json
-
-If you need to include pre-built executable files, use the files field instead:
-  "files": ["scripts/my-tool.js"]`);
+      console.warn(`\u26A0\uFE0F  WARNING: ${fieldName} field points to "${binPath}" but neither the dist file nor corresponding src file exists.
+   
+   Create "${srcPath}" and run 'libuild build --save' to update paths correctly.`);
+      return;
     }
-    console.warn(`\u26A0\uFE0F  WARNING: ${fieldName} field points to dist/ directory: "${binPath}"
+    console.warn(`\u26A0\uFE0F  WARNING: ${fieldName} field points to "${binPath}" which doesn't exist yet.
    
-   libuild is ZERO-CONFIG - there is no libuild.config.js file!
-   Configuration comes from your package.json fields.
+   Run 'libuild build' to create the dist files, or use 'libuild build --save' to update the path to "${srcPath}".`);
+    return;
+  }
+  if (binPath.startsWith("dist/") || binPath.startsWith("./dist/")) {
+    console.warn(`\u26A0\uFE0F  WARNING: ${fieldName} field points to "${binPath}" in dist/ directory.
    
-   The libuild workflow is to point bin entries to src/ files and use --save to update paths.
-   Consider changing to: "${srcPath}" and running 'libuild build --save'`);
+   libuild expects bin entries to point to src/ files. Consider changing to the corresponding src/ path and using --save.`);
     return;
   }
-  if (binPath.startsWith("src/") || binPath.startsWith("./src/")) {
+  const fullPath = Path3.join(cwd, binPath);
+  const pathExists = await fileExists(fullPath);
+  if (pathExists) {
     return;
   }
-  if (!binPath.startsWith("src/") && !binPath.startsWith("./src/")) {
-    console.warn(`\u26A0\uFE0F  WARNING: ${fieldName} field points to "${binPath}" which is not in src/ directory.
-   Consider moving executable to src/ or using the files field for pre-built scripts.
-   Run 'libuild build --save' after fixing to update paths correctly.`);
+  if (binPath.startsWith("src/") || binPath.startsWith("./src/") || binPath.startsWith("bin/") || binPath.startsWith("./bin/")) {
+    let normalizedPath = binPath.startsWith("./") ? binPath.slice(2) : binPath;
+    if (normalizedPath.startsWith("src/")) {
+      const srcRelativePath = normalizedPath.replace("src/", "");
+      if (srcRelativePath.includes("/")) {
+        console.warn(`\u26A0\uFE0F  WARNING: ${fieldName} field points to "${binPath}" which is in a subdirectory of src/.`);
+        console.warn(`   libuild only auto-detects top-level src/ files as entrypoints.`);
+        console.warn(`   Consider moving the file to the top-level src/ directory or use the bin/ directory for executables.`);
+      }
+    }
+    const basePath = fullPath.replace(/\.(js|cjs|mjs)$/, "");
+    const tsPath = basePath + ".ts";
+    const jsPath = basePath + ".js";
+    const tsExists = await fileExists(tsPath);
+    const jsExists = await fileExists(jsPath);
+    if (tsExists || jsExists) {
+      return;
+    }
   }
+  console.warn(`\u26A0\uFE0F  WARNING: ${fieldName} field points to "${binPath}" which doesn't exist
+   
+   libuild is ZERO-CONFIG - there is no libuild.config.js file!
+   Configuration comes from your package.json fields.
+   
+   Use 'libuild build --save' to update package.json with correct dist/ paths automatically.`);
 }
 function transformBinPaths(value) {
   if (typeof value === "string") {
@@ -215533,10 +215652,19 @@ function transformBinPaths(value) {
     if (value.startsWith("dist/src/")) {
       return value.replace("dist/", "");
     }
+    if (value.startsWith("./dist/bin/")) {
+      return value.replace("./dist/", "");
+    }
+    if (value.startsWith("dist/bin/")) {
+      return value.replace("dist/", "");
+    }
     if (value.startsWith("./src/")) {
       return value.replace("./", "");
     }
-    if (value.startsWith("src/") || value === "src") {
+    if (value.startsWith("./bin/")) {
+      return value.replace("./", "");
+    }
+    if (value.startsWith("src/") || value === "src" || value.startsWith("bin/") || value === "bin") {
       return value;
     }
     return value;
@@ -215581,7 +215709,103 @@ function fixExportsForDist(obj) {
   }
   return obj;
 }
-function cleanPackageJSON(pkg, mainEntry, options) {
+async function setExecutablePermissions(filePath) {
+  try {
+    await FS3.chmod(filePath, 493);
+  } catch (error) {
+    console.warn(`\u26A0\uFE0F  WARNING: Could not set executable permissions for ${filePath}: ${error.message}`);
+  }
+}
+async function makeFilesExecutable(pkg, cwd, allBinEntries) {
+  const filesToMakeExecutable = [];
+  if (pkg.bin) {
+    if (typeof pkg.bin === "string") {
+      filesToMakeExecutable.push(Path3.join(cwd, pkg.bin));
+    } else if (typeof pkg.bin === "object") {
+      for (const binPath of Object.values(pkg.bin)) {
+        if (typeof binPath === "string") {
+          filesToMakeExecutable.push(Path3.join(cwd, binPath));
+        }
+      }
+    }
+  }
+  for (const binEntryInfo of allBinEntries) {
+    const baseDir = binEntryInfo.source === "src" ? "dist/src/bin" : "dist/bin";
+    const jsPath = Path3.join(cwd, baseDir, `${binEntryInfo.name}.js`);
+    const cjsPath = Path3.join(cwd, baseDir, `${binEntryInfo.name}.cjs`);
+    if (!filesToMakeExecutable.includes(jsPath)) {
+      filesToMakeExecutable.push(jsPath);
+    }
+    if (!filesToMakeExecutable.includes(cjsPath)) {
+      filesToMakeExecutable.push(cjsPath);
+    }
+  }
+  for (const filePath of filesToMakeExecutable) {
+    if (await fileExists(filePath)) {
+      await setExecutablePermissions(filePath);
+    }
+  }
+}
+async function resolveWorkspaceDependencies(dependencies, cwd) {
+  if (!dependencies)
+    return void 0;
+  const resolved = {};
+  for (const [depName, depVersion] of Object.entries(dependencies)) {
+    if (depVersion.startsWith("workspace:")) {
+      const resolvedVersion = await resolveWorkspaceVersion(depName, depVersion, cwd);
+      resolved[depName] = resolvedVersion;
+    } else {
+      resolved[depName] = depVersion;
+    }
+  }
+  return resolved;
+}
+async function resolveWorkspaceVersion(packageName, workspaceSpec, cwd) {
+  try {
+    if (workspaceSpec === "workspace:*") {
+      const packageNameParts = packageName.replace("@", "").replace("/", "-");
+      const packageBaseName = packageName.split("/").pop() || packageName;
+      const possiblePaths = [
+        `../packages/${packageNameParts}/package.json`,
+        `../packages/${packageBaseName}/package.json`,
+        `../${packageNameParts}/package.json`,
+        `../${packageBaseName}/package.json`,
+        `./packages/${packageNameParts}/package.json`,
+        `./packages/${packageBaseName}/package.json`,
+        `./${packageNameParts}/package.json`,
+        `./${packageBaseName}/package.json`
+      ];
+      for (const pkgPath of possiblePaths) {
+        try {
+          const resolvedPath = Path3.resolve(cwd, pkgPath);
+          if (await fileExists(resolvedPath)) {
+            const pkgContent = await FS3.readFile(resolvedPath, "utf-8");
+            const pkgJson = JSON.parse(pkgContent);
+            if (pkgJson.name === packageName) {
+              console.info(`  Resolved workspace:* dependency "${packageName}" to ^${pkgJson.version}`);
+              return `^${pkgJson.version}`;
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+      console.warn(`\u26A0\uFE0F  WARNING: Could not resolve workspace dependency "${packageName}" - keeping as workspace:*`);
+      console.warn(`    Searched in: ${possiblePaths.map((p) => Path3.resolve(cwd, p)).join(", ")}`);
+      return workspaceSpec;
+    }
+    const versionPart = workspaceSpec.replace("workspace:", "");
+    if (versionPart !== "*") {
+      console.info(`  Resolved workspace:${versionPart} dependency "${packageName}" to ${versionPart}`);
+      return versionPart;
+    }
+    return workspaceSpec;
+  } catch (error) {
+    console.warn(`\u26A0\uFE0F  WARNING: Error resolving workspace dependency "${packageName}": ${error.message}`);
+    return workspaceSpec;
+  }
+}
+async function cleanPackageJSON(pkg, mainEntry, options, cwd, distDir) {
   const cleaned = {
     name: pkg.name,
     version: pkg.version
@@ -215632,6 +215856,8 @@ function cleanPackageJSON(pkg, mainEntry, options) {
         cleaned[field] = transformBinPaths(pkg[field]);
       } else if (pathFields.includes(field)) {
         cleaned[field] = transformSrcToDist(pkg[field]);
+      } else if (field === "dependencies" || field === "devDependencies" || field === "peerDependencies" || field === "optionalDependencies") {
+        cleaned[field] = await resolveWorkspaceDependencies(pkg[field], cwd);
       } else {
         cleaned[field] = pkg[field];
       }
@@ -215644,7 +215870,13 @@ function cleanPackageJSON(pkg, mainEntry, options) {
     cleaned.main = `src/${mainEntry}.cjs`;
   }
   cleaned.module = `src/${mainEntry}.js`;
-  cleaned.types = `src/${mainEntry}.d.ts`;
+  if (distDir) {
+    const dtsPath = Path3.join(distDir, "src", `${mainEntry}.d.ts`);
+    const exists = await fileExists(dtsPath);
+    if (exists) {
+      cleaned.types = `src/${mainEntry}.d.ts`;
+    }
+  }
   return cleaned;
 }
 async function fileExists(filePath) {
@@ -215681,7 +215913,7 @@ async function build2(cwd, save = false) {
   const pkgPath = Path3.join(cwd, "package.json");
   const pkg = JSON.parse(await FS3.readFile(pkgPath, "utf-8"));
   if (pkg.bin) {
-    await validateBinPaths(pkg.bin, srcDir, "bin");
+    await validateBinPaths(pkg.bin, cwd, save, "bin");
   }
   if (!pkg.private) {
     console.warn("\u26A0\uFE0F  WARNING: Root package.json is not private - this could lead to accidental publishing of development package.json");
@@ -215696,9 +215928,19 @@ async function build2(cwd, save = false) {
       console.warn("   Add 'dist/' to your .gitignore file");
     }
   }
-  const entries = await findEntrypoints(srcDir);
-  if (entries.length === 0) {
-    throw new Error("No entry points found in src/");
+  const binDir = Path3.join(cwd, "bin");
+  const srcEntries = await findEntrypoints(srcDir);
+  const binEntries = await findBinEntrypoints(binDir);
+  const allBinEntries = binEntries.map((entry) => ({ name: entry, source: "top-level" }));
+  const entries = [
+    ...srcEntries,
+    ...allBinEntries.map((entry) => `bin/${entry.name}`)
+  ];
+  if (srcEntries.length === 0 && allBinEntries.length === 0) {
+    throw new Error("No entry points found in src/ or bin/");
+  }
+  if (allBinEntries.length > 0) {
+    console.info(`  Found bin entries: ${allBinEntries.map((entry) => entry.name).join(", ")}`);
   }
   const options = {
     formats: {
@@ -215709,7 +215951,7 @@ async function build2(cwd, save = false) {
       umd: entries.includes("umd")
     }
   };
-  const mainEntry = detectMainEntry(pkg, entries);
+  const mainEntry = detectMainEntry(pkg, srcEntries);
   console.info("  Found entries:", entries.join(", "));
   console.info("  Main entry:", mainEntry);
   if (options.formats.cjs) {
@@ -215740,11 +215982,29 @@ async function build2(cwd, save = false) {
   const entryPoints = [];
   const umdEntries = [];
   for (const entry of entries) {
-    const entryPath = Path3.join(srcDir, `${entry}.ts`);
-    const jsEntryPath = Path3.join(srcDir, `${entry}.js`);
+    let entryPath;
+    let jsEntryPath;
+    let sourceDir;
+    if (entry.startsWith("bin/")) {
+      const binEntryName = entry.replace("bin/", "");
+      const binEntryInfo = allBinEntries.find((binEntry) => binEntry.name === binEntryName);
+      if (binEntryInfo?.source === "src") {
+        entryPath = Path3.join(srcDir, "bin", `${binEntryName}.ts`);
+        jsEntryPath = Path3.join(srcDir, "bin", `${binEntryName}.js`);
+        sourceDir = "src/bin/";
+      } else {
+        entryPath = Path3.join(binDir, `${binEntryName}.ts`);
+        jsEntryPath = Path3.join(binDir, `${binEntryName}.js`);
+        sourceDir = "bin/";
+      }
+    } else {
+      entryPath = Path3.join(srcDir, `${entry}.ts`);
+      jsEntryPath = Path3.join(srcDir, `${entry}.js`);
+      sourceDir = "src/";
+    }
     const actualPath = await fileExists(entryPath) ? entryPath : jsEntryPath;
     if (!await fileExists(actualPath)) {
-      throw new Error(`Entry point file not found: ${actualPath}. Expected ${entry}.ts or ${entry}.js in src/ directory.`);
+      throw new Error(`Entry point file not found: ${actualPath}. Expected ${entry.replace("bin/", "")}.ts or ${entry.replace("bin/", "")}.js in ${sourceDir} directory.`);
     }
     if (entry === "umd") {
       umdEntries.push(actualPath);
@@ -215752,58 +216012,107 @@ async function build2(cwd, save = false) {
       entryPoints.push(actualPath);
     }
   }
+  const srcEntryPoints = entryPoints.filter((path) => path.includes(srcDir));
+  const binEntryPoints = entryPoints.filter((path) => path.includes(binDir));
+  const distBinDir = Path3.join(distDir, "bin");
+  if (binEntryPoints.length > 0) {
+    await FS3.mkdir(distBinDir, { recursive: true });
+  }
   if (entryPoints.length > 0) {
-    const entryNames = entryPoints.map((path) => {
+    console.info(`  Building ${entryPoints.length} entries (ESM)...`);
+    const srcEntryNames = srcEntryPoints.map((path) => {
       const name = Path3.basename(path, Path3.extname(path));
       return name;
     });
-    console.info(`  Building ${entryPoints.length} entries (ESM)...`);
-    await ESBuild.build({
-      entryPoints,
-      outdir: distSrcDir,
-      format: "esm",
-      outExtension: { ".js": ".js" },
-      bundle: true,
-      minify: false,
-      sourcemap: false,
-      external: externalDeps,
-      platform: "node",
-      target: "node18",
-      packages: "external",
-      supported: { "import-attributes": true },
-      plugins: [
-        externalEntrypointsPlugin({
-          entryNames,
-          outputExtension: ".js"
-        }),
-        dtsPlugin({
-          outDir: distSrcDir,
-          rootDir: srcDir,
-          entryPoints
-        })
-      ]
+    const binEntryNames = binEntryPoints.map((path) => {
+      const name = Path3.basename(path, Path3.extname(path));
+      return name;
     });
-    if (options.formats.cjs) {
-      console.info(`  Building ${entryPoints.length} entries (CJS)...`);
+    const allESMEntryPoints = [...srcEntryPoints, ...binEntryPoints];
+    const allEntryNames = [...srcEntryNames, ...binEntryNames];
+    if (allESMEntryPoints.length > 0) {
       await ESBuild.build({
-        entryPoints,
-        outdir: distSrcDir,
-        format: "cjs",
-        outExtension: { ".js": ".cjs" },
+        entryPoints: allESMEntryPoints,
+        outdir: distDir,
+        outbase: cwd,
+        // Preserve src/ and bin/ directory structure
+        format: "esm",
+        outExtension: { ".js": ".js" },
         bundle: true,
         minify: false,
         sourcemap: false,
         external: externalDeps,
         platform: "node",
         target: "node18",
+        packages: "external",
         supported: { "import-attributes": true },
         plugins: [
           externalEntrypointsPlugin({
-            entryNames,
-            outputExtension: ".cjs"
-          })
+            entryNames: allEntryNames,
+            outputExtension: ".js"
+          }),
+          // Generate TypeScript declarations for src entries
+          ...srcEntryPoints.length > 0 ? [dtsPlugin({
+            outDir: distSrcDir,
+            rootDir: srcDir,
+            entryPoints: srcEntryPoints
+          })] : [],
+          // Generate TypeScript declarations for bin entries
+          ...binEntryPoints.length > 0 ? [dtsPlugin({
+            outDir: distBinDir,
+            rootDir: binDir,
+            entryPoints: binEntryPoints
+          })] : []
         ]
       });
+      if (binEntryPoints.length > 0) {
+        const runtimeBanner = generateRuntimeBanner(pkg);
+        for (const binEntryName of binEntryNames) {
+          const outputPath = Path3.join(distBinDir, `${binEntryName}.js`);
+          await processJavaScriptExecutable(outputPath, runtimeBanner);
+        }
+      }
+    }
+    if (options.formats.cjs) {
+      console.info(`  Building ${entryPoints.length} entries (CJS)...`);
+      if (srcEntryPoints.length > 0) {
+        try {
+          await ESBuild.build({
+            entryPoints: srcEntryPoints,
+            outdir: distSrcDir,
+            format: "cjs",
+            outExtension: { ".js": ".cjs" },
+            bundle: true,
+            minify: false,
+            sourcemap: false,
+            external: externalDeps,
+            platform: "node",
+            target: "node18",
+            supported: { "import-attributes": true },
+            plugins: [
+              externalEntrypointsPlugin({
+                entryNames: srcEntryNames,
+                outputExtension: ".cjs"
+              })
+            ]
+          });
+        } catch (error) {
+          const errorMessage = error.message || "";
+          const hasErrorsArray = error.errors && Array.isArray(error.errors);
+          const isTLAError = errorMessage.includes('Top-level await is currently not supported with the "cjs" output format') || hasErrorsArray && error.errors.some((e) => e.text && e.text.includes('Top-level await is currently not supported with the "cjs" output format'));
+          if (isTLAError) {
+            console.info(`
+\u26A0\uFE0F  Top-level await detected - CommonJS generation disabled`);
+            console.info(`   Top-level await is incompatible with CommonJS format`);
+            console.info(`   Building ESM-only (Node.js 14+ and modern bundlers supported)`);
+            console.info(`   To permanently disable CJS: remove "main" field from package.json
+`);
+            options.formats.cjs = false;
+          } else {
+            throw error;
+          }
+        }
+      }
     }
   }
   for (const umdPath of umdEntries) {
@@ -215826,8 +216135,8 @@ async function build2(cwd, save = false) {
   }
   const autoDiscoveredFiles = [];
   console.info("  Generating package.json...");
-  const cleanedPkg = cleanPackageJSON(pkg, mainEntry, options);
-  const exportsResult = generateExports(entries, mainEntry, options, pkg.exports);
+  const cleanedPkg = await cleanPackageJSON(pkg, mainEntry, options, cwd, distDir);
+  const exportsResult = await generateExports(entries, mainEntry, options, pkg.exports, distDir, allBinEntries);
   cleanedPkg.exports = fixExportsForDist(exportsResult.exports);
   if (exportsResult.staleExports.length > 0) {
     console.warn(`\u26A0\uFE0F  WARNING: Found ${exportsResult.staleExports.length} stale export(s) pointing to missing src/ files:`);
@@ -215928,7 +216237,10 @@ async function build2(cwd, save = false) {
       rootPkg2.main = `./dist/src/${mainEntry}.cjs`;
     }
     rootPkg2.module = `./dist/src/${mainEntry}.js`;
-    rootPkg2.types = `./dist/src/${mainEntry}.d.ts`;
+    const dtsPath = Path3.join(distDir, "src", `${mainEntry}.d.ts`);
+    if (await fileExists(dtsPath)) {
+      rootPkg2.types = `./dist/src/${mainEntry}.d.ts`;
+    }
     if (rootPkg2.typings && typeof rootPkg2.typings === "string") {
       rootPkg2.typings = rootPkg2.typings.startsWith("./dist/") ? rootPkg2.typings : "./" + Path3.join("dist", rootPkg2.typings);
     }
@@ -215959,6 +216271,27 @@ async function build2(cwd, save = false) {
       }
     }
     rootPkg2.exports = rootExports;
+    if (allBinEntries.length > 0) {
+      const generatedBin = {};
+      for (const binEntryInfo of allBinEntries) {
+        const binPath = binEntryInfo.source === "src" ? `./dist/src/bin/${binEntryInfo.name}.js` : `./dist/bin/${binEntryInfo.name}.js`;
+        const fullPath = Path3.join(cwd, binPath);
+        if (await fileExists(fullPath)) {
+          generatedBin[binEntryInfo.name] = binPath;
+        }
+      }
+      if (Object.keys(generatedBin).length > 0) {
+        if (rootPkg2.bin) {
+          if (typeof rootPkg2.bin === "string") {
+            const existingName = pkg.name?.split("/").pop() || "cli";
+            rootPkg2.bin = { [existingName]: rootPkg2.bin };
+          }
+          rootPkg2.bin = { ...rootPkg2.bin, ...generatedBin };
+        } else {
+          rootPkg2.bin = generatedBin;
+        }
+      }
+    }
     if (rootPkg2.bin) {
       if (typeof rootPkg2.bin === "string") {
         const distPath = rootPkg2.bin.startsWith("./dist/") ? rootPkg2.bin : rootPkg2.bin.startsWith("dist/") ? "./" + rootPkg2.bin : "./" + Path3.join("dist", rootPkg2.bin);
@@ -216021,6 +216354,9 @@ async function build2(cwd, save = false) {
   if (save) {
     rootPkg = JSON.parse(await FS3.readFile(pkgPath, "utf-8"));
   }
+  if (allBinEntries.length > 0 || pkg.bin) {
+    await makeFilesExecutable(pkg, cwd, allBinEntries);
+  }
   return { distPkg: fixedDistPkg, rootPkg };
 }
 async function publish(cwd, save = true, extraArgs = []) {