@sse-ui/builder 1.1.0 → 1.3.0

package/dist/cli.js

@@ -1,13 +1,18 @@
 #!/usr/bin/env node
+import {
+  getVersionEnvVariables
+} from "./chunk-6NNEV5YX.js";
 import {
   addLicense,
   getOutExtension,
   mapConcurrently,
   validatePkgJson,
   writePackageJson
-} from "./chunk-44E7L73Q.js";
+} from "./chunk-N46AJ2OI.js";
+import "./chunk-MLKGABMK.js";
 
 // src/cli.ts
+import chalk11 from "chalk";
 import { Command as Command11 } from "commander";
 
 // src/core/build.ts
@@ -20,6 +25,7 @@ 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";
@@ -30,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 || {};
@@ -41,8 +47,22 @@ async function loadConfig() {
   }
 }
 
+// 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";
+}
+function getPmExec() {
+  const pm = getPackageManager();
+  if (pm === "pnpm") return ["pnpm", "exec"];
+  if (pm === "yarn") return ["yarn"];
+  return ["npx"];
+}
+
 // src/core/build.ts
-var buildCommand = new Command("build").description("Builds the package for publishing.").option("--bundle <bundles...>", "Bundles to output", ["esm", "cjs"]).option(
+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
@@ -72,112 +92,118 @@ 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(
-  "--bundleSingleFile",
-  "Bundle all modules into single files using esbuild (tsup style)",
-  false
 ).option(
   "--exportExtensions <exts...>",
   "Available extensions for generating exports wildcards.",
   [".js", ".mjs", ".cjs"]
-).option("--verbose", "Enable verbose logging.", false).action(async (cliOptions) => {
+).option("--minify", "Minify the generated output.").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,
-    bundleSingleFile: cliOptions.bundleSingleFile ?? fileConfig.bundleSingleFile ?? false,
-    exportExtensions: cliOptions.exportExtensions ?? fileConfig.exportExtensions ?? [".js", ".mjs", ".cjs"]
-  };
-  const {
-    bundle: bundles,
-    hasLargeFiles,
-    skipBundlePackageJson,
-    verbose = false,
-    ignore: extraIgnores,
-    buildTypes,
-    skipTsc,
-    skipBabelRuntimeCheck = false,
-    skipPackageJson = false,
-    enableReactCompiler = false,
-    tsgo: useTsgo = false,
-    bundleSingleFile,
-    exportExtensions
-  } = 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 minify = cliOptions.minify ?? fileConfig.minify ?? 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(chalk.blue(`Selected output directory: "${buildDirBase}"`));
+    if (isFlat)
+      console.log(chalk.blue("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`."
     );
   }
   if (!bundles || bundles.length === 0) {
     console.error(
-      "No bundles specified. Use --bundle to specify which bundles to build."
+      chalk.red(
+        "No bundles specified. Use --bundle to specify which bundles to build."
+      )
     );
     return;
   }
-  const { build: babelBuild, cjsCopy } = await import("./babel-QBNMMXUJ.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.' : ""}`
     );
   }
