@b9g/libuild 0.1.0

package/src/libuild.cjs

@@ -0,0 +1,800 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/libuild.ts
+var libuild_exports = {};
+__export(libuild_exports, {
+  build: () => build2,
+  publish: () => publish,
+  transformSrcToDist: () => transformSrcToDist
+});
+module.exports = __toCommonJS(libuild_exports);
+var FS2 = __toESM(require("fs/promises"), 1);
+var Path2 = __toESM(require("path"), 1);
+var import_child_process = require("child_process");
+var ESBuild = __toESM(require("esbuild"), 1);
+var TS = __toESM(require("typescript"), 1);
+
+// src/umd-plugin.ts
+var FS = __toESM(require("fs/promises"), 1);
+var Path = __toESM(require("path"), 1);
+var import_magic_string = __toESM(require("magic-string"), 1);
+function umdPlugin(options) {
+  return {
+    name: "umd-wrapper",
+    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");
+  const ms = new import_magic_string.default(code);
+  const sourcemapComment = code.match(/\/\/# sourceMappingURL=.+$/m);
+  if (sourcemapComment) {
+    const index = code.lastIndexOf(sourcemapComment[0]);
+    ms.remove(index, index + sourcemapComment[0].length);
+  }
+  const exportsMatch = code.match(/\nmodule\.exports\s*=\s*([^;]+);?\s*$/);
+  if (exportsMatch) {
+    const index = code.lastIndexOf(exportsMatch[0]);
+    ms.overwrite(index, index + exportsMatch[0].length, `
+return ${exportsMatch[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 = `
+}));`;
+  ms.prepend(umdHeader);
+  ms.append(umdFooter);
+  const result = ms.toString();
+  const map = ms.generateMap({
+    file: Path.basename(filePath),
+    source: Path.basename(filePath).replace(".js", ".ts"),
+    includeContent: true
+  });
+  await FS.writeFile(filePath, result);
+  await FS.writeFile(filePath + ".map", map.toString());
+  await FS.writeFile(filePath, result + `
+//# sourceMappingURL=${Path.basename(filePath)}.map`);
+}
+
+// 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 FS2.readdir(srcDir);
+  return files.filter(isValidEntrypoint).map((file) => Path2.basename(file, Path2.extname(file))).sort();
+}
+async function detectMainEntry(pkg, entries) {
+  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 match = importPath.match(/\.\/src\/([^.]+)/);
+      if (match && entries.includes(match[1])) {
+        return match[1];
+      }
+    }
+  }
+  if (pkg.main && typeof pkg.main === "string") {
+    const mainBase = Path2.basename(pkg.main, Path2.extname(pkg.main));
+    if (entries.includes(mainBase)) {
+      return mainBase;
+    }
+  }
+  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 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`;
+    }
+    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 = Path2.basename(filename, Path2.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 = Path2.basename(filename, Path2.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 {
+      exports2[key] = expandExistingExport(value);
+    }
+  }
+  if (!exports2["."]) {
+    exports2["."] = createExportEntry(mainEntry);
+  } else {
+    exports2["."] = expandExistingExport(exports2["."], mainEntry);
+  }
+  for (const entry of entries) {
+    if (entry === "umd")
+      continue;
+    const key = `./${entry}`;
+    if (!exports2[key]) {
+      exports2[key] = createExportEntry(entry);
+    } else {
+      exports2[key] = expandExistingExport(exports2[key], entry);
+    }
+    if (!exports2[`${key}.js`]) {
+      exports2[`${key}.js`] = exports2[key];
+    }
+    if (entry === "jsx-runtime") {
+      if (!exports2["./jsx-dev-runtime"]) {
+        exports2["./jsx-dev-runtime"] = exports2[key];
+      }
+      if (!exports2["./jsx-dev-runtime.js"]) {
+        exports2["./jsx-dev-runtime.js"] = exports2[key];
+      }
+    }
+  }
+  if (options.formats.umd && !exports2["./umd"]) {
+    exports2["./umd"] = {
+      require: "./src/umd.js"
+    };
+    if (!exports2["./umd.js"]) {
+      exports2["./umd.js"] = exports2["./umd"];
+    }
+  }
+  if (!exports2["./package.json"]) {
+    exports2["./package.json"] = "./package.json";
+  }
+  return { exports: exports2, 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 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 {
+        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",
+    "peerDependencies",
+    "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] = transformSrcToDist(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 FS2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function build2(cwd, save = false) {
+  console.log("Building with libuild...");
+  const srcDir = Path2.join(cwd, "src");
+  const distDir = Path2.join(cwd, "dist");
+  const distSrcDir = Path2.join(distDir, "src");
+  if (!await fileExists(srcDir)) {
+    throw new Error("No src/ directory found");
+  }
+  const pkgPath = Path2.join(cwd, "package.json");
+  const pkg = JSON.parse(await FS2.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 = Path2.join(cwd, ".gitignore");
+  if (await fileExists(gitignorePath)) {
+    const gitignoreContent = await FS2.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 = await detectMainEntry(pkg, entries);
+  console.log("  Found entries:", entries.join(", "));
+  console.log("  Main entry:", mainEntry);
+  if (options.formats.cjs) {
+    console.log("  Formats: ESM, CJS" + (options.formats.umd ? ", UMD" : ""));
+  } else {
+    console.log("  Formats: ESM" + (options.formats.umd ? ", UMD" : "") + " (no main field - CJS disabled)");
+  }
+  if (await fileExists(distDir)) {
+    await FS2.rm(distDir, { recursive: true });
+  }
+  await FS2.mkdir(distDir, { recursive: true });
+  const entryPoints = [];
+  const umdEntries = [];
+  for (const entry of entries) {
+    const entryPath = Path2.join(srcDir, `${entry}.ts`);
+    const jsEntryPath = Path2.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) {
+    console.log(`  Building ${entryPoints.length} entries (ESM)...`);
+    await ESBuild.build({
+      entryPoints,
+      outdir: distSrcDir,
+      format: "esm",
+      entryNames: "[name]",
+      outExtension: { ".js": ".js" },
+      bundle: true,
+      splitting: true,
+      // Enable shared chunk extraction
+      minify: false,
+      sourcemap: true,
+      external: Object.keys(pkg.dependencies || {}),
+      platform: "node",
+      target: "node16"
+    });
+    if (options.formats.cjs) {
+      console.log(`  Building ${entryPoints.length} entries (CJS)...`);
+      await ESBuild.build({
+        entryPoints,
+        outdir: distSrcDir,
+        format: "cjs",
+        entryNames: "[name]",
+        outExtension: { ".js": ".cjs" },
+        bundle: true,
+        minify: false,
+        sourcemap: true,
+        external: Object.keys(pkg.dependencies || {}),
+        platform: "node",
+        target: "node16"
+        // Note: CJS doesn't support splitting, but building together still helps with consistency
+      });
+    }
+  }
+  for (const umdPath of umdEntries) {
+    const entry = Path2.basename(umdPath, Path2.extname(umdPath));
+    console.log(`  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",
+      entryNames: "[name]",
+      bundle: true,
+      minify: false,
+      sourcemap: true,
+      external: Object.keys(pkg.dependencies || {}),
+      platform: "node",
+      target: "node16",
+      plugins: [umdPlugin({ globalName })]
+    });
+  }
+  console.log("  Generating TypeScript declarations...");
+  const allTsFiles = [...entryPoints, ...umdEntries].filter((file) => file.endsWith(".ts"));
+  if (allTsFiles.length > 0) {
+    const compilerOptions = {
+      declaration: true,
+      emitDeclarationOnly: true,
+      outDir: distSrcDir,
+      rootDir: srcDir,
+      skipLibCheck: true,
+      esModuleInterop: true,
+      target: TS.ScriptTarget.ES2020,
+      module: TS.ModuleKind.ESNext
+    };
+    const program = TS.createProgram(allTsFiles, compilerOptions);
+    const emitResult = program.emit();
+    if (emitResult.diagnostics.length > 0) {
+      const diagnostics = TS.formatDiagnosticsWithColorAndContext(emitResult.diagnostics, {
+        getCanonicalFileName: (path) => path,
+        getCurrentDirectory: () => cwd,
+        getNewLine: () => "\n"
+      });
+      throw new Error(`TypeScript declaration generation failed:
+${diagnostics}`);
+    }
+  }
+  for (const entry of entries) {
+    if (entry === "umd")
+      continue;
+    const jsPath = Path2.join(distSrcDir, `${entry}.js`);
+    const dtsPath = Path2.join(distSrcDir, `${entry}.d.ts`);
+    if (await fileExists(jsPath) && await fileExists(dtsPath)) {
+      const content = await FS2.readFile(jsPath, "utf-8");
+      await FS2.writeFile(jsPath, `/// <reference types="./${entry}.d.ts" />
+${content}`);
+    }
+  }
+  const autoDiscoveredFiles = [];
+  console.log("  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.log("   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 FS2.writeFile(
+    Path2.join(distDir, "package.json"),
+    JSON.stringify(fixedDistPkg, null, 2) + "\n"
+  );
+  const defaultFilesToCopy = ["README.md", "LICENSE", "CHANGELOG.md"];
+  for (const file of defaultFilesToCopy) {
+    const srcPath = Path2.join(cwd, file);
+    if (await fileExists(srcPath)) {
+      console.log(`  Copying ${file}...`);
+      await FS2.copyFile(srcPath, Path2.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 = Path2.join(cwd, commonFile);
+      if (await fileExists(commonPath) && !pkg.files.includes(commonFile)) {
+        console.log(`  Auto-discovered ${commonFile}, adding to files field...`);
+        pkg.files.push(commonFile);
+        autoDiscoveredFiles.push(commonFile);
+      }
+    }
+  }
+  if (pkg.files && Array.isArray(pkg.files)) {
+    console.log("  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 srcPath = Path2.join(cwd, pattern);
+        const destPath = Path2.join(distDir, pattern);
+        if (await fileExists(srcPath)) {
+          const stat2 = await FS2.stat(srcPath);
+          if (stat2.isDirectory()) {
+            console.log(`  Copying directory ${pattern}/...`);
+            await FS2.mkdir(Path2.dirname(destPath), { recursive: true });
+            await FS2.cp(srcPath, destPath, { recursive: true });
+          } else {
+            console.log(`  Copying ${pattern}...`);
+            await FS2.mkdir(Path2.dirname(destPath), { recursive: true });
+            await FS2.copyFile(srcPath, destPath);
+          }
+        } else if (pattern.includes("*")) {
+          const baseDir = pattern.split("*")[0].replace(/\/$/, "");
+          if (baseDir && await fileExists(Path2.join(cwd, baseDir))) {
+            console.log(`  Copying pattern ${pattern}...`);
+            const baseSrcPath = Path2.join(cwd, baseDir);
+            const baseDestPath = Path2.join(distDir, baseDir);
+            await FS2.mkdir(Path2.dirname(baseDestPath), { recursive: true });
+            await FS2.cp(baseSrcPath, baseDestPath, { recursive: true });
+          } else {
+            throw new Error(`Pattern base directory not found for "${pattern}". Expected directory: ${Path2.join(cwd, baseDir)}`);
+          }
+        } else {
+          throw new Error(`File specified in files field not found: ${srcPath}. 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.log("  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 : "./" + Path2.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/")) {
+          rootPkg2.bin = "./" + Path2.join("dist", rootPkg2.bin);
+        }
+      } else {
+        for (const [name, binPath] of Object.entries(rootPkg2.bin)) {
+          if (typeof binPath === "string" && !binPath.startsWith("./dist/")) {
+            rootPkg2.bin[name] = "./" + Path2.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 FS2.writeFile(pkgPath, JSON.stringify(rootPkg2, null, 2) + "\n");
+  } else {
+    console.log("  Skipping root package.json update (use --save to enable)");
+  }
+  console.log("\nBuild complete!");
+  console.log(`
+  Output: ${distDir}`);
+  console.log(`
+  Entries: ${entries.length}`);
+  if (options.formats.cjs) {
+    console.log(`
+  Formats: ESM, CJS${options.formats.umd ? ", UMD" : ""}`);
+  } else {
+    console.log(`
+  Formats: ESM${options.formats.umd ? ", UMD" : ""}`);
+  }
+  let rootPkg = pkg;
+  if (save) {
+    rootPkg = JSON.parse(await FS2.readFile(pkgPath, "utf-8"));
+  }
+  return { distPkg: fixedDistPkg, rootPkg };
+}
+async function publish(cwd, save = true) {
+  await build2(cwd, save);
+  console.log("\nPublishing to npm...");
+  const distDir = Path2.join(cwd, "dist");
+  const distPkgPath = Path2.join(distDir, "package.json");
+  if (!await fileExists(distPkgPath)) {
+    throw new Error("No dist/package.json found. Run 'libuild build' first.");
+  }
+  const proc = (0, import_child_process.spawn)("npm", ["publish"], {
+    cwd: distDir,
+    stdio: "inherit"
+  });
+  const exitCode = await new Promise((resolve) => {
+    proc.on("close", resolve);
+  });
+  if (exitCode === 0) {
+    const distPkg = JSON.parse(await FS2.readFile(distPkgPath, "utf-8"));
+    console.log(`
+Published ${distPkg.name}@${distPkg.version}!`);
+  } else {
+    throw new Error("npm publish failed");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  publish,
+  transformSrcToDist
+});
+//# sourceMappingURL=libuild.cjs.map