elit 3.6.6 → 3.6.7

package/dist/build.js

@@ -2533,7 +2533,19 @@ error: ${text}`);
     }
   });
 
-  // src/runtime.ts
+  // src/build/constants.ts
+  var defaultOptions = {
+    outDir: "dist",
+    minify: true,
+    sourcemap: false,
+    target: "es2020",
+    format: "esm",
+    treeshake: true,
+    logging: true,
+    external: []
+  };
+
+  // src/shares/runtime.ts
   var runtime = (() => {
     if (typeof Deno !== "undefined") return "deno";
     if (typeof Bun !== "undefined") return "bun";
@@ -2543,7 +2555,15 @@ error: ${text}`);
   var isBun = runtime === "bun";
   var isDeno = runtime === "deno";
 
-  // src/fs.ts
+  // src/server/fs/node-modules.ts
+  var fs;
+  var fsPromises;
+  if (isNode || isBun) {
+    fs = __require("fs");
+    fsPromises = __require("fs/promises");
+  }
+
+  // src/server/fs/utils.ts
   function parseOptions(options, defaultValue) {
     return typeof options === "string" ? { encoding: options } : options || defaultValue;
   }
@@ -2562,12 +2582,37 @@ error: ${text}`);
     }
     return data;
   }
-  var fs;
-  var fsPromises;
-  if (isNode || isBun) {
-    fs = __require("fs");
-    fsPromises = __require("fs/promises");
+  function createStatsFromDenoFileInfo(info) {
+    return {
+      isFile: () => info.isFile,
+      isDirectory: () => info.isDirectory,
+      isBlockDevice: () => false,
+      isCharacterDevice: () => false,
+      isSymbolicLink: () => info.isSymlink || false,
+      isFIFO: () => false,
+      isSocket: () => false,
+      dev: info.dev || 0,
+      ino: info.ino || 0,
+      mode: info.mode || 0,
+      nlink: info.nlink || 1,
+      uid: info.uid || 0,
+      gid: info.gid || 0,
+      rdev: 0,
+      size: info.size,
+      blksize: info.blksize || 4096,
+      blocks: info.blocks || Math.ceil(info.size / 512),
+      atimeMs: info.atime?.getTime() || Date.now(),
+      mtimeMs: info.mtime?.getTime() || Date.now(),
+      ctimeMs: info.birthtime?.getTime() || Date.now(),
+      birthtimeMs: info.birthtime?.getTime() || Date.now(),
+      atime: info.atime || /* @__PURE__ */ new Date(),
+      mtime: info.mtime || /* @__PURE__ */ new Date(),
+      ctime: info.birthtime || /* @__PURE__ */ new Date(),
+      birthtime: info.birthtime || /* @__PURE__ */ new Date()
+    };
   }
+
+  // src/server/fs/file-ops.ts
   function readFileSync(path, options) {
     const opts = parseOptions(options, {});
     if (isNode || isBun) {
@@ -2603,6 +2648,8 @@ error: ${text}`);
     }
     throw new Error("Unsupported runtime");
   }
+
+  // src/server/fs/directory-ops.ts
   function mkdirSync(path, options) {
     const opts = typeof options === "number" ? { mode: options } : options || {};
     if (isNode || isBun) {
@@ -2611,6 +2658,8 @@ error: ${text}`);
       Deno.mkdirSync(path, { recursive: opts.recursive });
     }
   }
+
+  // src/server/fs/path-ops.ts
   function copyFileSync(src, dest, flags) {
     if (isNode || isBun) {
       fs.copyFileSync(src, dest, flags);
@@ -2618,67 +2667,34 @@ error: ${text}`);
       Deno.copyFileSync(src, dest);
     }
   }
-  function createStatsFromDenoFileInfo(info) {
-    return {
-      isFile: () => info.isFile,
-      isDirectory: () => info.isDirectory,
-      isBlockDevice: () => false,
-      isCharacterDevice: () => false,
-      isSymbolicLink: () => info.isSymlink || false,
-      isFIFO: () => false,
-      isSocket: () => false,
-      dev: info.dev || 0,
-      ino: info.ino || 0,
-      mode: info.mode || 0,
-      nlink: info.nlink || 1,
-      uid: info.uid || 0,
-      gid: info.gid || 0,
-      rdev: 0,
-      size: info.size,
-      blksize: info.blksize || 4096,
-      blocks: info.blocks || Math.ceil(info.size / 512),
-      atimeMs: info.atime?.getTime() || Date.now(),
-      mtimeMs: info.mtime?.getTime() || Date.now(),
-      ctimeMs: info.birthtime?.getTime() || Date.now(),
-      birthtimeMs: info.birthtime?.getTime() || Date.now(),
-      atime: info.atime || /* @__PURE__ */ new Date(),
-      mtime: info.mtime || /* @__PURE__ */ new Date(),
-      ctime: info.birthtime || /* @__PURE__ */ new Date(),
-      birthtime: info.birthtime || /* @__PURE__ */ new Date()
-    };
-  }
 