-  if (bundleSingleFile) {
-    if (verbose)
-      console.log("\u{1F4E6} Bundling package into single files via esbuild...");
+  if (builder === "esbuild") {
+    if (isVerbose)
+      console.log(
+        chalk.green("\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(
+        chalk.red(
+          "Esbuild requires an 'entry' point. Please define it in your config (esbuild.entry) or via --entry."
+        )
+      );
+    }
+    const entryPoints = typeof rawEntryPoints === "string" ? [rawEntryPoints] : rawEntryPoints;
     await Promise.all(
       bundles.map(async (bundle) => {
         const outExtension = getOutExtension(bundle, {
-          isFlat: !!options.flat,
+          isFlat: !!isFlat,
           isType: false,
           packageType
         });
@@ -185,18 +211,21 @@ var buildCommand = new Command("build").description("Builds the package for publ
         const outputDir = path.join(buildDir, relativeOutDir);
         await fs.mkdir(outputDir, { recursive: true });
         await esbuild({
-          entryPoints: [path.join(sourceDir, "index.ts")],
+          entryPoints,
           bundle: true,
-          outfile: path.join(outputDir, `index${outExtension}`),
+          outdir: outputDir,
           format: bundle === "esm" ? "esm" : "cjs",
-          target: ["es2020", "node14"],
-          minify: false,
+          target: esbuildConfig.target || ["es2020", "node14"],
+          minify,
+          outExtension: { ".js": outExtension },
+          // Forces the correct extension output
           external: [
             ...Object.keys(packageJson.dependencies || {}),
-            ...Object.keys(packageJson.peerDependencies || {})
+            ...Object.keys(packageJson.peerDependencies || {}),
+            ...esbuildConfig.external || []
           ]
         });
-        if (buildDir !== outputDir && !skipBundlePackageJson && !options.flat) {
+        if (buildDir !== outputDir && !skipBundlePackageJson && !isFlat) {
           await fs.writeFile(
             path.join(outputDir, "package.json"),
             JSON.stringify({
@@ -211,16 +240,24 @@ var buildCommand = new Command("build").description("Builds the package for publ
           name: packageJson.name,
           version: packageJson.version,
           outputDir,
-          isFlat: !!options.flat,
+          isFlat: !!isFlat,
           packageType
         });
       })
     );
   } else {
+    if (isVerbose)
+      console.log(chalk.green("\u{1F4E6} Transpiling package via Babel..."));
+    const { build: babelBuild, cjsCopy } = await import("./babel-6NHCDM3A.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: !!options.flat,
+          isFlat: !!isFlat,
           isType: false,
           packageType
         });
@@ -236,18 +273,17 @@ var buildCommand = new Command("build").description("Builds the package for publ
             babelRuntimeVersion,
             hasLargeFiles,
             bundle,
-            verbose,
+            verbose: isVerbose,
+            minify,
             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
+            reactCompiler: enableReactCompiler ? { reactVersion: reactVersion || "latest" } : void 0
           })
         );
-        if (buildDir !== outputDir && !skipBundlePackageJson && !options.flat) {
+        if (buildDir !== outputDir && !skipBundlePackageJson && !isFlat) {
           promises.push(
             fs.writeFile(
               path.join(outputDir, "package.json"),
@@ -258,7 +294,7 @@ var buildCommand = new Command("build").description("Builds the package for publ
             )
           );
         }
-        if (!options.flat) {
+        if (!isFlat) {
           promises.push(cjsCopy({ from: sourceDir, to: outputDir }));
         }
         await Promise.all(promises);
@@ -268,35 +304,48 @@ var buildCommand = new Command("build").description("Builds the package for publ
           name: packageJson.name,
           version: packageJson.version,
           outputDir,
-          isFlat: !!options.flat,
+          isFlat: !!isFlat,
           packageType
         });
       })
     );
-    if (options.flat) {
+    if (isFlat) {
       await cjsCopy({ from: sourceDir, to: buildDir });
     }
   }
-  if (buildTypes) {
-    const tsMod = await import("./typescript-3J237V7Q.js");
+  if (buildTypes === true) {
+    if (isVerbose)
+      console.log(chalk.cyan("\u{1F4DD} Generating TypeScript declarations..."));
+    const tsMod = await import("./typescript-42L4XZEH.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({
@@ -308,16 +357,17 @@ var buildCommand = new Command("build").description("Builds the package for publ
     })),
     outputDir: buildDir,
     addTypes: buildTypes,
-    isFlat: !!options.flat,
+    isFlat: !!isFlat,
     packageType,
-    exportExtensions: options.exportExtensions
+    exportExtensions
   });
   await copyHandler({
     cwd,
-    globs: options.copy ?? [],
+    globs: copyGlobs,
     buildDir,
-    verbose: options.verbose
+    verbose: isVerbose
   });
+  console.log(chalk.green.bold("\u2714 Build completed successfully"));
 });
 async function copyHandler({
   cwd,
@@ -340,13 +390,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;
         }
@@ -411,7 +458,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,
@@ -421,7 +468,7 @@ async function recursiveCopy({
   try {
     await fs.cp(source, target, { recursive: true });
     if (verbose) {
-      console.log(`Copied ${source} to ${target}`);
+      console.log(chalk.gray(`\u{1F4C4} Copied ${source} \u2192 ${target}`));
     }
     return true;
   } catch (err) {
@@ -429,7 +476,7 @@ async function recursiveCopy({
       throw err;
     }
     if (verbose) {
-      console.warn(`Source does not exist: ${source}`);
+      console.warn(chalk.yellow(`\u26A0 Source does not exist: ${source}`));
     }
     throw err;
   }
@@ -440,12 +487,7 @@ 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";
-}
+import chalk2 from "chalk";
 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(
@@ -458,6 +500,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 {
@@ -482,9 +525,13 @@ 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(
+        chalk2.blue(
+          `\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);
@@ -496,11 +543,11 @@ var publishCommand = new Command2("publish").description(
       stdio: "inherit",
       cwd: publishDir
     })`${pm} ${args}`;
-    console.log("\u2705 Successfully published!");
+    console.log(chalk2.green("\u2705 Successfully published!"));
   } catch (error) {
-    console.error("\u274C Error executing publish command:");
+    console.error(chalk2.red("\u274C Error executing publish command:"));
     if (error instanceof Error) {
-      console.error(error.message);
+      console.error(chalk2.red(error.message));
     }
     process.exit(1);
   }
@@ -510,9 +557,11 @@ var publishCommand = new Command2("publish").description(
 import * as fs3 from "fs/promises";
 import * as path3 from "path";
 import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
 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 {
@@ -522,13 +571,16 @@ 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(
+        chalk3.blue(`\u{1F9F9} Cleaning build directory: ${buildDirBase}...`)
+      );
     await fs3.rm(buildDir, { recursive: true, force: true });
-    console.log("\u2728 Cleaned successfully!");
+    console.log(chalk3.green("\u2728 Cleaned successfully!"));
   } catch (error) {
-    console.error("\u274C Error executing clean command:");
+    console.error(chalk3.red("\u274C Error executing clean command:"));
     if (error instanceof Error) {
-      console.error(error.message);
+      console.error(chalk3.red(error.message));
     }
     process.exit(1);
   }
@@ -537,10 +589,12 @@ var cleanCommand = new Command3("clean").description(
 // src/core/typecheck.ts
 import { Command as Command4 } from "commander";
 import { $ as $3 } from "execa";
+import chalk4 from "chalk";
 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(chalk4.blue("\u{1F50D} Running typecheck..."));
   try {
     const args = ["tsc", "--noEmit"];
     if (options.watch) {
@@ -548,11 +602,13 @@ var typecheckCommand = new Command4("typecheck").description(
     }
     await $3({ stdio: "inherit" })`${args.join(" ")}`;
     if (!options.watch) {
-      console.log("\u2705 Typecheck passed! No errors found.");
+      console.log(chalk4.green("\u2705 Typecheck passed! No errors found."));
     }
   } catch (error) {
     console.error(
-      "\u274C Typecheck failed. Please fix the TypeScript errors above."
+      chalk4.red(
+        "\u274C Typecheck failed. Please fix the TypeScript errors above."
+      )
     );
     process.exit(1);
   }
@@ -563,9 +619,12 @@ import * as fs4 from "fs/promises";
 import * as path4 from "path";
 import { Command as Command5 } from "commander";
 import { $ as $4 } from "execa";
+import chalk5 from "chalk";
 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 {
@@ -578,28 +637,41 @@ 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(
+        chalk5.blue(`\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."
+      chalk5.green(
+        "\u2705 Pack successful! You can inspect the generated .tgz file."
+      )
     );
   } catch (error) {
-    console.error("\u274C Error executing pack command:");
-    if (error instanceof Error) console.error(error.message);
+    console.error(chalk5.red("\u274C Error executing pack command:"));
+    if (error instanceof Error) console.error(chalk5.red(error.message));
     process.exit(1);
   }
 });
 
 // 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";
+import chalk6 from "chalk";
+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",
@@ -609,49 +681,102 @@ 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(
+          chalk6.yellow(
+            "\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(
+        chalk6.red(
+          `\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(
+      chalk6.cyan(`\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}`;
-    console.log("\u2705 Version bumped successfully!");
+    await $5({ stdio: isVerbose ? "inherit" : "pipe" })`${pm} ${args}`;
+    console.log(chalk6.green("\u2705 Version bumped successfully!"));
   } catch (error) {
-    console.error("\u274C Failed to bump version.");
+    console.error(chalk6.red("\u274C Failed to bump version."));
     process.exit(1);
   }
 });
 
 // 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";
+import chalk7 from "chalk";
 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);
@@ -659,44 +784,53 @@ 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);
-    console.log(`
-\u{1F4CA} Package Info: ${packageJson.name}`);
-    console.log(`================================`);
-    console.log(`Version:       ${packageJson.version}`);
-    console.log(`Build Folder:  ./${publishDirBase}`);
+    if (isVerbose)
+      console.log(chalk7.gray(`Gathering info from ${publishDir}...`));
+    console.log(
+      chalk7.cyan(`
+\u{1F4CA} Package Info: `) + chalk7.bold(packageJson.name)
+    );
+    console.log(chalk7.gray(`================================`));
+    console.log(`Version:       ${chalk7.white(packageJson.version)}`);
+    console.log(`Build Folder:  ${chalk7.white(`./${publishDirBase}`)}`);
     if (sizeBytes > 1024 * 1024) {
       console.log(
-        `Total Size:    ${sizeMB} MB \u26A0\uFE0F (Consider keeping packages under 1MB)`
+        `Total Size:    ${chalk7.yellow(`${sizeMB} MB`)} ${chalk7.red("\u26A0\uFE0F (Consider keeping packages under 1MB)")}`
       );
     } else {
-      console.log(`Total Size:    ${sizeKB} KB \u2705`);
+      console.log(`Total Size:    ${chalk7.green(`${sizeKB} KB \u2705`)}`);
     }
-    console.log(`================================
-`);
+    console.log(chalk7.gray(`================================
+`));
   } catch (error) {
     console.error(
-      "\u274C Error fetching package info. Did you build the project first?"
+      chalk7.red(
+        "\u274C Error fetching package info. Did you build the project first?"
+      )
     );
     process.exit(1);
   }
 });
 
 // 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";
+import chalk8 from "chalk";
 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);
@@ -704,31 +838,36 @@ 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(
+        chalk8.blue(`\u{1F517} Linking package from: ./${publishDirBase}...`)
+      );
     await $6({
-      stdio: "inherit",
+      stdio: isVerbose ? "inherit" : "pipe",
       cwd: publishDir
-    })`npm link`;
-    console.log(`
-\u2705 Successfully linked!`);
+    })`${pm} link`;
+    console.log(chalk8.green(`
+\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(chalk8.cyan(`\u{1F449} ${pm} link ${packageJson.name}`));
   } catch (error) {
-    console.error("\u274C Error executing link command:");
-    if (error instanceof Error) console.error(error.message);
+    console.error(chalk8.red("\u274C Error executing link command:"));
+    if (error instanceof Error) console.error(chalk8.red(error.message));
     process.exit(1);
   }
 });
 
 // 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";
+import chalk9 from "chalk";
+import { globby as globby2 } from "globby";
 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 = [];
@@ -745,56 +884,85 @@ 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(chalk9.yellow("\u26A0\uFE0F No 'exports' field found to check."));
       return;
     }
-    console.log(`\u{1F575}\uFE0F Checking exports mapping in ./${publishDirBase}...`);
+    console.log(
+      chalk9.blue(`\u{1F575}\uFE0F Checking exports mapping in ./${publishDirBase}...`)
+    );
     const allPaths = extractPaths(buildPkg.exports);
+    const uniquePaths = Array.from(new Set(allPaths));
     let hasErrors = false;
-    for (const relativePath of allPaths) {
-      const absolutePath = path7.join(cwd, publishDirBase, relativePath);
-      const exists = await fileExists(absolutePath);
-      if (exists) {
-        console.log(`  \u2705 Found: ${relativePath}`);
+    const publishDirFullPath = path8.join(cwd, publishDirBase);
+    for (const relativePath of uniquePaths) {
+      if (relativePath.includes("*")) {
+        const matchedFiles = await globby2(relativePath, {
+          cwd: publishDirFullPath
+        });
+        if (matchedFiles.length > 0) {
+          if (isVerbose)
+            console.log(
+              chalk9.green(`  \u2705 Found matches for pattern: ${relativePath}`)
+            );
+        } else {
+          console.error(
+            chalk9.red(`  \u274C No files match pattern: ${relativePath}`)
+          );
+          hasErrors = true;
+        }
       } else {
-        console.error(`  \u274C Missing: ${relativePath}`);
-        hasErrors = true;
+        const absolutePath = path8.join(publishDirFullPath, relativePath);
+        const exists = await fileExists(absolutePath);
+        if (exists) {
+          if (isVerbose)
+            console.log(chalk9.green(`  \u2705 Found: ${relativePath}`));
+        } else {
+          console.error(chalk9.red(`  \u274C Missing: ${relativePath}`));
+          hasErrors = true;
+        }
       }
     }
     if (hasErrors) {
       console.error(
-        "\n\u274C Export check failed! Some files declared in package.json are missing."
+        chalk9.red(
+          "\n\u274C Export check failed! Some files declared in package.json are missing."
+        )
       );
       process.exit(1);
     } else {
-      console.log("\n\u2728 All exported files are present and accounted for!");
+      console.log(
+        chalk9.green("\n\u2728 All exported files are present and accounted for!")
+      );
     }
   } catch (error) {
-    if (error instanceof Error) console.error(error.message);
+    if (error instanceof Error) console.error(chalk9.red(error.message));
     process.exit(1);
   }
 });
 
 // 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
