@sse-ui/builder 1.0.3 → 1.2.0

package/dist/cli.js

@@ -1,13 +1,18 @@
 #!/usr/bin/env node
 import {
-  createPackageBin,
-  createPackageExports,
+  getVersionEnvVariables
+} from "./chunk-MBPIJFGX.js";
+import {
+  addLicense,
   getOutExtension,
   mapConcurrently,
-  validatePkgJson
-} from "./chunk-5S2N5WDQ.js";
+  validatePkgJson,
+  writePackageJson
+} from "./chunk-B6FMAT44.js";
+import "./chunk-MLKGABMK.js";
 
 // src/cli.ts
+import chalk2 from "chalk";
 import { Command as Command11 } from "commander";
 
 // src/core/build.ts
@@ -19,6 +24,8 @@ import * as path from "path";
 import { sep as posixSep } from "path/posix";
 import * as semver from "semver";
 import { Command } from "commander";
+import { build as esbuild } from "esbuild";
+import chalk from "chalk";
 
 // src/utils/loadConfig.ts
 import { loadConfig as loadC12Config } from "c12";
@@ -29,7 +36,7 @@ async function loadConfig() {
       rcFile: false,
       globalRc: false
     });
-    if (configFile) {
+    if (configFile && (config?.verbose || process.env.SSE_BUILD_VERBOSE === "true")) {
       console.log(`\u{1F4DD} Loaded config from ${configFile}`);
     }
     return config || {};
@@ -40,95 +47,22 @@ async function loadConfig() {
   }
 }
 
-// src/core/build.ts
-async function addLicense({
-  name,
-  version,
-  license,
-  bundle,
-  outputDir,
-  isFlat,
-  packageType
-}) {
-  const outExtension = getOutExtension(bundle, { isFlat, packageType });
-  const file = path.join(outputDir, `index${outExtension}`);
-  if (!await fs.stat(file).then(
-    (stats) => stats.isFile(),
-    () => false
-  )) {
-    return;
-  }
-  const content = await fs.readFile(file, { encoding: "utf8" });
-  await fs.writeFile(
-    file,
-    `/**
- * ${name} v${version}
- *
- * @license ${license}
- * This source code is licensed under the ${license} license found in the
- * LICENSE file in the root directory of this source tree.
- */
-${content}`,
-    { encoding: "utf8" }
-  );
-  console.log(`License added to ${file}`);
+// src/utils/package-manager.ts
+function getPackageManager() {
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.includes("pnpm")) return "pnpm";
+  if (userAgent.includes("yarn")) return "yarn";
+  return "npm";
 }