-  // src/path.ts
+  // src/server/path/platform.ts
   function getSeparator(isWin) {
     return isWin ? "\\" : "/";
   }
   function getCwd() {
     if (isNode || isBun) {
       return process.cwd();
-    } else if (isDeno) {
+    }
+    if (isDeno) {
       return Deno.cwd();
     }
     return "/";
   }
+  var isWindows = (() => {
+    if (isNode) {
+      return process.platform === "win32";
+    }
+    if (isDeno) {
+      return Deno.build.os === "windows";
+    }
+    return typeof process !== "undefined" && process.platform === "win32";
+  })();
+
+  // src/server/path/operations.ts
   function findLastSeparator(path) {
     return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
   }
-  function createPathOps(isWin) {
-    return {
-      sep: getSeparator(isWin),
-      delimiter: isWin ? ";" : ":",
-      normalize: (path) => normalizePath(path, isWin),
-      join: (...paths) => joinPaths(paths, isWin),
-      resolve: (...paths) => resolvePaths(paths, isWin),
-      isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
-      relative: (from, to) => relativePath(from, to, isWin),
-      dirname: (path) => getDirname(path, isWin),
-      basename: (path, ext) => getBasename(path, ext, isWin),
-      extname: (path) => getExtname(path),
-      parse: (path) => parsePath(path, isWin),
-      format: (pathObject) => formatPath(pathObject, isWin)
-    };
-  }
   function isAbsolutePosix(path) {
     return path.length > 0 && path[0] === "/";
   }
@@ -2699,28 +2715,18 @@ error: ${text}`);
     }
     return false;
   }
-  var isWindows = (() => {
-    if (isNode) {
-      return process.platform === "win32";
-    } else if (isDeno) {
-      return Deno.build.os === "windows";
-    }
-    return typeof process !== "undefined" && process.platform === "win32";
-  })();
-  var posix = createPathOps(false);
-  var win32 = createPathOps(true);
   function normalizePath(path, isWin) {
     if (path.length === 0) return ".";
     const separator = getSeparator(isWin);
     const isAbsolute = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
     const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
-    let normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+    const normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
     const parts = normalized.split(separator);
     const result = [];
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
+    for (let index = 0; index < parts.length; index++) {
+      const part = parts[index];
       if (part === "" || part === ".") {
-        if (i === 0 && isAbsolute) result.push("");
+        if (index === 0 && isAbsolute) result.push("");
         continue;
       }
       if (part === "..") {
@@ -2735,21 +2741,21 @@ error: ${text}`);
         result.push(part);
       }
     }
