@b9g/libuild 0.1.3 → 0.1.5

package/src/libuild.js

@@ -1,13 +1,939 @@
 /// <reference types="./libuild.d.ts" />
-import {
-  build,
-  publish,
-  transformSrcToDist
-} from "./chunk-YRPHTAV4.js";
-import "./chunk-EVLPGECD.js";
+// src/libuild.ts
+import * as FS3 from "fs/promises";
+import * as Path3 from "path";
+import { spawn } from "child_process";
+import * as ESBuild from "esbuild";
+
+// src/plugins/umd.ts
+import * as FS from "fs/promises";
+import * as Path from "path";
+function umdPlugin(options) {
+  return {
+    name: "umd",
+    setup(build3) {
+      build3.onEnd(async (result) => {
+        if (result.errors.length > 0)
+          return;
+        const outputDir = build3.initialOptions.outdir;
+        if (outputDir) {
+          const files = await FS.readdir(outputDir);
+          for (const file of files) {
+            if (file.endsWith(".js") && !file.endsWith(".js.map")) {
+              await wrapWithUMD(Path.join(outputDir, file), options.globalName);
+            }
+          }
+        }
+      });
+    }
+  };
+}
+async function wrapWithUMD(filePath, globalName) {
+  const code = await FS.readFile(filePath, "utf-8");
+  let modifiedCode = code.replace(/\nmodule\.exports\s*=\s*([^;]+);?\s*$/, "\nreturn $1;");
+  const umdHeader = `(function (root, factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD
+    define([], factory);
+  } else if (typeof module === 'object' && module.exports) {
+    // CommonJS
+    module.exports = factory();
+  } else {
+    // Browser globals
+    root.${globalName} = factory();
+  }
+}(typeof self !== 'undefined' ? self : this, function () {
+`;
+  const umdFooter = `
+}));`;
+  const result = umdHeader + modifiedCode + umdFooter;
+  await FS.writeFile(filePath, result);
+}
+
+// src/plugins/external.ts
+function externalEntrypointsPlugin(options) {
+  return {
+    name: "external-entrypoints",
+    setup(build3) {
+      const { entryNames, currentEntry, outputExtension } = options;
+      const externalEntries = currentEntry ? entryNames.filter((name) => name !== currentEntry) : entryNames;
+      build3.onResolve({ filter: /^\.\// }, (args) => {
+        const withoutExt = args.path.replace(/\.(ts|js)$/, "");
+        const entryName = withoutExt.replace(/^\.\//, "");
+        if (externalEntries.includes(entryName)) {
+          return {
+            path: `./${entryName}${outputExtension}`,
+            external: true
+          };
+        }
+      });
+    }
+  };
+}
+
+// src/plugins/dts.ts
+import * as FS2 from "fs/promises";
+import * as Path2 from "path";
+function dtsPlugin(options) {
+  return {
+    name: "dts",
+    setup(build3) {
+      const entryFiles = [];
+      build3.onLoad({ filter: /\.tsx?$/ }, async (args) => {
+        if (!entryFiles.includes(args.path)) {
+          entryFiles.push(args.path);
+        }
+        return void 0;
+      });
+      build3.onEnd(async (result) => {
+        if (result.errors.length > 0) {
+          return;
+        }
+        let TS;
+        try {
+          TS = await import("typescript");
+        } catch {
+          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;
+          });
+        });
+        if (tsFiles.length === 0) {
+          return;
+        }
+        try {
+          const compilerOptions = {
+            declaration: true,
+            emitDeclarationOnly: true,
+            outDir: options.outDir,
+            rootDir: options.rootDir,
+            skipLibCheck: true,
+            esModuleInterop: true,
+            target: TS.ScriptTarget.ES2020,
+            module: TS.ModuleKind.ESNext,
+            isolatedModules: true,
+            // Prevent cross-file type dependencies
+            noResolve: true
+            // Don't resolve imports - only process the specific files
+          };
+          const program = TS.createProgram(tsFiles, compilerOptions);
+          const emitResult = program.emit();
+          if (emitResult.diagnostics.length > 0) {
+            const diagnostics = TS.formatDiagnosticsWithColorAndContext(emitResult.diagnostics, {
+              getCanonicalFileName: (path) => path,
+              getCurrentDirectory: () => process.cwd(),
+              getNewLine: () => "\n"
+            });
+            result.errors.push({
+              id: "typescript-declarations",
+              pluginName: "dts",
+              text: `TypeScript declaration generation failed:
+${diagnostics}`,
+              location: null,
+              notes: [],
+              detail: void 0
+            });
+          }
+        } catch (error) {
+          result.errors.push({
+            id: "typescript-plugin-error",
+            pluginName: "dts",
+            text: `TypeScript plugin error: ${error.message}`,
+            location: null,
+            notes: [],
+            detail: void 0
+          });
+        }
+        await addTripleSlashReferences(tsFiles, options.outDir);
+      });
+    }
+  };
+}
+async function addTripleSlashReferences(tsFiles, outDir) {
+  for (const tsFile of tsFiles) {
+    const baseName = Path2.basename(tsFile, Path2.extname(tsFile));
+    const jsPath = Path2.join(outDir, `${baseName}.js`);
+    const dtsPath = Path2.join(outDir, `${baseName}.d.ts`);
+    const [jsExists, dtsExists] = await Promise.all([
+      FS2.access(jsPath).then(() => true).catch(() => false),
+      FS2.access(dtsPath).then(() => true).catch(() => false)
+    ]);
+    if (!jsExists || !dtsExists)
+      continue;
+    const content = await FS2.readFile(jsPath, "utf-8");
+    const referenceComment = `/// <reference types="./${baseName}.d.ts" />`;
+    let modifiedContent;
+    if (content.startsWith("#!")) {
+      const firstNewline = content.indexOf("\n");
+      if (firstNewline !== -1) {
+        modifiedContent = content.slice(0, firstNewline + 1) + `${referenceComment}
+` + content.slice(firstNewline + 1);
+      } else {
+        modifiedContent = content + `
+${referenceComment}`;
+      }
+    } else {
+      modifiedContent = `${referenceComment}
+${content}`;
+    }
+    await FS2.writeFile(jsPath, modifiedContent);
+  }
+}
+
+// src/libuild.ts
+function isValidEntrypoint(filename) {
+  if (!filename.endsWith(".ts") && !filename.endsWith(".js"))
+    return false;
+  if (filename.endsWith(".d.ts"))
+    return false;
+  if (filename.startsWith("_"))
+    return false;
+  if (filename.startsWith("."))
+    return false;
+  return true;
+}
+async function findEntrypoints(srcDir) {
+  const files = await FS3.readdir(srcDir);
+  return files.filter(isValidEntrypoint).map((file) => Path3.basename(file, Path3.extname(file))).sort();
+}
+function detectMainEntry(pkg, entries) {
+  function extractEntryFromPath(path) {
+    const match = path.match(/\.\/src\/([^.]+)/);
+    return match ? match[1] : void 0;
+  }
+  if (pkg.exports && pkg.exports["."]) {
+    const dotExport = pkg.exports["."];
+    let importPath;
+    if (typeof dotExport === "string") {
+      importPath = dotExport;
+    } else if (typeof dotExport === "object" && dotExport.import) {
+      importPath = dotExport.import;
+    }
+    if (importPath) {
+      const entry = extractEntryFromPath(importPath);
+      if (entry && entries.includes(entry)) {
+        return entry;
+      }
+    }
+  }
+  if (pkg.main && typeof pkg.main === "string") {
+    const mainBase = Path3.basename(pkg.main, Path3.extname(pkg.main));
+    if (entries.includes(mainBase)) {
+      return mainBase;
+    }
+  }
+  if (pkg.module && typeof pkg.module === "string") {
+    const moduleBase = Path3.basename(pkg.module, Path3.extname(pkg.module));
+    if (entries.includes(moduleBase)) {
+      return moduleBase;
+    }
+  }
+  if (entries.includes("index")) {
+    return "index";
+  }
+  if (entries.length === 1) {
+    return entries[0];
+  }
+  const pkgNameParts = pkg.name.split("/");
+  const pkgName = pkgNameParts[pkgNameParts.length - 1];
+  if (!pkgName) {
+    throw new Error(`Invalid package name: ${pkg.name}`);
+  }
+  if (entries.includes(pkgName)) {
+    return pkgName;
+  }
+  return entries[0];
+}
+function checkIfExportIsStale(exportKey, exportValue, entries) {
+  if (exportKey === "./package.json" || typeof exportValue === "string" && (exportValue === "./package.json" || exportValue.endsWith("/package.json"))) {
+    return false;
+  }
+  let entryName;
+  let hasInvalidPath = false;
+  if (typeof exportValue === "string") {
+    if (exportValue.match(/\.\/src\/.*\/.*\.(ts|js)$/)) {
+      hasInvalidPath = true;
+    } else {
+      const match = exportValue.match(/\.\/src\/([^/]+)\.(ts|js)$/);
+      if (match) {
+        const filename = match[1] + "." + match[2];
+        if (!isValidEntrypoint(filename)) {
+          hasInvalidPath = true;
+        } else {
+          entryName = match[1];
+        }
+      }
+    }
+  } else if (typeof exportValue === "object" && exportValue !== null) {
+    const importPath = exportValue.import || exportValue.require;
+    if (typeof importPath === "string") {
+      if (importPath.match(/\.\/src\/.*\/.*\.(ts|js|cjs)$/)) {
+        hasInvalidPath = true;
+      } else {
+        const match = importPath.match(/\.\/src\/([^/]+)\.(ts|js|cjs)$/);
+        if (match) {
+          const filename = match[1] + "." + match[2].replace("cjs", "js");
+          if (!isValidEntrypoint(filename)) {
+            hasInvalidPath = true;
+          } else {
+            entryName = match[1];
+          }
+        }
+      }
+    }
+  }
+  if (!entryName && !hasInvalidPath && exportKey.startsWith("./") && exportKey !== ".") {
+    const keyName = exportKey.slice(2).replace(/\.js$/, "");
+    if (keyName && !keyName.includes("/")) {
+      entryName = keyName;
+    }
+  }
+  if (hasInvalidPath) {
+    return false;
+  }
+  return entryName ? !entries.includes(entryName) : false;
+}
+function generateExports(entries, mainEntry, options, existingExports = {}) {
+  const exports = {};
+  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`;
+    }
+    return exportEntry;
+  }
+  function expandExistingExport(existing, entryFromPath) {
+    var _a;
+    if (typeof existing === "string") {
+      if (existing === "./package.json" || existing.endsWith("/package.json")) {
+        return existing;
+      }
+      const match = existing.match(/\.\/src\/([^/]+\.(?:ts|js))$/);
+      if (match) {
+        const filename = match[1];
+        if (!isValidEntrypoint(filename)) {
+          throw new Error(`Export path '${existing}' references '${filename}' which is not a valid entrypoint. Valid entrypoints cannot start with '_' or '.' and must be .ts/.js files in src/.`);
+        }
+        const entry = Path3.basename(filename, Path3.extname(filename));
+        return options.formats.cjs ? {
+          types: `./src/${entry}.d.ts`,
+          import: existing,
+          require: `./src/${entry}.cjs`
+        } : {
+          types: `./src/${entry}.d.ts`,
+          import: existing
+        };
+      }
+      if (entryFromPath) {
+        return options.formats.cjs ? {
+          types: `./src/${entryFromPath}.d.ts`,
+          import: existing,
+          require: `./src/${entryFromPath}.cjs`
+        } : {
+          types: `./src/${entryFromPath}.d.ts`,
+          import: existing
+        };
+      }
+      throw new Error(`Export path '${existing}' must point to a valid entrypoint in src/ (e.g., './src/utils.js'). Nested directories and internal files (starting with '_' or '.') are not allowed.`);
+    } else if (typeof existing === "object" && existing !== null) {
+      if (options.formats.cjs && !existing.require && existing.import) {
+        const match = (_a = existing.import) == null ? void 0 : _a.match(/\.\/src\/([^/]+\.(?:ts|js))$/);
+        if (match) {
+          const filename = match[1];
+          if (!isValidEntrypoint(filename)) {
+            throw new Error(`Export import path '${existing.import}' references '${filename}' which is not a valid entrypoint. Valid entrypoints cannot start with '_' or '.' and must be .ts/.js files in src/.`);
+          }
+          const entry = Path3.basename(filename, Path3.extname(filename));
+          return {
+            ...existing,
+            types: existing.types || `./src/${entry}.d.ts`,
+            require: `./src/${entry}.cjs`
+          };
+        }
+        if (entryFromPath) {
+          return {
+            ...existing,
+            types: existing.types || `./src/${entryFromPath}.d.ts`,
+            require: `./src/${entryFromPath}.cjs`
+          };
+        }
+        throw new Error(`Export import path '${existing.import}' must point to a valid entrypoint in src/ (e.g., './src/utils.js'). Nested directories and internal files are not allowed.`);
+      }
+      return {
+        types: existing.types || `./src/${entryFromPath}.d.ts`,
+        ...existing
+      };
+    }
+    return existing;
+  }
+  for (const [key, value] of Object.entries(existingExports)) {
+    const isStale = checkIfExportIsStale(key, value, entries);
+    if (isStale) {
+      staleExports.push(key);
+    } else {
+      exports[key] = expandExistingExport(value);
+    }
+  }
+  if (!exports["."]) {
+    exports["."] = createExportEntry(mainEntry);
+  } else {
+    exports["."] = expandExistingExport(exports["."], mainEntry);
+  }
+  for (const entry of entries) {
+    if (entry === "umd")
+      continue;
+    const key = `./${entry}`;
+    if (!exports[key]) {
+      exports[key] = createExportEntry(entry);
+    } else {
+      exports[key] = expandExistingExport(exports[key], entry);
+    }
+    if (!exports[`${key}.js`]) {
+      exports[`${key}.js`] = exports[key];
+    }
+  }
+  if (options.formats.umd && !exports["./umd"]) {
+    exports["./umd"] = {
+      require: "./src/umd.js"
+    };
+    if (!exports["./umd.js"]) {
+      exports["./umd.js"] = exports["./umd"];
+    }
+  }
+  if (!exports["./package.json"]) {
+    exports["./package.json"] = "./package.json";
+  }
+  return { exports, staleExports };
+}
+function transformSrcToDist(value) {
+  if (typeof value === "string") {
+    if (value.startsWith("src/") || value === "src") {
+      return "./" + value;
+    }
+    return value;
+  } else if (Array.isArray(value)) {
+    return value.map(transformSrcToDist);
+  } else if (typeof value === "object" && value !== null) {
+    const transformed = {};
+    for (const [key, val] of Object.entries(value)) {
+      transformed[key] = transformSrcToDist(val);
+    }
+    return transformed;
+  }
+  return value;
+}
+function transformBinPaths(value) {
+  if (typeof value === "string") {
+    if (value.startsWith("./dist/src/")) {
+      return value.replace("./dist/", "");
+    }
+    if (value.startsWith("dist/src/")) {
+      return value.replace("dist/", "");
+    }
+    if (value.startsWith("./src/")) {
+      return value.replace("./", "");
+    }
+    if (value.startsWith("src/") || value === "src") {
+      return value;
+    }
+    return value;
+  } else if (typeof value === "object" && value !== null) {
+    const transformed = {};
+    for (const [key, val] of Object.entries(value)) {
+      transformed[key] = transformBinPaths(val);
+    }
+    return transformed;
+  }
+  return value;
+}
+function fixExportsForDist(obj) {
+  if (typeof obj === "string") {
+    if (obj.includes("/dist/") && obj.includes("/src/")) {
+      const match = obj.match(/.*\/src\/(.*)$/);
+      if (match) {
+        return `./src/${match[1]}`;
+      }
+    }
+    if (obj.startsWith("./dist/src/")) {
+      return obj.replace("./dist/src/", "./src/");
+    }
+    if (obj.includes("/dist/") && obj.endsWith("/package.json")) {
+      return "./package.json";
+    }
+    return obj;
+  } else if (Array.isArray(obj)) {
+    return obj.map(fixExportsForDist);
+  } else if (typeof obj === "object" && obj !== null) {
+    const fixed = {};
+    for (const [key, val] of Object.entries(obj)) {
+      if (key === "files" && Array.isArray(val)) {
+        fixed[key] = val.filter((file) => file !== "dist/" && file !== "dist").concat(val.includes("dist/") || val.includes("dist") ? ["src/"] : []);
+      } else if (key === "bin") {
+        fixed[key] = val;
+      } else {
+        fixed[key] = fixExportsForDist(val);
+      }
+    }
+    return fixed;
+  }
+  return obj;
+}
+function cleanPackageJSON(pkg, mainEntry, options) {
+  const cleaned = {
+    name: pkg.name,
+    version: pkg.version
+  };
+  const fieldsToKeep = [
+    "description",
+    "keywords",
+    "author",
+    "contributors",
+    "maintainers",
+    "license",
+    "repository",
+    "bugs",
+    "homepage",
+    "funding",
+    "bin",
+    "scripts",
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "peerDependenciesMeta",
+    "optionalDependencies",
+    "bundledDependencies",
+    "engines",
+    "cpu",
+    "os",
+    "type",
+    "types",
+    "files",
+    "sideEffects",
+    "browserslist"
+  ];
+  const pathFields = ["files", "types", "scripts"];
+  for (const field of fieldsToKeep) {
+    if (pkg[field] !== void 0) {
+      if (field === "scripts") {
+        const npmLifecycleScripts = ["postinstall", "preinstall", "install", "preuninstall", "postuninstall", "shrinkwrap"];
+        const filteredScripts = {};
+        for (const [scriptName, scriptValue] of Object.entries(pkg[field] || {})) {
+          if (npmLifecycleScripts.includes(scriptName)) {
+            filteredScripts[scriptName] = scriptValue;
+          }
+        }
+        if (Object.keys(filteredScripts).length > 0) {
+          cleaned[field] = transformSrcToDist(filteredScripts);
+        }
+      } else if (field === "bin") {
+        cleaned[field] = transformBinPaths(pkg[field]);
+      } else if (pathFields.includes(field)) {
+        cleaned[field] = transformSrcToDist(pkg[field]);
+      } else {
+        cleaned[field] = pkg[field];
+      }
+    }
+  }
+  if (!cleaned.type) {
+    cleaned.type = "module";
+  }
+  if (options.formats.cjs) {
+    cleaned.main = `src/${mainEntry}.cjs`;
+  }
+  cleaned.module = `src/${mainEntry}.js`;
+  cleaned.types = `src/${mainEntry}.d.ts`;
+  return cleaned;
+}
+async function fileExists(filePath) {
+  try {
+    await FS3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validatePath(inputPath, basePath) {
+  if (Path3.isAbsolute(inputPath)) {
+    throw new Error(`Absolute paths are not allowed: ${inputPath}`);
+  }
+  if (inputPath.includes("..")) {
+    throw new Error(`Path traversal is not allowed: ${inputPath}`);
+  }
+  const resolvedPath = Path3.resolve(basePath, inputPath);
+  const resolvedBase = Path3.resolve(basePath);
+  if (!resolvedPath.startsWith(resolvedBase + Path3.sep) && resolvedPath !== resolvedBase) {
+    throw new Error(`Path ${inputPath} resolves outside the project directory`);
+  }
+  return resolvedPath;
+}
+async function build2(cwd, save = false) {
+  console.info("Building with libuild...");
+  const srcDir = Path3.join(cwd, "src");
+  const distDir = Path3.join(cwd, "dist");
+  const distSrcDir = Path3.join(distDir, "src");
+  if (!await fileExists(srcDir)) {
+    throw new Error("No src/ directory found");
+  }
+  const pkgPath = Path3.join(cwd, "package.json");
+  const pkg = JSON.parse(await FS3.readFile(pkgPath, "utf-8"));
+  if (!pkg.private) {
+    console.warn("\u26A0\uFE0F  WARNING: Root package.json is not private - this could lead to accidental publishing of development package.json");
+    console.warn("   Consider setting 'private: true' in your root package.json");
+  }
+  const gitignorePath = Path3.join(cwd, ".gitignore");
+  if (await fileExists(gitignorePath)) {
+    const gitignoreContent = await FS3.readFile(gitignorePath, "utf-8");
+    const isDistIgnored = gitignoreContent.includes("dist/") || gitignoreContent.includes("/dist") || gitignoreContent.includes("dist\n") || gitignoreContent.includes("dist\r\n");
+    if (!isDistIgnored) {
+      console.warn("\u26A0\uFE0F  WARNING: dist/ directory is not in .gitignore - built files should not be committed");
+      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 options = {
+    formats: {
+      esm: true,
+      // Always build ESM
+      cjs: !!pkg.main,
+      // Generate CJS only if main field exists
+      umd: entries.includes("umd")
+    }
+  };
+  const mainEntry = detectMainEntry(pkg, entries);
+  console.info("  Found entries:", entries.join(", "));
+  console.info("  Main entry:", mainEntry);
+  if (options.formats.cjs) {
+    console.info("  Formats: ESM, CJS" + (options.formats.umd ? ", UMD" : ""));
+  } else {
+    console.info("  Formats: ESM" + (options.formats.umd ? ", UMD" : "") + " (no main field - CJS disabled)");
+  }
+  const tempDistDir = `${distDir}.tmp.${Date.now()}.${Math.random().toString(36).substr(2, 9)}`;
+  try {
+    await FS3.mkdir(tempDistDir, { recursive: true });
+    if (await fileExists(distDir)) {
+      await FS3.rm(distDir, { recursive: true });
+    }
+    await FS3.rename(tempDistDir, distDir);
+  } catch (error) {
+    try {
+      if (await fileExists(tempDistDir)) {
+        await FS3.rm(tempDistDir, { recursive: true });
+      }
+    } catch {
+    }
+    throw error;
+  }
+  const externalDeps = [
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.peerDependencies || {}),
+    ...Object.keys(pkg.optionalDependencies || {})
+  ];
+  const entryPoints = [];
+  const umdEntries = [];
+  for (const entry of entries) {
+    const entryPath = Path3.join(srcDir, `${entry}.ts`);
+    const jsEntryPath = Path3.join(srcDir, `${entry}.js`);
+    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.`);
+    }
+    if (entry === "umd") {
+      umdEntries.push(actualPath);
+    } else {
+      entryPoints.push(actualPath);
+    }
+  }
+  if (entryPoints.length > 0) {
+    const entryNames = entryPoints.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: "node16",
+      plugins: [
+        externalEntrypointsPlugin({
+          entryNames,
+          outputExtension: ".js"
+        }),
+        dtsPlugin({
+          outDir: distSrcDir,
+          rootDir: srcDir,
+          entryPoints
+        })
+      ]
+    });
+    if (options.formats.cjs) {
+      console.info(`  Building ${entryPoints.length} entries (CJS)...`);
+      await ESBuild.build({
+        entryPoints,
+        outdir: distSrcDir,
+        format: "cjs",
+        outExtension: { ".js": ".cjs" },
+        bundle: true,
+        minify: false,
+        sourcemap: false,
+        external: externalDeps,
+        platform: "node",
+        target: "node16",
+        plugins: [
+          externalEntrypointsPlugin({
+            entryNames,
+            outputExtension: ".cjs"
+          })
+        ]
+      });
+    }
+  }
+  for (const umdPath of umdEntries) {
+    const entry = Path3.basename(umdPath, Path3.extname(umdPath));
+    console.info(`  Building ${entry} (UMD)...`);
+    const globalName = pkg.name.includes("/") ? pkg.name.split("/").pop().replace(/-/g, "").charAt(0).toUpperCase() + pkg.name.split("/").pop().replace(/-/g, "").slice(1) : pkg.name.replace(/-/g, "").charAt(0).toUpperCase() + pkg.name.replace(/-/g, "").slice(1);
+    await ESBuild.build({
+      entryPoints: [umdPath],
+      outdir: distSrcDir,
+      format: "cjs",
+      bundle: true,
+      minify: false,
+      sourcemap: false,
+      external: externalDeps,
+      platform: "node",
+      target: "node16",
+      plugins: [umdPlugin({ globalName })]
+    });
+  }
+  const autoDiscoveredFiles = [];
+  console.info("  Generating package.json...");
+  const cleanedPkg = cleanPackageJSON(pkg, mainEntry, options);
+  const exportsResult = generateExports(entries, mainEntry, options, pkg.exports);
+  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:`);
+    for (const staleExport of exportsResult.staleExports) {
+      console.warn(`   - ${staleExport}`);
+    }
+    if (save) {
+      console.info("   Removing stale exports from root package.json (--save mode)");
+    } else {
+      console.warn("   Use --save to remove these from root package.json");
+    }
+  }
+  if (cleanedPkg.files && Array.isArray(cleanedPkg.files)) {
+    for (const autoFile of autoDiscoveredFiles) {
+      if (!cleanedPkg.files.includes(autoFile)) {
+        cleanedPkg.files.push(autoFile);
+      }
+    }
+  }
+  const fixedDistPkg = fixExportsForDist(cleanedPkg);
+  await FS3.writeFile(
+    Path3.join(distDir, "package.json"),
+    JSON.stringify(fixedDistPkg, null, 2) + "\n"
+  );
+  const defaultFilesToCopy = ["README.md", "LICENSE", "CHANGELOG.md"];
+  for (const file of defaultFilesToCopy) {
+    const srcPath = Path3.join(cwd, file);
+    if (await fileExists(srcPath)) {
+      console.info(`  Copying ${file}...`);
+      await FS3.copyFile(srcPath, Path3.join(distDir, file));
+    }
+  }
+  const commonFiles = ["README.md", "LICENSE", "CHANGELOG.md", "COPYING", "AUTHORS"];
+  if (pkg.files && Array.isArray(pkg.files)) {
+    for (const commonFile of commonFiles) {
+      const commonPath = Path3.join(cwd, commonFile);
+      if (await fileExists(commonPath) && !pkg.files.includes(commonFile)) {
+        console.info(`  Auto-discovered ${commonFile}, adding to files field...`);
+        pkg.files.push(commonFile);
+        autoDiscoveredFiles.push(commonFile);
+      }
+    }
+  }
+  if (pkg.files && Array.isArray(pkg.files)) {
+    console.info("  Copying files from package.json files field...");
+    for (const pattern of pkg.files) {
+      if (typeof pattern === "string" && (pattern.includes("src") || pattern.includes("dist"))) {
+        continue;
+      }
+      if (typeof pattern === "string") {
+        const validatedSrcPath = validatePath(pattern, cwd);
+        const validatedDestPath = validatePath(pattern, distDir);
+        if (await fileExists(validatedSrcPath)) {
+          const stat2 = await FS3.stat(validatedSrcPath);
+          if (stat2.isSymbolicLink()) {
+            throw new Error(`Symbolic links are not allowed in files field: ${pattern}`);
+          }
+          if (stat2.isDirectory()) {
+            console.info(`  Copying directory ${pattern}/...`);
+            await FS3.mkdir(Path3.dirname(validatedDestPath), { recursive: true });
+            await FS3.cp(validatedSrcPath, validatedDestPath, { recursive: true });
+          } else if (stat2.isFile()) {
+            console.info(`  Copying ${pattern}...`);
+            await FS3.mkdir(Path3.dirname(validatedDestPath), { recursive: true });
+            await FS3.copyFile(validatedSrcPath, validatedDestPath);
+          } else {
+            throw new Error(`Unsupported file type for ${pattern}. Only regular files and directories are allowed.`);
+          }
+        } else if (pattern.includes("*")) {
+          const baseDir = pattern.split("*")[0].replace(/\/$/, "");
+          if (baseDir) {
+            const validatedBaseSrcPath = validatePath(baseDir, cwd);
+            const validatedBaseDestPath = validatePath(baseDir, distDir);
+            if (await fileExists(validatedBaseSrcPath)) {
+              console.info(`  Copying pattern ${pattern}...`);
+              await FS3.mkdir(Path3.dirname(validatedBaseDestPath), { recursive: true });
+              await FS3.cp(validatedBaseSrcPath, validatedBaseDestPath, { recursive: true });
+            } else {
+              throw new Error(`Pattern base directory not found for "${pattern}". Expected directory: ${validatedBaseSrcPath}`);
+            }
+          } else {
+            throw new Error(`Invalid pattern "${pattern}". Pattern must have a base directory before the wildcard.`);
+          }
+        } else {
+          throw new Error(`File specified in files field not found: ${validatedSrcPath}. Remove "${pattern}" from package.json files field or create the file.`);
+        }
+      } else {
+        throw new Error(`Invalid files field entry: ${JSON.stringify(pattern)}. Files field entries must be strings.`);
+      }
+    }
+  }
+  if (save) {
+    console.info("  Updating root package.json...");
+    const rootPkg2 = { ...pkg };
+    rootPkg2.private = true;
+    if (options.formats.cjs) {
+      rootPkg2.main = `./dist/src/${mainEntry}.cjs`;
+    }
+    rootPkg2.module = `./dist/src/${mainEntry}.js`;
+    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);
+    }
+    const rootExports = {};
+    for (const [key, value] of Object.entries(cleanedPkg.exports)) {
+      if (typeof value === "string") {
+        rootExports[key] = value.startsWith("./dist/") ? value : `./dist${value.startsWith(".") ? value.slice(1) : value}`;
+      } else if (typeof value === "object" && value !== null) {
+        rootExports[key] = {};
+        for (const [subKey, subValue] of Object.entries(value)) {
+          if (typeof subValue === "string") {
+            rootExports[key][subKey] = subValue.startsWith("./dist/") ? subValue : `./dist${subValue.startsWith(".") ? subValue.slice(1) : subValue}`;
+          }
+        }
+      }
+    }
+    rootPkg2.exports = rootExports;
+    if (rootPkg2.bin) {
+      if (typeof rootPkg2.bin === "string") {
+        if (!rootPkg2.bin.startsWith("./dist/")) {
+          if (rootPkg2.bin.startsWith("dist/")) {
+            rootPkg2.bin = "./" + rootPkg2.bin;
+          } else {
+            rootPkg2.bin = "./" + Path3.join("dist", rootPkg2.bin);
+          }
+        }
+      } else {
+        for (const [name, binPath] of Object.entries(rootPkg2.bin)) {
+          if (typeof binPath === "string" && !binPath.startsWith("./dist/")) {
+            if (binPath.startsWith("dist/")) {
+              rootPkg2.bin[name] = "./" + binPath;
+            } else {
+              rootPkg2.bin[name] = "./" + Path3.join("dist", binPath);
+            }
+          }
+        }
+      }
+    }
+    if (pkg.files !== void 0) {
+      if (!rootPkg2.files) {
+        rootPkg2.files = [];
+      } else if (!Array.isArray(rootPkg2.files)) {
+        rootPkg2.files = [rootPkg2.files];
+      }
+      for (const autoFile of autoDiscoveredFiles) {
+        if (!rootPkg2.files.includes(autoFile)) {
+          rootPkg2.files.push(autoFile);
+        }
+      }
+      if (!rootPkg2.files.includes("dist/") && !rootPkg2.files.includes("dist")) {
+        rootPkg2.files.push("dist/");
+      }
+    }
+    await FS3.writeFile(pkgPath, JSON.stringify(rootPkg2, null, 2) + "\n");
+  } else {
+    console.info("  Skipping root package.json update (use --save to enable)");
+  }
+  console.info("\nBuild complete!");
+  console.info(`
+  Output: ${distDir}`);
+  console.info(`
+  Entries: ${entries.length}`);
+  if (options.formats.cjs) {
+    console.info(`
+  Formats: ESM, CJS${options.formats.umd ? ", UMD" : ""}`);
+  } else {
+    console.info(`
+  Formats: ESM${options.formats.umd ? ", UMD" : ""}`);
+  }
+  let rootPkg = pkg;
+  if (save) {
+    rootPkg = JSON.parse(await FS3.readFile(pkgPath, "utf-8"));
+  }
+  return { distPkg: fixedDistPkg, rootPkg };
+}
+async function publish(cwd, save = true, extraArgs = []) {
+  await build2(cwd, save);
+  console.info("\nPublishing to npm...");
+  const distDir = Path3.join(cwd, "dist");
+  const distPkgPath = Path3.join(distDir, "package.json");
+  if (!await fileExists(distPkgPath)) {
+    throw new Error("No dist/package.json found. Run 'libuild build' first.");
+  }
+  const distPkg = JSON.parse(await FS3.readFile(distPkgPath, "utf-8"));
+  const publishArgs = ["publish"];
+  if (distPkg.name.startsWith("@")) {
+    publishArgs.push("--access", "public");
+  }
+  publishArgs.push(...extraArgs);
+  const proc = spawn("npm", publishArgs, {
+    cwd: distDir,
+    stdio: "inherit"
+  });
+  const exitCode = await new Promise((resolve3) => {
+    proc.on("close", resolve3);
+  });
+  if (exitCode === 0) {
+    const distPkg2 = JSON.parse(await FS3.readFile(distPkgPath, "utf-8"));
+    console.info(`
+Published ${distPkg2.name}@${distPkg2.version}!`);
+  } else {
+    throw new Error("npm publish failed");
+  }
+}
 export {
-  build,
+  build2 as build,
   publish,
   transformSrcToDist
 };
-//# sourceMappingURL=libuild.js.map