@@ -887,7 +1055,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;
     }
@@ -912,8 +1080,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)
@@ -953,20 +1121,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) {
@@ -1366,16 +1534,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) {
@@ -1391,12 +1559,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);
@@ -1407,7 +1575,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,
@@ -1422,7 +1590,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) {
@@ -1453,7 +1621,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;
@@ -1475,7 +1643,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));
         }
       })
     };
@@ -1505,13 +1673,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
     };
@@ -1521,12 +1689,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
@@ -1542,13 +1710,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) {
@@ -1562,16 +1730,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;
@@ -1598,7 +1766,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;
     }
@@ -1608,7 +1776,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;
@@ -1618,12 +1786,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;
@@ -1653,9 +1821,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) {
@@ -1664,8 +1832,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) => {
@@ -1734,13 +1902,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);
@@ -1756,8 +1924,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);
@@ -1767,29 +1935,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;
       }
     }
   }
@@ -1821,35 +1989,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;
     }
   }
@@ -1887,19 +2055,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 {
@@ -1964,10 +2132,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 = [];
@@ -2107,20 +2275,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;
@@ -2142,17 +2310,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
         });
       }
@@ -2216,38 +2384,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) {
@@ -2265,16 +2433,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);
@@ -2305,23 +2473,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);
@@ -2329,7 +2497,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() {
@@ -2343,44 +2511,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;
         }