-    let final = result.join(separator);
-    if (final.length === 0) {
+    let finalPath = result.join(separator);
+    if (finalPath.length === 0) {
       return isAbsolute ? separator : ".";
     }
-    if (trailingSeparator && final[final.length - 1] !== separator) {
-      final += separator;
+    if (trailingSeparator && finalPath[finalPath.length - 1] !== separator) {
+      finalPath += separator;
     }
-    return final;
+    return finalPath;
   }
   function joinPaths(paths, isWin) {
     if (paths.length === 0) return ".";
     const separator = getSeparator(isWin);
     let joined = "";
-    for (let i = 0; i < paths.length; i++) {
-      const path = paths[i];
+    for (let index = 0; index < paths.length; index++) {
+      const path = paths[index];
       if (path && path.length > 0) {
         if (joined.length === 0) {
           joined = path;
@@ -2764,43 +2770,43 @@ error: ${text}`);
   function resolvePaths(paths, isWin) {
     const separator = getSeparator(isWin);
     let resolved = "";
-    let isAbsolute = false;
-    for (let i = paths.length - 1; i >= 0 && !isAbsolute; i--) {
-      const path = paths[i];
+    let absolute = false;
+    for (let index = paths.length - 1; index >= 0 && !absolute; index--) {
+      const path = paths[index];
       if (path && path.length > 0) {
         resolved = path + (resolved.length > 0 ? separator + resolved : "");
-        isAbsolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+        absolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
       }
     }
-    if (!isAbsolute) {
+    if (!absolute) {
       const cwd = getCwd();
       resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
     }
     return normalizePath(resolved, isWin);
   }
   function relativePath(from, to, isWin) {
-    from = resolvePaths([from], isWin);
-    to = resolvePaths([to], isWin);
-    if (from === to) return "";
+    const resolvedFrom = resolvePaths([from], isWin);
+    const resolvedTo = resolvePaths([to], isWin);
+    if (resolvedFrom === resolvedTo) return "";
     const separator = getSeparator(isWin);
-    const fromParts = from.split(separator).filter((p) => p.length > 0);
-    const toParts = to.split(separator).filter((p) => p.length > 0);
-    let commonLength = 0;
+    const fromParts = resolvedFrom.split(separator).filter((part) => part.length > 0);
+    const toParts = resolvedTo.split(separator).filter((part) => part.length > 0);
     const minLength = Math.min(fromParts.length, toParts.length);
-    for (let i = 0; i < minLength; i++) {
-      if (fromParts[i] === toParts[i]) {
+    let commonLength = 0;
+    for (let index = 0; index < minLength; index++) {
+      if (fromParts[index] === toParts[index]) {
         commonLength++;
       } else {
         break;
       }
     }
-    const upCount = fromParts.length - commonLength;
     const result = [];
-    for (let i = 0; i < upCount; i++) {
+    const upCount = fromParts.length - commonLength;
+    for (let index = 0; index < upCount; index++) {
       result.push("..");
     }
-    for (let i = commonLength; i < toParts.length; i++) {
-      result.push(toParts[i]);
+    for (let index = commonLength; index < toParts.length; index++) {
+      result.push(toParts[index]);
     }
     return result.join(separator) || ".";
   }
@@ -2808,15 +2814,15 @@ error: ${text}`);
     if (path.length === 0) return ".";
     const separator = getSeparator(isWin);
     const normalized = normalizePath(path, isWin);
-    const lastSepIndex = normalized.lastIndexOf(separator);
-    if (lastSepIndex === -1) return ".";
-    if (lastSepIndex === 0) return separator;
-    return normalized.slice(0, lastSepIndex);
+    const lastSeparatorIndex = normalized.lastIndexOf(separator);
+    if (lastSeparatorIndex === -1) return ".";
+    if (lastSeparatorIndex === 0) return separator;
+    return normalized.slice(0, lastSeparatorIndex);
   }
   function getBasename(path, ext, isWin) {
     if (path.length === 0) return "";
-    const lastSepIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
-    let base = lastSepIndex === -1 ? path : path.slice(lastSepIndex + 1);
+    const lastSeparatorIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+    let base = lastSeparatorIndex === -1 ? path : path.slice(lastSeparatorIndex + 1);
     if (ext && base.endsWith(ext)) {
       base = base.slice(0, base.length - ext.length);
     }
@@ -2824,8 +2830,8 @@ error: ${text}`);
   }
   function getExtname(path) {
     const lastDotIndex = path.lastIndexOf(".");
-    const lastSepIndex = findLastSeparator(path);
-    if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
+    const lastSeparatorIndex = findLastSeparator(path);
+    if (lastDotIndex === -1 || lastDotIndex < lastSeparatorIndex || lastDotIndex === path.length - 1) {
       return "";
     }
     return path.slice(lastDotIndex);
@@ -2841,10 +2847,8 @@ error: ${text}`);
       } else if (path[0] === "\\" || path[0] === "/") {
         root = "\\";
       }
-    } else {
-      if (path[0] === "/") {
-        root = "/";
-      }
+    } else if (path[0] === "/") {
+      root = "/";
     }
     const dir = getDirname(path, isWin);
     const base = getBasename(path, void 0, isWin);
@@ -2860,6 +2864,26 @@ error: ${text}`);
     if (dir === pathObject.root) return dir + base;
     return dir + separator + base;
   }
+  function createPathOps(isWin) {
+    return {
+      sep: getSeparator(isWin),
+      delimiter: isWin ? ";" : ":",
+      normalize: (path) => normalizePath(path, isWin),
+      join: (...paths) => joinPaths(paths, isWin),
+      resolve: (...paths) => resolvePaths(paths, isWin),
+      isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+      relative: (from, to) => relativePath(from, to, isWin),
+      dirname: (path) => getDirname(path, isWin),
+      basename: (path, ext) => getBasename(path, ext, isWin),
+      extname: (path) => getExtname(path),
+      parse: (path) => parsePath(path, isWin),
+      format: (pathObject) => formatPath(pathObject, isWin)
+    };
+  }
+
+  // src/server/path/index.ts
+  var posix = createPathOps(false);
+  var win32 = createPathOps(true);
   function join(...paths) {
     return joinPaths(paths, isWindows);
   }
@@ -2876,7 +2900,141 @@ error: ${text}`);
     return getExtname(path);
   }
 