-async function writePackageJson({
-  packageJson,
-  bundles,
-  outputDir,
-  cwd,
-  addTypes = false,
-  isFlat = false,
-  packageType
-}) {
-  delete packageJson.scripts;
-  delete packageJson.publishConfig?.directory;
-  delete packageJson.devDependencies;
-  delete packageJson.imports;
-  const resolvedPackageType = packageType || packageJson.type || "commonjs";
-  packageJson.type = resolvedPackageType;
-  const originalExports = packageJson.exports;
-  delete packageJson.exports;
-  const originalBin = packageJson.bin;
-  delete packageJson.bin;
-  const {
-    exports: packageExports,
-    main: main2,
-    types
-  } = await createPackageExports({
-    exports: originalExports,
-    bundles,
-    outputDir,
-    cwd,
-    addTypes,
-    isFlat,
-    packageType: resolvedPackageType
-  });
-  packageJson.exports = packageExports;
-  if (main2) {
-    packageJson.main = main2;
-  }
-  if (types) {
-    packageJson.types = types;
-  }
-  const bin = await createPackageBin({
-    bin: originalBin,
-    bundles,
-    cwd,
-    isFlat,
-    packageType: resolvedPackageType
-  });
-  if (bin) {
-    packageJson.bin = bin;
-  }
-  await fs.writeFile(
-    path.join(outputDir, "package.json"),
-    JSON.stringify(packageJson, null, 2),
-    "utf-8"
-  );
+function getPmExec() {
+  const pm = getPackageManager();
+  if (pm === "pnpm") return ["pnpm", "exec"];
+  if (pm === "yarn") return ["yarn"];
+  return ["npx"];
 }
-var buildCommand = new Command("build").description("Builds the package for publishing.").option("--bundle <bundles...>", "Bundles to output", ["esm", "cjs"]).option(
+
+// src/core/build.ts
+var buildCommand = new Command("build").description(chalk.cyan("Builds the package for publishing.")).option("--bundle <bundles...>", "Bundles to output", ["esm", "cjs"]).option("--entry <entry>", "Entry point for esbuild (e.g., src/index.ts)").option(
   "--hasLargeFiles",
   "Set to `true` if you know you are transpiling large files.",
   false
@@ -158,67 +92,76 @@ var buildCommand = new Command("build").description("Builds the package for publ
   []
 ).option("--enableReactCompiler", "Whether to use the React compiler.", false).option(
   "--tsgo",
-  'Uses tsgo cli instead of tsc for type generation. Can also be set via env var "SSE_USE_TSGO"',
+  "Uses tsgo cli instead of tsc for type generation.",
   process.env.SSE_USE_TSGO === "1" || process.env.SSE_USE_TSGO === "true"
 ).option(
   "--flat",
   "Builds the package in a flat structure without subdirectories for each module type.",
   process.env.SSE_BUILD_FLAT === "1"
-).option("--verbose", "Enable verbose logging.", false).action(async (cliOptions) => {
+).option(
+  "--exportExtensions <exts...>",
+  "Available extensions for generating exports wildcards.",
+  [".js", ".mjs", ".cjs"]
+).action(async (cliOptions) => {
   const fileConfig = await loadConfig();
-  const options = {
-    bundle: cliOptions.bundle || fileConfig.bundle || ["esm", "cjs"],
-    hasLargeFiles: cliOptions.hasLargeFiles ?? fileConfig.hasLargeFiles ?? false,
-    skipBundlePackageJson: cliOptions.skipBundlePackageJson ?? fileConfig.skipBundlePackageJson ?? false,
-    buildTypes: cliOptions.buildTypes ?? fileConfig.buildTypes ?? true,
-    skipTsc: cliOptions.skipTsc ?? fileConfig.skipTsc ?? false,
-    ignore: [...fileConfig.ignore || [], ...cliOptions.ignore || []],
-    copy: [...fileConfig.copy || [], ...cliOptions.copy || []],
-    enableReactCompiler: cliOptions.enableReactCompiler ?? fileConfig.enableReactCompiler ?? false,
-    tsgo: cliOptions.tsgo ?? fileConfig.tsgo ?? false,
-    flat: cliOptions.flat ?? fileConfig.flat ?? false,
-    verbose: cliOptions.verbose ?? fileConfig.verbose ?? false,
-    skipBabelRuntimeCheck: false,
-    skipPackageJson: false,
-    skipMainCheck: false
-  };
-  const {
-    bundle: bundles,
-    hasLargeFiles,
-    skipBundlePackageJson,
-    verbose = false,
-    ignore: extraIgnores,
-    buildTypes,
-    skipTsc,
-    skipBabelRuntimeCheck = false,
-    skipPackageJson = false,
-    enableReactCompiler = false,
-    tsgo: useTsgo = false
-  } = options;
+  const isVerbose = cliOptions.verbose || fileConfig.verbose || process.env.SSE_BUILD_VERBOSE === "true";
+  if (isVerbose) process.env.SSE_BUILD_VERBOSE = "true";
+  const isEsbuild = !!fileConfig.esbuild || !!cliOptions.entry;
+  const builder = isEsbuild ? "esbuild" : "babel";
+  const bundles = cliOptions.bundle || fileConfig.bundle || ["esm", "cjs"];
+  const isFlat = cliOptions.flat ?? fileConfig.flat ?? false;
+  const buildTypes = cliOptions.buildTypes ?? fileConfig.buildTypes ?? true;
+  const skipTsc = cliOptions.skipTsc ?? fileConfig.skipTsc ?? false;
+  const skipBundlePackageJson = cliOptions.skipBundlePackageJson ?? fileConfig.skipBundlePackageJson ?? false;
+  const skipBabelRuntimeCheck = cliOptions.skipBabelRuntimeCheck ?? false;
+  const skipPackageJson = cliOptions.skipPackageJson ?? false;
+  const enableReactCompiler = cliOptions.enableReactCompiler ?? fileConfig.babel?.enableReactCompiler ?? false;
+  const useTsgo = cliOptions.tsgo ?? fileConfig.tsgo ?? false;
+  const exportExtensions = cliOptions.exportExtensions ?? fileConfig.exportExtensions ?? [".js", ".mjs", ".cjs"];
+  const copyGlobs = [...fileConfig.copy || [], ...cliOptions.copy || []];
   const cwd = process.cwd();
   const pkgJsonPath = path.join(cwd, "package.json");
   const packageJson = JSON.parse(
     await fs.readFile(pkgJsonPath, { encoding: "utf8" })
   );
   validatePkgJson(packageJson, {
-    skipMainCheck: options.skipMainCheck,
+    skipMainCheck: cliOptions.skipMainCheck,
     enableReactCompiler
   });
   const buildDirBase = packageJson.publishConfig?.directory;
   const buildDir = path.join(cwd, buildDirBase);
   const packageType = packageJson.type === "module" ? "module" : "commonjs";
-  console.log(`Selected output directory: "${buildDirBase}"`);
-  if (options.flat) {
-    console.log("Building package in flat structure.");
+  if (isVerbose) {
+    console.log(`Selected output directory: "${buildDirBase}"`);
+    if (isFlat) console.log("Building package in flat structure.");
   }
   await fs.rm(buildDir, { recursive: true, force: true });
+  const pm = getPackageManager();
   let babelRuntimeVersion = packageJson.dependencies?.["@babel/runtime"];
   if (babelRuntimeVersion === "catalog:") {
-    const { stdout: configStdout } = await $`pnpm config list --json`;
-    const pnpmWorkspaceConfig = JSON.parse(configStdout);
-    babelRuntimeVersion = pnpmWorkspaceConfig.catalog["@babel/runtime"];
+    if (pm === "pnpm") {
+      try {
+        const { stdout: configStdout } = await $`pnpm config list --json`;
+        const pnpmWorkspaceConfig = JSON.parse(configStdout);
+        babelRuntimeVersion = pnpmWorkspaceConfig.catalog["@babel/runtime"];
+      } catch (error) {
+        if (isVerbose)
+          console.warn(
+            `
+\u26A0\uFE0F Failed to resolve 'catalog:' using pnpm. Falling back to default.`
+          );
+        babelRuntimeVersion = "^7.25.0";
+      }
+    } else {
+      if (isVerbose)
+        console.warn(
+          `
+\u26A0\uFE0F 'catalog:' dependency found but package manager is ${pm}. Falling back to default babel runtime version.`
+        );
+      babelRuntimeVersion = "^7.25.0";
+    }
   }
-  if (!babelRuntimeVersion && !skipBabelRuntimeCheck) {
+  if (builder === "babel" && !babelRuntimeVersion && !skipBabelRuntimeCheck) {
     throw new Error(
       "package.json needs to have a dependency on `@babel/runtime` when building with `@babel/plugin-transform-runtime`."
     );
@@ -229,101 +172,169 @@ var buildCommand = new Command("build").description("Builds the package for publ
     );
     return;
   }
-  const { build: babelBuild, cjsCopy } = await import("./babel-VTL3CZAT.js");
-  const relativeOutDirs = !options.flat ? {
-    cjs: ".",
-    esm: "esm"
-  } : {
-    cjs: ".",
-    esm: "."
-  };
+  const relativeOutDirs = !isFlat ? { cjs: ".", esm: "esm" } : { cjs: ".", esm: "." };
   const sourceDir = path.join(cwd, "src");
   const reactVersion = semver.minVersion(packageJson.peerDependencies?.react || "")?.version ?? "latest";
-  if (enableReactCompiler) {
+  if (enableReactCompiler && isVerbose) {
     const mode = process.env.SSE_REACT_COMPILER_MODE ?? "opt-in";
     console.log(
       `[feature] Building with React compiler enabled. The compiler mode is "${mode}" right now.${mode === "opt-in" ? ' Use explicit "use memo" directives in your components to enable the React compiler for them.' : ""}`
     );
   }
-  await Promise.all(
-    bundles.map(async (bundle) => {
-      const outExtension = getOutExtension(bundle, {
-        isFlat: !!options.flat,
-        isType: false,
-        packageType
-      });
-      const relativeOutDir = relativeOutDirs[bundle];
-      const outputDir = path.join(buildDir, relativeOutDir);
-      await fs.mkdir(outputDir, { recursive: true });
-      const promises = [];
-      promises.push(
-        babelBuild({
-          cwd,
-          sourceDir,
-          outDir: outputDir,
-          babelRuntimeVersion,
-          hasLargeFiles,
-          bundle,
-          verbose,
-          optimizeClsx: packageJson.dependencies?.clsx !== void 0 || packageJson.dependencies?.classnames !== void 0,
-          removePropTypes: packageJson.dependencies?.["prop-types"] !== void 0,
-          pkgVersion: packageJson.version,
-          ignores: extraIgnores,
-          outExtension,
-          reactCompiler: enableReactCompiler ? {
-            reactVersion: reactVersion || "latest"
-          } : void 0
-        })
+  if (builder === "esbuild") {
+    if (isVerbose)
+      console.log("\u{1F4E6} Bundling package into single files via esbuild...");
+    const esbuildConfig = fileConfig.esbuild || { entry: "src/index.ts" };
+    let rawEntryPoints = cliOptions.entry || esbuildConfig.entry;
+    if (!rawEntryPoints) {
+      throw new Error(
+        "Esbuild requires an 'entry' point. Please define it in your config (esbuild.entry) or via --entry."
       );
-      if (buildDir !== outputDir && !skipBundlePackageJson && !options.flat) {
-        promises.push(
-          fs.writeFile(
+    }
+    const entryPoints = typeof rawEntryPoints === "string" ? [rawEntryPoints] : rawEntryPoints;
+    await Promise.all(
+      bundles.map(async (bundle) => {
+        const outExtension = getOutExtension(bundle, {
+          isFlat: !!isFlat,
+          isType: false,
+          packageType
+        });
+        const relativeOutDir = relativeOutDirs[bundle];
+        const outputDir = path.join(buildDir, relativeOutDir);
+        await fs.mkdir(outputDir, { recursive: true });
+        await esbuild({
+          entryPoints,
+          bundle: true,
+          outdir: outputDir,
+          format: bundle === "esm" ? "esm" : "cjs",
+          target: esbuildConfig.target || ["es2020", "node14"],
+          minify: esbuildConfig.minify ?? false,
+          outExtension: { ".js": outExtension },
+          // Forces the correct extension output
+          external: [
+            ...Object.keys(packageJson.dependencies || {}),
+            ...Object.keys(packageJson.peerDependencies || {}),
+            ...esbuildConfig.external || []
+          ]
+        });
+        if (buildDir !== outputDir && !skipBundlePackageJson && !isFlat) {
+          await fs.writeFile(
             path.join(outputDir, "package.json"),
             JSON.stringify({
               type: bundle === "esm" ? "module" : "commonjs",
               sideEffects: packageJson.sideEffects ?? false
             })
-          )
+          );
+        }
+        await addLicense({
+          bundle,
+          license: packageJson.license,
+          name: packageJson.name,
+          version: packageJson.version,
+          outputDir,
+          isFlat: !!isFlat,
+          packageType
+        });
+      })
+    );
+  } else {
+    if (isVerbose) console.log("\u{1F4E6} Transpiling package via Babel...");
+    const { build: babelBuild, cjsCopy } = await import("./babel-RJOLF3H5.js");
+    const hasLargeFiles = cliOptions.hasLargeFiles ?? fileConfig.babel?.hasLargeFiles ?? false;
+    const extraIgnores = [
+      ...fileConfig.babel?.ignore || [],
+      ...cliOptions.ignore || []
+    ];
+    await Promise.all(
+      bundles.map(async (bundle) => {
+        const outExtension = getOutExtension(bundle, {
+          isFlat: !!isFlat,
+          isType: false,
+          packageType
+        });
+        const relativeOutDir = relativeOutDirs[bundle];
+        const outputDir = path.join(buildDir, relativeOutDir);
+        await fs.mkdir(outputDir, { recursive: true });
+        const promises = [];
+        promises.push(
+          babelBuild({
+            cwd,
+            sourceDir,
+            outDir: outputDir,
+            babelRuntimeVersion,
+            hasLargeFiles,
+            bundle,
+            verbose: isVerbose,
+            optimizeClsx: packageJson.dependencies?.clsx !== void 0 || packageJson.dependencies?.classnames !== void 0,
+            removePropTypes: packageJson.dependencies?.["prop-types"] !== void 0,
+            pkgVersion: packageJson.version,
+            ignores: extraIgnores,
+            outExtension,
+            reactCompiler: enableReactCompiler ? { reactVersion: reactVersion || "latest" } : void 0
+          })
         );
-      }
-      if (!options.flat) {
-        promises.push(cjsCopy({ from: sourceDir, to: outputDir }));
-      }
-      await Promise.all(promises);
-      await addLicense({
-        bundle,
-        license: packageJson.license,
-        name: packageJson.name,
-        version: packageJson.version,
-        outputDir,
-        isFlat: !!options.flat,
-        packageType
-      });
-    })
-  );
-  if (options.flat) {
-    await cjsCopy({ from: sourceDir, to: buildDir });
+        if (buildDir !== outputDir && !skipBundlePackageJson && !isFlat) {
+          promises.push(
+            fs.writeFile(
+              path.join(outputDir, "package.json"),
+              JSON.stringify({
+                type: bundle === "esm" ? "module" : "commonjs",
+                sideEffects: packageJson.sideEffects ?? false
+              })
+            )
+          );
+        }
+        if (!isFlat) {
+          promises.push(cjsCopy({ from: sourceDir, to: outputDir }));
+        }
+        await Promise.all(promises);
+        await addLicense({
+          bundle,
+          license: packageJson.license,
+          name: packageJson.name,
+          version: packageJson.version,
+          outputDir,
+          isFlat: !!isFlat,
+          packageType
+        });
+      })
+    );
+    if (isFlat) {
+      await cjsCopy({ from: sourceDir, to: buildDir });
+    }
   }
-  if (buildTypes) {
-    const tsMod = await import("./typescript-CS6YZCMJ.js");
+  if (buildTypes === true) {
+    if (isVerbose) console.log("\u{1F4DD} Generating TypeScript declarations...");
+    const tsMod = await import("./typescript-6QWCIZ3Q.js");
     const bundleMap = bundles.map((type) => ({
       type,
       dir: relativeOutDirs[type]
     }));
+    let esbuildEntryPoints;
+    if (builder === "esbuild") {
+      const esbuildConfig = fileConfig.esbuild || { entry: "src/index.ts" };
+      const rawEntryPoints = cliOptions.entry || esbuildConfig.entry;
+      esbuildEntryPoints = typeof rawEntryPoints === "string" ? [rawEntryPoints] : rawEntryPoints;
+    }
     await tsMod.createTypes({
       bundles: bundleMap,
       srcDir: sourceDir,
       cwd,
       skipTsc,
-      isFlat: !!options.flat,
+      isFlat: !!isFlat,
       buildDir,
       useTsgo,
       packageType,
-      verbose: options.verbose
+      verbose: isVerbose,
+      builder,
+      entryPoints: esbuildEntryPoints
     });
   }
   if (skipPackageJson) {
-    console.log("Skipping package.json generation in the output directory.");
+    if (isVerbose)
+      console.log(
+        "Skipping package.json generation in the output directory."
+      );
     return;
   }
   await writePackageJson({
@@ -335,14 +346,15 @@ var buildCommand = new Command("build").description("Builds the package for publ
     })),
     outputDir: buildDir,
     addTypes: buildTypes,
-    isFlat: !!options.flat,
-    packageType
+    isFlat: !!isFlat,
+    packageType,
+    exportExtensions
   });
   await copyHandler({
     cwd,
-    globs: options.copy ?? [],
+    globs: copyGlobs,
     buildDir,
-    verbose: options.verbose
+    verbose: isVerbose
   });
 });
 async function copyHandler({
@@ -366,13 +378,10 @@ async function copyHandler({
   await Promise.all(
     localOrRootFiles.map(async (filesToCopy) => {
       for (const file of filesToCopy) {
-        if (
-          // eslint-disable-next-line no-await-in-loop
-          await fs.stat(file).then(
-            () => true,
-            () => false
-          )
-        ) {
+        if (await fs.stat(file).then(
+          () => true,
+          () => false
+        )) {
           defaultFiles.push(file);
           break;
         }
@@ -437,7 +446,7 @@ async function copyHandler({
     },
     20
   );
-  console.log(`\u{1F4CB} Copied ${defaultFiles.length} files.`);
+  if (verbose) console.log(`\u{1F4CB} Copied ${defaultFiles.length} files.`);
 }
 async function recursiveCopy({
   source,
@@ -466,12 +475,6 @@ import * as fs2 from "fs/promises";
 import * as path2 from "path";
 import { Command as Command2 } from "commander";
 import { $ as $2 } from "execa";
-function getPackageManager() {
-  const userAgent = process.env.npm_config_user_agent || "";
-  if (userAgent.includes("pnpm")) return "pnpm";
-  if (userAgent.includes("yarn")) return "yarn";
-  return "npm";
-}
 var publishCommand = new Command2("publish").description(
   "Automatically publishes the built package from the publishConfig.directory"
 ).option("--tag <tag>", "Registers the published package with the given tag").option(
@@ -484,6 +487,7 @@ var publishCommand = new Command2("publish").description(
   "--pm <manager>",
   "Force a specific package manager (npm, yarn, pnpm)"
 ).action(async (options) => {
+  const isVerbose = process.env.SSE_BUILD_VERBOSE === "true";
   const cwd = process.cwd();
   const pkgJsonPath = path2.join(cwd, "package.json");
   try {
@@ -508,9 +512,11 @@ var publishCommand = new Command2("publish").description(
       );
     }
     const pm = options.pm || getPackageManager();
-    console.log(
-      `\u{1F680} Publishing via ${pm.toUpperCase()} from directory: ${publishDirBase}`
-    );
+    if (isVerbose) {
+      console.log(
+        `\u{1F680} Publishing via ${pm.toUpperCase()} from directory: ${publishDirBase}`
+      );
+    }
     const args = ["publish"];
     if (options.tag) args.push("--tag", options.tag);
     if (options.access) args.push("--access", options.access);
@@ -539,6 +545,7 @@ import { Command as Command3 } from "commander";
 var cleanCommand = new Command3("clean").description(
   "Removes the build directory specified in package.json to start fresh"
 ).action(async () => {
+  const isVerbose = process.env.SSE_BUILD_VERBOSE === "true";
   const cwd = process.cwd();
   const pkgJsonPath = path3.join(cwd, "package.json");
   try {
@@ -548,7 +555,8 @@ var cleanCommand = new Command3("clean").description(
     const packageJson = JSON.parse(packageJsonContent);
     const buildDirBase = packageJson.publishConfig?.directory || "build";
     const buildDir = path3.join(cwd, buildDirBase);
-    console.log(`\u{1F9F9} Cleaning build directory: ${buildDirBase}...`);
+    if (isVerbose)
+      console.log(`\u{1F9F9} Cleaning build directory: ${buildDirBase}...`);
     await fs3.rm(buildDir, { recursive: true, force: true });
     console.log("\u2728 Cleaned successfully!");
   } catch (error) {
@@ -566,7 +574,8 @@ import { $ as $3 } from "execa";
 var typecheckCommand = new Command4("typecheck").description(
   "Runs TypeScript validation across the project without emitting files"
 ).option("--watch", "Run typechecking in watch mode").action(async (options) => {
-  console.log("\u{1F50D} Running typecheck...");
+  const isVerbose = process.env.SSE_BUILD_VERBOSE === "true";
+  if (isVerbose) console.log("\u{1F50D} Running typecheck...");
   try {
     const args = ["tsc", "--noEmit"];
     if (options.watch) {
@@ -592,6 +601,8 @@ import { $ as $4 } from "execa";
 var packCommand = new Command5("pack").description(
   "Creates a tarball (.tgz) of the built package to inspect before publishing"
 ).action(async () => {
+  const isVerbose = process.env.SSE_BUILD_VERBOSE === "true";
+  const pm = getPackageManager();
   const cwd = process.cwd();
   const pkgJsonPath = path4.join(cwd, "package.json");
   try {
@@ -604,11 +615,12 @@ var packCommand = new Command5("pack").description(
       throw new Error(`No publish directory specified in package.json.`);
     }
     const publishDir = path4.join(cwd, publishDirBase);
-    console.log(`\u{1F4E6} Packing package from directory: ${publishDirBase}...`);
+    if (isVerbose)
+      console.log(`\u{1F4E6} Packing package from directory: ${publishDirBase}...`);
     await $4({
       stdio: "inherit",
       cwd: publishDir
-    })`npm pack`;
+    })`${pm} pack`;
     console.log(
       "\u2705 Pack successful! You can inspect the generated .tgz file."
     );
@@ -620,12 +632,19 @@ var packCommand = new Command5("pack").description(
 });
 
 // src/core/version.ts
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
 import { Command as Command6 } from "commander";
 import { $ as $5 } from "execa";
-var versionCommand = new Command6("version").description("Bumps the package version (patch, minor, or major)").argument(
-  "<type>",
-  "Version update type (patch, minor, major, or specific version like 1.2.3)"
+import enquirer from "enquirer";
+import * as semver2 from "semver";
+var versionCommand = new Command6("version").description("Bumps the package version interactively or manually").argument(
+  "[type]",
+  "Version update type (patch, minor, major, or specific version like 1.2.3). If omitted, an interactive prompt will appear."
 ).option("--no-git-tag-version", "Do not create a git tag").action(async (type, options) => {
+  const isVerbose = process.env.SSE_BUILD_VERBOSE === "true";
+  const pm = getPackageManager();
+  const cwd = process.cwd();
   const validTypes = [
     "patch",
     "minor",
@@ -635,19 +654,64 @@ var versionCommand = new Command6("version").description("Bumps the package vers
     "premajor",
     "prerelease"
   ];
-  if (!validTypes.includes(type) && !/^\d+\.\d+\.\d+/.test(type)) {
-    console.error(
-      `\u274C Invalid version type: ${type}. Use patch, minor, major, or a valid semver.`
-    );
-    process.exit(1);
+  let selectedType = type;
+  if (!selectedType) {
+    let currentVersion = "0.0.0";
+    try {
+      const pkgJsonPath = path5.join(cwd, "package.json");
+      const pkgContent = await fs5.readFile(pkgJsonPath, "utf-8");
+      currentVersion = JSON.parse(pkgContent).version || "0.0.0";
+    } catch (err) {
+      if (isVerbose)
+        console.warn(
+          "\u26A0\uFE0F Could not read current version from package.json. Defaulting to 0.0.0"
+        );
+    }
+    const choices = validTypes.map((bump) => {
+      const nextVersion = semver2.inc(currentVersion, bump);
+      return {
+        name: bump,
+        message: `${bump.padEnd(10)} (v${nextVersion})`
+      };
+    });
+    const { bumpType } = await enquirer.prompt({
+      type: "select",
+      name: "bumpType",
+      message: `Current version: ${currentVersion}. Select version bump type:`,
+      choices: [...choices, { name: "custom", message: "custom..." }]
+    });
+    if (bumpType === "custom") {
+      const { customVersion } = await enquirer.prompt({
+        type: "input",
+        name: "customVersion",
+        message: "Enter custom version (e.g., 1.2.3):",
+        validate: (value) => {
+          if (semver2.valid(value)) {
+            return true;
+          }
+          return "Please enter a valid semver version (e.g., 1.2.3 or 1.2.3-beta.1)";
+        }
+      });
+      selectedType = customVersion;
+    } else {
+      selectedType = bumpType;
+    }
+  } else {
+    if (!validTypes.includes(selectedType) && !semver2.valid(selectedType)) {
+      console.error(
+        `\u274C Invalid version type: ${selectedType}. Use patch, minor, major, or a valid semver.`
+      );
+      process.exit(1);
+    }
   }
-  console.log(`\u{1F4C8} Bumping version (${type})...`);
+  if (isVerbose)
+    console.log(`\u{1F4C8} Bumping version (${selectedType}) via ${pm}...`);
   try {
-    const args = ["version", type];
+    const args = ["version", selectedType];
     if (!options.gitTagVersion) {
       args.push("--no-git-tag-version");
     }
-    await $5({ stdio: "inherit" })`npm ${args}`;
+    await $5({ stdio: isVerbose ? "inherit" : "pipe" })`${pm} ${args}`;
     console.log("\u2705 Version bumped successfully!");
   } catch (error) {
     console.error("\u274C Failed to bump version.");
@@ -656,28 +720,29 @@ var versionCommand = new Command6("version").description("Bumps the package vers
 });
 
 // src/core/info.ts
-import * as fs5 from "fs/promises";
-import * as path5 from "path";
+import * as fs6 from "fs/promises";
+import * as path6 from "path";
 import { Command as Command7 } from "commander";
 async function getDirSize(dirPath) {
   let size = 0;
-  const files = await fs5.readdir(dirPath, { withFileTypes: true });
+  const files = await fs6.readdir(dirPath, { withFileTypes: true });
   for (const file of files) {
-    const fullPath = path5.join(dirPath, file.name);
+    const fullPath = path6.join(dirPath, file.name);
     if (file.isDirectory()) {
       size += await getDirSize(fullPath);
     } else {
-      const stats = await fs5.stat(fullPath);
+      const stats = await fs6.stat(fullPath);
       size += stats.size;
     }
   }
   return size;
 }
 var infoCommand = new Command7("info").description("Displays size and file statistics of the built package").action(async () => {
+  const isVerbose = process.env.SSE_BUILD_VERBOSE === "true";
   const cwd = process.cwd();
-  const pkgJsonPath = path5.join(cwd, "package.json");
+  const pkgJsonPath = path6.join(cwd, "package.json");
   try {
-    const packageJsonContent = await fs5.readFile(pkgJsonPath, {
+    const packageJsonContent = await fs6.readFile(pkgJsonPath, {
       encoding: "utf8"
     });
     const packageJson = JSON.parse(packageJsonContent);
@@ -685,10 +750,11 @@ var infoCommand = new Command7("info").description("Displays size and file stati
     if (!publishDirBase) {
       throw new Error(`No publish directory specified in package.json.`);
     }
-    const publishDir = path5.join(cwd, publishDirBase);
+    const publishDir = path6.join(cwd, publishDirBase);
     const sizeBytes = await getDirSize(publishDir);
     const sizeKB = (sizeBytes / 1024).toFixed(2);
     const sizeMB = (sizeBytes / (1024 * 1024)).toFixed(2);
+    if (isVerbose) console.log(`Gathering info from ${publishDir}...`);
     console.log(`
 \u{1F4CA} Package Info: ${packageJson.name}`);
     console.log(`================================`);
@@ -712,17 +778,19 @@ var infoCommand = new Command7("info").description("Displays size and file stati
 });
 
 // src/core/link.ts
-import * as fs6 from "fs/promises";
-import * as path6 from "path";
+import * as fs7 from "fs/promises";
+import * as path7 from "path";
 import { Command as Command8 } from "commander";
 import { $ as $6 } from "execa";
 var linkCommand = new Command8("link").description(
   "Symlinks the built package directory so it can be tested in other local projects"
 ).action(async () => {
+  const isVerbose = process.env.SSE_BUILD_VERBOSE === "true";
+  const pm = getPackageManager();
   const cwd = process.cwd();
-  const pkgJsonPath = path6.join(cwd, "package.json");
+  const pkgJsonPath = path7.join(cwd, "package.json");
   try {
-    const packageJsonContent = await fs6.readFile(pkgJsonPath, {
+    const packageJsonContent = await fs7.readFile(pkgJsonPath, {
       encoding: "utf8"
     });
     const packageJson = JSON.parse(packageJsonContent);
@@ -730,18 +798,19 @@ var linkCommand = new Command8("link").description(
     if (!publishDirBase) {
       throw new Error(`No publish directory specified in package.json.`);
     }
-    const publishDir = path6.join(cwd, publishDirBase);
-    console.log(`\u{1F517} Linking package from: ./${publishDirBase}...`);
+    const publishDir = path7.join(cwd, publishDirBase);
+    if (isVerbose)
+      console.log(`\u{1F517} Linking package from: ./${publishDirBase}...`);
     await $6({
-      stdio: "inherit",
+      stdio: isVerbose ? "inherit" : "pipe",
       cwd: publishDir
-    })`npm link`;
+    })`${pm} link`;
     console.log(`
 \u2705 Successfully linked!`);
     console.log(
       `To use this in another project, go to that project and run:`
     );
-    console.log(`\u{1F449} npm link ${packageJson.name}`);
+    console.log(`\u{1F449} ${pm} link ${packageJson.name}`);
   } catch (error) {
     console.error("\u274C Error executing link command:");
     if (error instanceof Error) console.error(error.message);
@@ -750,11 +819,11 @@ var linkCommand = new Command8("link").description(
 });
 
 // src/core/check-exports.ts
-import * as fs7 from "fs/promises";
-import * as path7 from "path";
+import * as fs8 from "fs/promises";
+import * as path8 from "path";
 import { Command as Command9 } from "commander";
 async function fileExists(filePath) {
-  return fs7.stat(filePath).then(() => true).catch(() => false);
+  return fs8.stat(filePath).then(() => true).catch(() => false);
 }
 function extractPaths(exportsObj) {
   let paths = [];
@@ -771,35 +840,36 @@ function extractPaths(exportsObj) {
 var checkExportsCommand = new Command9("check-exports").description(
   "Verifies that all files declared in package.json 'exports' actually exist in the build folder"
 ).action(async () => {
+  const isVerbose = process.env.SSE_BUILD_VERBOSE === "true";
   const cwd = process.cwd();
-  const pkgJsonPath = path7.join(cwd, "package.json");
+  const pkgJsonPath = path8.join(cwd, "package.json");
   try {
-    const rootPkgContent = await fs7.readFile(pkgJsonPath, {
+    const rootPkgContent = await fs8.readFile(pkgJsonPath, {
       encoding: "utf8"
     });
     const publishDirBase = JSON.parse(rootPkgContent).publishConfig?.directory || "build";
-    const buildPkgPath = path7.join(cwd, publishDirBase, "package.json");
+    const buildPkgPath = path8.join(cwd, publishDirBase, "package.json");
     if (!await fileExists(buildPkgPath)) {
       throw new Error(
         `Could not find compiled package.json at ./${publishDirBase}/package.json. Did you build first?`
       );
     }
-    const buildPkgContent = await fs7.readFile(buildPkgPath, {
+    const buildPkgContent = await fs8.readFile(buildPkgPath, {
       encoding: "utf8"
     });
     const buildPkg = JSON.parse(buildPkgContent);
     if (!buildPkg.exports) {
-      console.log("\u26A0\uFE0F No 'exports' field found to check.");
+      if (isVerbose) console.log("\u26A0\uFE0F No 'exports' field found to check.");
       return;
     }
     console.log(`\u{1F575}\uFE0F Checking exports mapping in ./${publishDirBase}...`);
     const allPaths = extractPaths(buildPkg.exports);
     let hasErrors = false;
     for (const relativePath of allPaths) {
-      const absolutePath = path7.join(cwd, publishDirBase, relativePath);
+      const absolutePath = path8.join(cwd, publishDirBase, relativePath);
       const exists = await fileExists(absolutePath);
       if (exists) {
-        console.log(`  \u2705 Found: ${relativePath}`);
+        if (isVerbose) console.log(`  \u2705 Found: ${relativePath}`);
       } else {
         console.error(`  \u274C Missing: ${relativePath}`);
         hasErrors = true;
@@ -820,7 +890,8 @@ var checkExportsCommand = new Command9("check-exports").description(
 });
 
 // src/core/watch.ts
-import * as path8 from "path";
+import * as fs9 from "fs/promises";
+import * as path9 from "path";
 import { Command as Command10 } from "commander";
 
 // node_modules/chokidar/index.js
@@ -913,7 +984,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat5;
     if (wantBigintFsStats) {
-      this._stat = (path9) => statMethod(path9, { bigint: true });
+      this._stat = (path10) => statMethod(path10, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -938,8 +1009,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path9, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path9));
+          const { path: path10, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path10));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -979,20 +1050,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path9, depth) {
+  async _exploreDir(path10, depth) {
     let files;
     try {
-      files = await readdir2(path9, this._rdOptions);
+      files = await readdir2(path10, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path9 };
+    return { files, depth, path: path10 };
   }
-  async _formatEntry(dirent, path9) {
+  async _formatEntry(dirent, path10) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path9, basename4));
+      const fullPath = presolve(pjoin(path10, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -1392,16 +1463,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path9, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path10, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path9);
-    emitRaw(rawEvent, evPath, { watchedPath: path9 });
-    if (evPath && path9 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path9, evPath), KEY_LISTENERS, sp.join(path9, evPath));
+    listener(path10);
+    emitRaw(rawEvent, evPath, { watchedPath: path10 });
+    if (evPath && path10 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path10, evPath), KEY_LISTENERS, sp.join(path10, evPath));
     }
   };
   try {
-    return fs_watch(path9, {
+    return fs_watch(path10, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -1417,12 +1488,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path9, fullPath, options, handlers) => {
+var setFsWatchListener = (path10, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path9, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path10, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -1433,7 +1504,7 @@ var setFsWatchListener = (path9, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path9,
+      path10,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -1448,7 +1519,7 @@ var setFsWatchListener = (path9, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path9, "r");
+          const fd = await open(path10, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -1479,7 +1550,7 @@ var setFsWatchListener = (path9, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path9, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path10, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -1501,7 +1572,7 @@ var setFsWatchFileListener = (path9, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path9, curr));
+          foreach(cont.listeners, (listener2) => listener2(path10, curr));
         }
       })
     };
@@ -1531,13 +1602,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path9, listener) {
+  _watchWithNodeFs(path10, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path9);
-    const basename4 = sp.basename(path9);
+    const directory = sp.dirname(path10);
+    const basename4 = sp.basename(path10);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sp.resolve(path9);
+    const absolutePath = sp.resolve(path10);
     const options = {
       persistent: opts.persistent
     };
@@ -1547,12 +1618,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path9, absolutePath, options, {
+      closer = setFsWatchFileListener(path10, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path9, absolutePath, options, {
+      closer = setFsWatchListener(path10, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -1568,13 +1639,13 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname4 = sp.dirname(file);
+    const dirname5 = sp.dirname(file);
     const basename4 = sp.basename(file);
-    const parent = this.fsw._getWatchedDir(dirname4);
+    const parent = this.fsw._getWatchedDir(dirname5);
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path9, newStats) => {
+    const listener = async (path10, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -1588,16 +1659,16 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path9);
+            this.fsw._closeFile(path10);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path9, closer2);
+              this.fsw._addPathCloser(path10, closer2);
           } else {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname4, basename4);
+          this.fsw._remove(dirname5, basename4);
         }
       } else if (parent.has(basename4)) {
         const at = newStats.atimeMs;
@@ -1624,7 +1695,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path9, item) {
+  async _handleSymlink(entry, directory, path10, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -1634,7 +1705,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path9);
+        linkPath = await fsrealpath(path10);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -1644,12 +1715,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path9, entry.stats);
+          this.fsw._emit(EV.CHANGE, path10, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path9, entry.stats);
+        this.fsw._emit(EV.ADD, path10, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -1679,9 +1750,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path9 = sp.join(directory, item);
+      let path10 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path9, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path10, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -1690,8 +1761,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path9 = sp.join(dir, sp.relative(dir, path9));
-        this._addToNodeFs(path9, initialAdd, wh, depth + 1);
+        path10 = sp.join(dir, sp.relative(dir, path10));
+        this._addToNodeFs(path10, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve4, reject) => {
@@ -1760,13 +1831,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path9, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path10, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path9) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path10) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path9);
+    const wh = this.fsw._getWatchHelpers(path10);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -1782,8 +1853,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path9);
-        const targetPath = follow ? await fsrealpath(path9) : path9;
+        const absPath = sp.resolve(path10);
+        const targetPath = follow ? await fsrealpath(path10) : path10;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -1793,29 +1864,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path9) : path9;
+        const targetPath = follow ? await fsrealpath(path10) : path10;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path9, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path10, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path9), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path10), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path9, closer);
+        this.fsw._addPathCloser(path10, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path9;
+        return path10;
       }
     }
   }
@@ -1847,35 +1918,35 @@ function createPattern(matcher) {
       if (matcher.path === string)
         return true;
       if (matcher.recursive) {
-        const relative3 = sp2.relative(matcher.path, string);
-        if (!relative3) {
+        const relative4 = sp2.relative(matcher.path, string);
+        if (!relative4) {
           return false;
         }
-        return !relative3.startsWith("..") && !sp2.isAbsolute(relative3);
+        return !relative4.startsWith("..") && !sp2.isAbsolute(relative4);
       }
       return false;
     };
   }
   return () => false;
 }
-function normalizePath(path9) {
-  if (typeof path9 !== "string")
+function normalizePath(path10) {
+  if (typeof path10 !== "string")
     throw new Error("string expected");
-  path9 = sp2.normalize(path9);
-  path9 = path9.replace(/\\/g, "/");
+  path10 = sp2.normalize(path10);
+  path10 = path10.replace(/\\/g, "/");
   let prepend = false;
-  if (path9.startsWith("//"))
+  if (path10.startsWith("//"))
     prepend = true;
-  path9 = path9.replace(DOUBLE_SLASH_RE, "/");
+  path10 = path10.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path9 = "/" + path9;
-  return path9;
+    path10 = "/" + path10;
+  return path10;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path9 = normalizePath(testString);
+  const path10 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path9, stats)) {
+    if (pattern(path10, stats)) {
       return true;
     }
   }
@@ -1913,19 +1984,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path9) => toUnix(sp2.normalize(toUnix(path9)));
-var normalizeIgnored = (cwd = "") => (path9) => {
-  if (typeof path9 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path9) ? path9 : sp2.join(cwd, path9));
+var normalizePathToUnix = (path10) => toUnix(sp2.normalize(toUnix(path10)));
+var normalizeIgnored = (cwd = "") => (path10) => {
+  if (typeof path10 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path10) ? path10 : sp2.join(cwd, path10));
   } else {
-    return path9;
+    return path10;
   }
 };
-var getAbsolutePath = (path9, cwd) => {
-  if (sp2.isAbsolute(path9)) {
-    return path9;
+var getAbsolutePath = (path10, cwd) => {
+  if (sp2.isAbsolute(path10)) {
+    return path10;
   }
-  return sp2.join(cwd, path9);
+  return sp2.join(cwd, path10);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -1990,10 +2061,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path9, follow, fsw) {
+  constructor(path10, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path9;
-    this.path = path9 = path9.replace(REPLACER_RE, "");
+    const watchPath = path10;
+    this.path = path10 = path10.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -2133,20 +2204,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path9) => {
-        const absPath = getAbsolutePath(path9, cwd);
+      paths = paths.map((path10) => {
+        const absPath = getAbsolutePath(path10, cwd);
         return absPath;
       });
     }
-    paths.forEach((path9) => {
-      this._removeIgnoredPath(path9);
+    paths.forEach((path10) => {
+      this._removeIgnoredPath(path10);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path9) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path9, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path10) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path10, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -2168,17 +2239,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path9) => {
-      if (!sp2.isAbsolute(path9) && !this._closers.has(path9)) {
+    paths.forEach((path10) => {
+      if (!sp2.isAbsolute(path10) && !this._closers.has(path10)) {
         if (cwd)
-          path9 = sp2.join(cwd, path9);
-        path9 = sp2.resolve(path9);
+          path10 = sp2.join(cwd, path10);
+        path10 = sp2.resolve(path10);
       }
-      this._closePath(path9);
-      this._addIgnoredPath(path9);
-      if (this._watched.has(path9)) {
+      this._closePath(path10);
+      this._addIgnoredPath(path10);
+      if (this._watched.has(path10)) {
         this._addIgnoredPath({
-          path: path9,
+          path: path10,
           recursive: true
         });
       }
@@ -2242,38 +2313,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path9, stats) {
+  async _emit(event, path10, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path9 = sp2.normalize(path9);
+      path10 = sp2.normalize(path10);
     if (opts.cwd)
-      path9 = sp2.relative(opts.cwd, path9);
-    const args = [path9];
+      path10 = sp2.relative(opts.cwd, path10);
+    const args = [path10];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path9))) {
+    if (awf && (pw = this._pendingWrites.get(path10))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path9, [event, ...args]);
+        this._pendingUnlinks.set(path10, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path10) => {
+          this._pendingUnlinks.forEach((entry, path11) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path10);
+            this._pendingUnlinks.delete(path11);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path9)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path10)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path9);
+        this._pendingUnlinks.delete(path10);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -2291,16 +2362,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path9, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path10, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path9, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path10, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path9) : path9;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path10) : path10;
       let stats2;
       try {
         stats2 = await stat7(fullPath);
@@ -2331,23 +2402,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path9, timeout) {
+  _throttle(actionType, path10, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path9);
+    const actionPath = action.get(path10);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path9);
+      const item = action.get(path10);
       const count = item ? item.count : 0;
-      action.delete(path9);
+      action.delete(path10);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -2355,7 +2426,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path9, thr);
+    action.set(path10, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -2369,44 +2440,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path9, threshold, event, awfEmit) {
+  _awaitWriteFinish(path10, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path9;
-    if (this.options.cwd && !sp2.isAbsolute(path9)) {
-      fullPath = sp2.join(this.options.cwd, path9);
+    let fullPath = path10;
+    if (this.options.cwd && !sp2.isAbsolute(path10)) {
+      fullPath = sp2.join(this.options.cwd, path10);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path9)) {
+        if (err || !writes.has(path10)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path9).lastChange = now2;
+          writes.get(path10).lastChange = now2;
         }
-        const pw = writes.get(path9);
+        const pw = writes.get(path10);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path9);
+          writes.delete(path10);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path9)) {
-      writes.set(path9, {
+    if (!writes.has(path10)) {
+      writes.set(path10, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path9);
+          writes.delete(path10);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -2417,8 +2488,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path9, stats) {
-    if (this.options.atomic && DOT_RE.test(path9))
+  _isIgnored(path10, stats) {
+    if (this.options.atomic && DOT_RE.test(path10))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -2428,17 +2499,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path9, stats);
+    return this._userIgnored(path10, stats);
   }
-  _isntIgnored(path9, stat8) {
-    return !this._isIgnored(path9, stat8);
+  _isntIgnored(path10, stat9) {
+    return !this._isIgnored(path10, stat9);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path9) {
-    return new WatchHelper(path9, this.options.followSymlinks, this);
+  _getWatchHelpers(path10) {
+    return new WatchHelper(path10, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -2470,63 +2541,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path9 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path9);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path9) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path9, 100))
+    const path10 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path10);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path10) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path10, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path9);
+    const wp = this._getWatchedDir(path10);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path9, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path10, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path9;
+    let relPath = path10;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path9);
+      relPath = sp2.relative(this.options.cwd, path10);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path9);
+    this._watched.delete(path10);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path9))
-      this._emit(eventName, path9);
-    this._closePath(path9);
+    if (wasTracked && !this._isIgnored(path10))
+      this._emit(eventName, path10);
+    this._closePath(path10);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path9) {
-    this._closeFile(path9);
-    const dir = sp2.dirname(path9);
-    this._getWatchedDir(dir).remove(sp2.basename(path9));
+  _closePath(path10) {
+    this._closeFile(path10);
+    const dir = sp2.dirname(path10);
+    this._getWatchedDir(dir).remove(sp2.basename(path10));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path9) {
-    const closers = this._closers.get(path9);
+  _closeFile(path10) {
+    const closers = this._closers.get(path10);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path9);
+    this._closers.delete(path10);
   }
-  _addPathCloser(path9, closer) {
+  _addPathCloser(path10, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path9);
+    let list = this._closers.get(path10);
     if (!list) {
       list = [];
-      this._closers.set(path9, list);
+      this._closers.set(path10, list);
     }
     list.push(closer);
   }
@@ -2557,49 +2628,227 @@ var chokidar_default = { watch, FSWatcher };
 
 // src/core/watch.ts
 import { $ as $7 } from "execa";
+import { build as esbuild2 } from "esbuild";
+import { findWorkspacesRoot as findWorkspacesRoot2 } from "find-workspaces";
 var watchCommand = new Command10("watch").description(
-  "Watches the src directory and rebuilds automatically on changes"
-).action(() => {
+  "Watches the src directory and incrementally rebuilds files on changes (Vite-style)"
+).action(async () => {
   const cwd = process.cwd();
-  const srcDir = path8.join(cwd, "src");
-  console.log(`\u{1F440} Watching for changes in ./src...`);
-  let isBuilding = false;
-  let buildQueued = false;
-  const runBuild = async () => {
-    if (isBuilding) {
-      buildQueued = true;
-      return;
-    }
-    isBuilding = true;
-    console.log(`
-\u23F3 Detected changes. Rebuilding...`);
+  const srcDir = path9.join(cwd, "src");
+  const pkgJsonPath = path9.join(cwd, "package.json");
+  let watcher = null;
+  let configWatcher = null;
+  const startWatcher = async (isReload = false) => {
+    if (watcher) {
+      await watcher.close();
+    }
+    const isVerbose = process.env.SSE_BUILD_VERBOSE === "true";
+    if (isReload) {
+      console.log(`
+\u{1F504} Configuration change detected. Reloading...`);
+    }
+    const packageJsonContent = await fs9.readFile(pkgJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonContent);
+    const buildDirBase = packageJson.publishConfig?.directory || "build";
+    const buildDir = path9.join(cwd, buildDirBase);
+    const fileConfig = await loadConfig();
+    const bundles = fileConfig.bundle || ["esm", "cjs"];
+    const isFlat = fileConfig.flat ?? false;
+    const packageType = packageJson.type === "module" ? "module" : "commonjs";
+    const isEsbuild = !!fileConfig.esbuild;
+    const builder = isEsbuild ? "esbuild" : "babel";
+    const workspaceDir = await findWorkspacesRoot2(cwd);
+    const rootDir = workspaceDir ? workspaceDir.location : cwd;
+    const pm = getPackageManager();
+    const pmExec = getPmExec();
+    let babelRuntimeVersion = packageJson.dependencies?.["@babel/runtime"];
+    const reactVersion = packageJson.peerDependencies?.react || "latest";
+    console.log(`\u{1F440} Watching for changes (Builder: ${builder})...`);
     try {
-      await $7({ stdio: "inherit" })`npx sse-tools build`;
-      console.log(`\u2705 Build updated successfully! Waiting for changes...`);
+      await $7({
+        stdio: "inherit",
+        preferLocal: true
+      })`${pmExec} sse-tools build`;
     } catch (err) {
-      console.error(`\u274C Build failed during watch.`);
-    } finally {
-      isBuilding = false;
-      if (buildQueued) {
-        buildQueued = false;
-        runBuild();
-      }
+      console.error(`\u274C Initial build failed. Waiting for changes...
+`);
     }
+    const buildFile = async (filePath) => {
+      const relativePath = path9.relative(srcDir, filePath);
+      if (builder === "esbuild") {
+        if (isVerbose)
+          console.log(
+            `\u{1F680} [esbuild] Incremental rebuild triggered by ${relativePath}...`
+          );
+        const esbuildConfig = fileConfig.esbuild;
+        const entryPoints = typeof esbuildConfig.entry === "string" ? [esbuildConfig.entry] : esbuildConfig.entry;
+        try {
+          await Promise.all(
+            bundles.map(async (bundle) => {
+              const outExtension = getOutExtension(bundle, {
+                isFlat,
+                packageType
+              });
+              const relativeOutDir = isFlat ? "." : bundle === "esm" ? "esm" : ".";
+              const outputDir = path9.join(buildDir, relativeOutDir);
+              await esbuild2({
+                entryPoints,
+                bundle: true,
+                outdir: outputDir,
+                format: bundle === "esm" ? "esm" : "cjs",
+                target: esbuildConfig.target || ["es2020", "node14"],
+                minify: esbuildConfig.minify ?? false,
+                outExtension: { ".js": outExtension },
+                external: [
+                  ...Object.keys(packageJson.dependencies || {}),
+                  ...Object.keys(packageJson.peerDependencies || {}),
+                  ...esbuildConfig.external || []
+                ]
+              });
+            })
+          );
+          if (isVerbose) console.log(`\u2705 [esbuild] Rebuild complete.`);
+        } catch (err) {
+          console.error(`\u274C [esbuild] Rebuild failed:`, err.message);
+        }
+      } else {
+        const ext = path9.extname(filePath);
+        if (![".js", ".jsx", ".ts", ".tsx"].includes(ext) || filePath.endsWith(".d.ts"))
+          return;
+        let babelConfigFile = path9.join(rootDir, "babel.config.js");
+        if (!await fs9.stat(babelConfigFile).then(() => true).catch(() => false)) {
+          babelConfigFile = path9.join(rootDir, "babel.config.mjs");
+        }
+        await Promise.all(
+          bundles.map(async (bundle) => {
+            const outExtension = getOutExtension(bundle, {
+              isFlat,
+              packageType
+            });
+            const relativeOutDir = isFlat ? "." : bundle === "esm" ? "esm" : ".";
+            const outputDir = path9.join(buildDir, relativeOutDir);
+            const outFilePath = path9.join(
+              outputDir,
+              relativePath.replace(new RegExp(`\\${ext}$`), outExtension)
+            );
+            await fs9.mkdir(path9.dirname(outFilePath), { recursive: true });
+            const env = {
+              NODE_ENV: "production",
+              BABEL_ENV: bundle === "esm" ? "stable" : "node",
+              SSE_OUT_FILE_EXTENSION: outExtension,
+              SSE_BABEL_RUNTIME_VERSION: babelRuntimeVersion,
+              ...getVersionEnvVariables(packageJson.version)
+            };
+            await $7({
+              stdio: "pipe",
+              preferLocal: true,
+              env: { ...process.env, ...env }
+            })`babel --config-file ${babelConfigFile} --extensions .js,.jsx,.ts,.tsx ${filePath} --out-file ${outFilePath}`;
+          })
+        );
+        if (isVerbose) console.log(`\u2705 [babel] Updated ${relativePath}`);
+      }
+    };
+    const updateExports = async () => {
+      try {
+        const freshPkg = JSON.parse(
+          await fs9.readFile(pkgJsonPath, "utf8")
+        );
+        const relativeOutDirs = !isFlat ? { cjs: ".", esm: "esm" } : { cjs: ".", esm: "." };
+        await writePackageJson({
+          cwd,
+          packageJson: freshPkg,
+          bundles: bundles.map((type) => ({
+            type,
+            dir: relativeOutDirs[type]
+          })),
+          outputDir: buildDir,
+          addTypes: fileConfig.buildTypes ?? true,
+          isFlat,
+          packageType,
+          exportExtensions: fileConfig.exportExtensions
+        });
+      } catch (e) {
+        console.error(`\u274C Failed to update exports: ${e.message}`);
+      }
+    };
+    let exportTimeout;
+    const debouncedUpdateExports = () => {
+      clearTimeout(exportTimeout);
+      exportTimeout = setTimeout(() => updateExports(), 150);
+    };
+    watcher = chokidar_default.watch(srcDir, {
+      ignored: /(^|[\/\\])\../,
+      persistent: true,
+      ignoreInitial: true
+    });
+    watcher.on("change", async (filePath) => await buildFile(filePath)).on("add", async (filePath) => {
+      await buildFile(filePath);
+      debouncedUpdateExports();
+    }).on("unlink", async (filePath) => {
+      const relativePath = path9.relative(srcDir, filePath);
+      const ext = path9.extname(filePath);
+      for (const bundle of bundles) {
+        const outExtension = getOutExtension(bundle, {
+          isFlat,
+          packageType,
+          isType: false
+        });
+        const relativeOutDir = isFlat ? "." : bundle === "esm" ? "esm" : ".";
+        const outputDir = path9.join(buildDir, relativeOutDir);
+        const outRelativePath = relativePath.replace(
+          new RegExp(`\\${ext}$`),
+          outExtension
+        );
+        await fs9.rm(path9.join(outputDir, outRelativePath), { force: true }).catch(() => {
+        });
+      }
+      debouncedUpdateExports();
+    }).on("unlinkDir", async (dirPath) => {
+      const relativePath = path9.relative(srcDir, dirPath);
+      for (const bundle of bundles) {
+        const relativeOutDir = isFlat ? "." : bundle === "esm" ? "esm" : ".";
+        await fs9.rm(path9.join(buildDir, relativeOutDir, relativePath), {
+          recursive: true,
+          force: true
+        }).catch(() => {
+        });
+      }
+      debouncedUpdateExports();
+    });
   };
-  const watcher = chokidar_default.watch(srcDir, {
-    ignored: /(^|[\/\\])\../,
-    // ignore dotfiles
-    persistent: true,
-    ignoreInitial: true
-    // Don't trigger on startup
-  });
-  watcher.on("add", runBuild).on("change", runBuild).on("unlink", runBuild);
+  const configFiles = [
+    "sse.config.ts",
+    "sse.config.js",
+    "sse.config.mjs",
+    "sse.config.cjs",
+    "sse.config.mts",
+    "sse.config.cts",
+    "sse.config.json",
+    "package.json"
+  ];
+  configWatcher = chokidar_default.watch(
+    configFiles.map((f) => path9.join(cwd, f)),
+    {
+      persistent: true,
+      ignoreInitial: true
+    }
+  );
+  configWatcher.on("change", () => startWatcher(true));
+  await startWatcher();
 });
 
 // src/cli.ts
 async function main() {
   const program = new Command11();
-  program.name("sse-tools").description("CLI utilities for managing and building MUI packages").version("1.0.0");
+  program.name("sse-tools").description(
+    chalk2.cyan("CLI utilities for managing and building SSE packages")
+  ).version("1.0.0").option("-v, --verbose", "Enable verbose logging across all commands");
+  program.hook("preAction", (thisCommand) => {
+    if (thisCommand.opts().verbose) {
+      process.env.SSE_BUILD_VERBOSE = "true";
+    }
+  });
   program.addCommand(buildCommand);
   program.addCommand(publishCommand);
   program.addCommand(cleanCommand);