@@ -2391,8 +2559,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;
@@ -2402,17 +2570,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
   // -----------------
@@ -2444,63 +2612,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);
   }
@@ -2531,49 +2699,243 @@ 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";
+import chalk10 from "chalk";
 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;
+  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(
+        chalk10.cyan(`
+\u{1F504} Configuration change detected. Reloading...`)
+      );
     }
-    isBuilding = true;
-    console.log(`
-\u23F3 Detected changes. Rebuilding...`);
+    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(
+      chalk10.blue(`\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(
+        chalk10.red(`\u274C Initial build failed. Waiting for changes...
+`)
+      );
     }
+    const buildFile = async (filePath) => {
+      const relativePath = path9.relative(srcDir, filePath);
+      const minify = fileConfig.minify ?? false;
+      if (builder === "esbuild") {
+        if (isVerbose)
+          console.log(
+            chalk10.gray(
+              `\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,
+                outExtension: { ".js": outExtension },
+                external: [
+                  ...Object.keys(packageJson.dependencies || {}),
+                  ...Object.keys(packageJson.peerDependencies || {}),
+                  ...esbuildConfig.external || []
+                ]
+              });
+            })
+          );
+          if (isVerbose)
+            console.log(chalk10.green(`\u2705 [esbuild] Rebuild complete.`));
+        } catch (err) {
+          console.error(
+            chalk10.red(`\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_MINIFY: minify ? "true" : void 0,
+              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(chalk10.green(`\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(chalk10.red(`\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(
+    chalk11.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);