-  // src/workspace-package.ts
+  // src/build/helpers.ts
+  function ensureDir(dirPath) {
+    try {
+      mkdirSync(dirPath, { recursive: true });
+    } catch {
+    }
+  }
+  function calculateBuildMetrics(startTime, outputPath) {
+    const buildTime = Date.now() - startTime;
+    const stats = statSync(outputPath);
+    return { buildTime, size: stats.size };
+  }
+  function readFileAsString(filePath) {
+    const contentBuffer = readFileSync(filePath, "utf-8");
+    return typeof contentBuffer === "string" ? contentBuffer : contentBuffer.toString("utf-8");
+  }
+  function resolveBuildPaths(config) {
+    const entryPath = resolve(config.entry);
+    const outDir = resolve(config.outDir);
+    let outFile = config.outFile;
+    if (!outFile) {
+      const baseName = basename(config.entry, extname(config.entry));
+      const ext = config.format === "cjs" ? ".cjs" : ".js";
+      outFile = baseName + ext;
+    }
+    return {
+      entryPath,
+      outDir,
+      outFile,
+      outputPath: join(outDir, outFile)
+    };
+  }
+  function createDefine(config) {
+    const define = {};
+    if (!config.env) {
+      return define;
+    }
+    Object.entries(config.env).forEach(([key, value]) => {
+      if (key.startsWith("VITE_")) {
+        define[`import.meta.env.${key}`] = JSON.stringify(value);
+      }
+    });
+    if (config.env.MODE) {
+      define["import.meta.env.MODE"] = JSON.stringify(config.env.MODE);
+    }
+    define["import.meta.env.DEV"] = JSON.stringify(config.env.MODE !== "production");
+    define["import.meta.env.PROD"] = JSON.stringify(config.env.MODE === "production");
+    return define;
+  }
+  function copyBuildFiles(config, outDir) {
+    if (!config.copy || config.copy.length === 0) {
+      return;
+    }
+    if (config.logging) {
+      console.log("\n\u{1F4E6} Copying files...");
+    }
+    for (const copyItem of config.copy) {
+      const fromPath = resolve(copyItem.from);
+      const toPath = resolve(outDir, copyItem.to);
+      const targetDir = dirname(toPath);
+      if (!existsSync(targetDir)) {
+        ensureDir(targetDir);
+      }
+      if (!existsSync(fromPath)) {
+        if (config.logging) {
+          console.warn(`  \u26A0 File not found: ${copyItem.from}`);
+        }
+        continue;
+      }
+      if (copyItem.transform) {
+        const content = readFileAsString(fromPath);
+        const transformed = copyItem.transform(content, config);
+        writeFileSync(toPath, transformed);
+      } else {
+        copyFileSync(fromPath, toPath);
+      }
+      if (config.logging) {
+        console.log(`  \u2713 ${copyItem.from} \u2192 ${copyItem.to}`);
+      }
+    }
+  }
+  function formatBytes(bytes) {
+    if (bytes === 0) {
+      return "0 B";
+    }
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+  }
+
+  // src/build/logging.ts
+  function logBuildInfo(config, outputPath) {
+    console.log("\n\u{1F528} Building...");
+    console.log(`  Entry:  ${config.entry}`);
+    console.log(`  Output: ${outputPath}`);
+    console.log(`  Format: ${config.format}`);
+    console.log(`  Target: ${config.target}`);
+  }
+  function logBuildSuccess(buildTime, size) {
+    console.log("\n\u2705 Build successful!");
+    console.log(`  Time: ${buildTime}ms`);
+    console.log(`  Size: ${formatBytes(size)}`);
+  }
+  function logMetafileSummary(result) {
+    if (!result?.metafile) {
+      return;
+    }
+    const inputs = Object.keys(result.metafile.inputs).length;
+    console.log(`  Files: ${inputs} input(s)`);
+    const outputKeys = Object.keys(result.metafile.outputs);
+    if (outputKeys.length === 0) {
+      return;
+    }
+    const mainOutput = result.metafile.outputs[outputKeys[0]];
+    if (!mainOutput?.inputs) {
+      return;
+    }
+    const sortedInputs = Object.entries(mainOutput.inputs).sort(([, a], [, b]) => {
+      const aBytes = a.bytesInOutput || 0;
+      const bBytes = b.bytesInOutput || 0;
+      return bBytes - aBytes;
+    }).slice(0, 5);
+    if (sortedInputs.length === 0) {
+      return;
+    }
+    console.log("\n  \u{1F4CA} Top 5 largest modules:");
+    sortedInputs.forEach(([file, info]) => {
+      const fileName = file.split(/[/\\]/).pop() || file;
+      const infoBytes = info.bytesInOutput || 0;
+      console.log(`     ${fileName.padEnd(30)} ${formatBytes(infoBytes)}`);
+    });
+  }
+
+  // src/shares/workspace-package/package-json.ts
   function readPackageJson(filePath) {
     try {
       const packageJsonBuffer = readFileSync(filePath, "utf-8");
@@ -2886,13 +3044,14 @@ error: ${text}`);
       return void 0;
     }
   }
-  function findWorkspacePackageRoot(startDir, packageName) {
+
+  // src/shares/workspace-package/roots.ts
+  function findPackageDirectory(startDir, resolveMatch) {
     let currentDir = resolve(startDir);
     while (true) {
-      const packageJsonPath = join(currentDir, "package.json");
-      const packageJson = existsSync(packageJsonPath) ? readPackageJson(packageJsonPath) : void 0;
-      if (packageJson?.name === packageName) {
-        return currentDir;
+      const match = resolveMatch(currentDir);
+      if (match) {
+        return match;
       }
       const parentDir = dirname(currentDir);
       if (parentDir === currentDir) {
@@ -2901,20 +3060,21 @@ error: ${text}`);
       currentDir = parentDir;
     }
   }
+  function findWorkspacePackageRoot(startDir, packageName) {
+    return findPackageDirectory(startDir, (currentDir) => {
+      const packageJsonPath = join(currentDir, "package.json");
+      const packageJson = existsSync(packageJsonPath) ? readPackageJson(packageJsonPath) : void 0;
+      return packageJson?.name === packageName ? currentDir : void 0;
+    });
+  }
   function findInstalledPackageRoot(startDir, packageName) {
-    let currentDir = resolve(startDir);
-    while (true) {
+    return findPackageDirectory(startDir, (currentDir) => {
       const candidate = join(currentDir, "node_modules", ...packageName.split("/"));
-      if (existsSync(candidate)) {
-        return candidate;
-      }
-      const parentDir = dirname(currentDir);
-      if (parentDir === currentDir) {
-        return void 0;
-      }
-      currentDir = parentDir;
-    }
+      return existsSync(candidate) ? candidate : void 0;
+    });
   }
+
+  // src/shares/workspace-package/candidates.ts
   function getWorkspacePackageImportCandidates(packageRoot, specifier, options = {}) {
     const subpath = specifier === "elit" ? "index" : specifier.slice("elit/".length);
     const builtCandidates = options.preferredBuiltFormat === "cjs" ? [
@@ -2932,14 +3092,24 @@ error: ${text}`);
     ];
     return options.preferBuilt ? [...builtCandidates, ...sourceCandidates] : [...sourceCandidates, ...builtCandidates];
   }
+
+  // src/shares/workspace-package/resolve.ts
+  function isWorkspacePackageSpecifier(specifier) {
+    return specifier === "elit" || specifier.startsWith("elit/");
+  }
   function resolveWorkspacePackageImport(specifier, startDir, options = {}) {
-    if (specifier !== "elit" && !specifier.startsWith("elit/")) {
+    if (!isWorkspacePackageSpecifier(specifier)) {
       return void 0;
     }
-    const packageRoots = [
-      findWorkspacePackageRoot(startDir, "elit"),
-      findInstalledPackageRoot(startDir, "elit")
-    ].filter((value, index, values) => typeof value === "string" && values.indexOf(value) === index);
+    const packageRoots = /* @__PURE__ */ new Set();
+    const workspacePackageRoot = findWorkspacePackageRoot(startDir, "elit");
+    const installedPackageRoot = findInstalledPackageRoot(startDir, "elit");
+    if (workspacePackageRoot) {
+      packageRoots.add(workspacePackageRoot);
+    }
+    if (installedPackageRoot) {
+      packageRoots.add(installedPackageRoot);
+    }
     for (const packageRoot of packageRoots) {
       for (const candidate of getWorkspacePackageImportCandidates(packageRoot, specifier, options)) {
         if (existsSync(candidate)) {
@@ -2950,22 +3120,7 @@ error: ${text}`);
     return void 0;
   }
 
-  // src/build.ts
-  function ensureDir(dirPath) {
-    try {
-      mkdirSync(dirPath, { recursive: true });
-    } catch (error) {
-    }
-  }
-  function calculateBuildMetrics(startTime, outputPath) {
-    const buildTime = Date.now() - startTime;
-    const stats = statSync(outputPath);
-    return { buildTime, size: stats.size };
-  }
-  function readFileAsString(filePath) {
-    const contentBuffer = readFileSync(filePath, "utf-8");
-    return typeof contentBuffer === "string" ? contentBuffer : contentBuffer.toString("utf-8");
-  }
+  // src/build/plugins.ts
   function createWorkspacePackagePlugin(entryDir, options = {}) {
     return {
       name: "workspace-package-self-reference",
@@ -2977,6 +3132,31 @@ error: ${text}`);
       }
     };
   }
+  function createBrowserOnlyPlugin() {
+    return {
+      name: "browser-only",
+      setup(build2) {
+        build2.onResolve({ filter: /^(node:.*|fs|path|http|https|url|os|child_process|net|tls|crypto|stream|util|events|buffer|zlib|readline|process|assert|constants|dns|domain|punycode|querystring|repl|string_decoder|sys|timers|tty|v8|vm)$/ }, () => {
+          return { path: "node-builtin", external: true, sideEffects: false };
+        });
+        build2.onResolve({ filter: /^(chokidar|esbuild|mime-types|open|ws|fs\/promises)$/ }, () => {
+          return { path: "server-dep", external: true, sideEffects: false };
+        });
+        build2.onLoad({ filter: /server|config|cli/ }, () => ({
+          contents: "export default {};"
+        }));
+      }
+    };
+  }
+  function createBuildPlugins(entryPath, platform) {
+    const workspacePackagePlugin = createWorkspacePackagePlugin(dirname(entryPath), {
+      preferBuilt: platform === "browser",
+      preferredBuiltFormat: platform === "browser" ? "esm" : void 0
+    });
+    return platform === "browser" ? [workspacePackagePlugin, createBrowserOnlyPlugin()] : [workspacePackagePlugin];
+  }
+
+  // src/build/runtime-builders.ts
   function getMinifyOptions(minify) {
     return minify ? {
       minifyWhitespace: true,
@@ -2987,206 +3167,123 @@ error: ${text}`);
       keepNames: false
     } : {};
   }
-  function logBuildInfo(config, outputPath) {
-    console.log("\n\u{1F528} Building...");
-    console.log(`  Entry:  ${config.entry}`);
-    console.log(`  Output: ${outputPath}`);
-    console.log(`  Format: ${config.format}`);
-    console.log(`  Target: ${config.target}`);
+  async function buildWithNode(context) {
+    const { build: esbuild } = await Promise.resolve().then(() => __toESM(require_main()));
+    const { config, paths, platform, plugins, define, startTime } = context;
+    const baseOptions = {
+      entryPoints: [paths.entryPath],
+      bundle: true,
+      outfile: paths.outputPath,
+      format: config.format,
+      target: config.target,
+      minify: config.minify,
+      sourcemap: config.sourcemap,
+      external: config.external,
+      treeShaking: config.treeshake,
+      globalName: config.globalName,
+      platform,
+      plugins,
+      define,
+      logLevel: config.logging ? "info" : "silent",
+      metafile: true,
+      mainFields: platform === "browser" ? ["browser", "module", "main"] : ["module", "main"]
+    };
+    const esbuildOptions = {
+      ...baseOptions,
+      ...getMinifyOptions(config.minify)
+    };
+    if (config.resolve?.alias) {
+      esbuildOptions.resolve = { alias: config.resolve.alias };
+    }
+    const result = await esbuild(esbuildOptions);
+    const { buildTime, size } = calculateBuildMetrics(startTime, paths.outputPath);
+    return { result, buildTime, size };
   }
-  function logBuildSuccess(buildTime, size) {
-    console.log(`
-\u2705 Build successful!`);
-    console.log(`  Time: ${buildTime}ms`);
-    console.log(`  Size: ${formatBytes(size)}`);
+  async function buildWithBun(context) {
+    const { config, paths, plugins, define, startTime } = context;
+    const result = await Bun.build({
+      entrypoints: [paths.entryPath],
+      outdir: paths.outDir,
+      target: "bun",
+      format: config.format === "cjs" ? "cjs" : "esm",
+      minify: config.minify,
+      sourcemap: config.sourcemap ? "external" : "none",
+      external: config.external,
+      naming: paths.outFile,
+      define,
+      plugins
+    });
+    if (!result.success) {
+      throw new Error("Bun build failed: " + JSON.stringify(result.logs));
+    }
+    const { buildTime, size } = calculateBuildMetrics(startTime, paths.outputPath);
+    return { result, buildTime, size };
+  }
+  async function buildWithDeno(context) {
+    const { config, paths, startTime } = context;
+    const result = await Deno.emit(paths.entryPath, {
+      bundle: "module",
+      check: false,
+      compilerOptions: {
+        target: config.target,
+        module: config.format === "cjs" ? "commonjs" : "esnext",
+        sourceMap: config.sourcemap
+      }
+    });
+    const bundledCode = result.files["deno:///bundle.js"];
+    if (bundledCode) {
+      await Deno.writeTextFile(paths.outputPath, bundledCode);
+    }
+    const { buildTime, size } = calculateBuildMetrics(startTime, paths.outputPath);
+    return { result, buildTime, size };
+  }
+  async function runRuntimeBuild(context) {
+    if (runtime === "node") {
+      return buildWithNode(context);
+    }
+    if (runtime === "bun") {
+      return buildWithBun(context);
+    }
+    return buildWithDeno(context);
+  }
+
+  // src/build/build.ts
+  function resolveBuildPlatform(config) {
+    return config.platform || (config.format === "cjs" ? "node" : "browser");
   }
-  var defaultOptions = {
-    outDir: "dist",
-    minify: true,
-    sourcemap: false,
-    target: "es2020",
-    format: "esm",
-    treeshake: true,
-    logging: true,
-    external: []
-  };
   async function build(options) {
     const config = { ...defaultOptions, ...options };
     const startTime = Date.now();
     if (!config.entry) {
       throw new Error("Entry file is required");
     }
-    const entryPath = resolve(config.entry);
-    const outDir = resolve(config.outDir);
-    let outFile = config.outFile;
-    if (!outFile) {
-      const baseName = basename(config.entry, extname(config.entry));
-      const ext = config.format === "cjs" ? ".cjs" : ".js";
-      outFile = baseName + ext;
-    }
-    const outputPath = join(outDir, outFile);
-    ensureDir(outDir);
+    const paths = resolveBuildPaths(config);
+    ensureDir(paths.outDir);
     if (config.logging) {
-      logBuildInfo(config, outputPath);
+      logBuildInfo(config, paths.outputPath);
     }
-    const browserOnlyPlugin = {
-      name: "browser-only",
-      setup(build2) {
-        build2.onResolve({ filter: /^(node:.*|fs|path|http|https|url|os|child_process|net|tls|crypto|stream|util|events|buffer|zlib|readline|process|assert|constants|dns|domain|punycode|querystring|repl|string_decoder|sys|timers|tty|v8|vm)$/ }, () => {
-          return { path: "node-builtin", external: true, sideEffects: false };
-        });
-        build2.onResolve({ filter: /^(chokidar|esbuild|mime-types|open|ws|fs\/promises)$/ }, () => {
-          return { path: "server-dep", external: true, sideEffects: false };
-        });
-        build2.onLoad({ filter: /server|config|cli/ }, () => ({
-          contents: "export default {};"
-        }));
-      }
-    };
     try {
-      const platform = config.platform || (config.format === "cjs" ? "node" : "browser");
-      const workspacePackagePlugin = createWorkspacePackagePlugin(dirname(entryPath), {
-        preferBuilt: platform === "browser",
-        preferredBuiltFormat: platform === "browser" ? "esm" : void 0
+      const platform = resolveBuildPlatform(config);
+      const plugins = createBuildPlugins(paths.entryPath, platform);
+      const define = createDefine(config);
+      const { result, buildTime, size } = await runRuntimeBuild({
+        config,
+        paths,
+        platform,
+        plugins,
+        define,
+        startTime
       });
-      const plugins = platform === "browser" ? [workspacePackagePlugin, browserOnlyPlugin] : [workspacePackagePlugin];
-      const define = {};
-      if (config.env) {
-        Object.entries(config.env).forEach(([key, value]) => {
-          if (key.startsWith("VITE_")) {
-            define[`import.meta.env.${key}`] = JSON.stringify(value);
-          }
-        });
-        if (config.env.MODE) {
-          define["import.meta.env.MODE"] = JSON.stringify(config.env.MODE);
-        }
-        define["import.meta.env.DEV"] = JSON.stringify(config.env.MODE !== "production");
-        define["import.meta.env.PROD"] = JSON.stringify(config.env.MODE === "production");
-      }
-      let result;
-      let buildTime;
-      let size;
-      if (runtime === "node") {
-        const { build: esbuild } = await Promise.resolve().then(() => __toESM(require_main()));
-        const baseOptions = {
-          entryPoints: [entryPath],
-          bundle: true,
-          outfile: outputPath,
-          format: config.format,
-          target: config.target,
-          minify: config.minify,
-          sourcemap: config.sourcemap,
-          external: config.external,
-          treeShaking: config.treeshake,
-          globalName: config.globalName,
-          platform,
-          plugins,
-          define,
-          logLevel: config.logging ? "info" : "silent",
-          metafile: true,
-          // Prioritize browser field for browser builds
-          mainFields: platform === "browser" ? ["browser", "module", "main"] : ["module", "main"]
-        };
-        const esbuildOptions = {
-          ...baseOptions,
-          ...getMinifyOptions(config.minify)
-        };
-        if (config.resolve?.alias) {
-          esbuildOptions.resolve = { alias: config.resolve.alias };
-        }
-        result = await esbuild(esbuildOptions);
-        ({ buildTime, size } = calculateBuildMetrics(startTime, outputPath));
-      } else if (runtime === "bun") {
-        result = await Bun.build({
-          entrypoints: [entryPath],
-          outdir: outDir,
-          target: "bun",
-          format: config.format === "cjs" ? "cjs" : "esm",
-          minify: config.minify,
-          sourcemap: config.sourcemap ? "external" : "none",
-          external: config.external,
-          naming: outFile,
-          define,
-          plugins
-        });
-        if (!result.success) {
-          throw new Error("Bun build failed: " + JSON.stringify(result.logs));
-        }
-        ({ buildTime, size } = calculateBuildMetrics(startTime, outputPath));
-      } else {
-        result = await Deno.emit(entryPath, {
-          bundle: "module",
-          check: false,
-          compilerOptions: {
-            target: config.target,
-            module: config.format === "cjs" ? "commonjs" : "esnext",
-            sourceMap: config.sourcemap
-          }
-        });
-        const bundledCode = result.files["deno:///bundle.js"];
-        if (bundledCode) {
-          await Deno.writeTextFile(outputPath, bundledCode);
-        }
-        ({ buildTime, size } = calculateBuildMetrics(startTime, outputPath));
-      }
       if (config.logging) {
         logBuildSuccess(buildTime, size);
-        if (runtime === "node" && result.metafile) {
-          const inputs = Object.keys(result.metafile.inputs).length;
-          console.log(`  Files: ${inputs} input(s)`);
-          const outputKeys = Object.keys(result.metafile.outputs);
-          if (outputKeys.length > 0) {
-            const mainOutput = result.metafile.outputs[outputKeys[0]];
-            if (mainOutput && mainOutput.inputs) {
-              const sortedInputs = Object.entries(mainOutput.inputs).sort(([, a], [, b]) => {
-                const aBytes = a.bytesInOutput || 0;
-                const bBytes = b.bytesInOutput || 0;
-                return bBytes - aBytes;
-              }).slice(0, 5);
-              if (sortedInputs.length > 0) {
-                console.log("\n  \u{1F4CA} Top 5 largest modules:");
-                sortedInputs.forEach(([file, info]) => {
-                  const fileName = file.split(/[/\\]/).pop() || file;
-                  const infoBytes = info.bytesInOutput || 0;
-                  console.log(`     ${fileName.padEnd(30)} ${formatBytes(infoBytes)}`);
-                });
-              }
-            }
-          }
-        }
+        logMetafileSummary(result);
       }
       const buildResult = {
-        outputPath,
+        outputPath: paths.outputPath,
         buildTime,
         size
       };
-      if (config.copy && config.copy.length > 0) {
-        if (config.logging) {
-          console.log("\n\u{1F4E6} Copying files...");
-        }
-        for (const copyItem of config.copy) {
-          const fromPath = resolve(copyItem.from);
-          const toPath = resolve(outDir, copyItem.to);
-          const targetDir = dirname(toPath);
-          if (!existsSync(targetDir)) {
-            ensureDir(targetDir);
-          }
-          if (existsSync(fromPath)) {
-            if (copyItem.transform) {
-              const content = readFileAsString(fromPath);
-              const transformed = copyItem.transform(content, config);
-              writeFileSync(toPath, transformed);
-            } else {
-              copyFileSync(fromPath, toPath);
-            }
-            if (config.logging) {
-              console.log(`  \u2713 ${copyItem.from} \u2192 ${copyItem.to}`);
-            }
-          } else if (config.logging) {
-            console.warn(`  \u26A0 File not found: ${copyItem.from}`);
-          }
-        }
-      }
+      copyBuildFiles(config, paths.outDir);
       if (config.onBuildEnd) {
         await config.onBuildEnd(buildResult);
       }
@@ -3202,11 +3299,4 @@ error: ${text}`);
       throw error;
     }
   }
-  function formatBytes(bytes) {
-    if (bytes === 0) return "0 B";
-    const k = 1024;
-    const sizes = ["B", "KB", "MB", "GB"];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
-  }
 })();