elit 3.6.6 → 3.6.7

package/dist/build.cjs

@@ -27,14 +27,26 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/build.ts
+// src/build/index.ts
 var build_exports = {};
 __export(build_exports, {
   build: () => build
 });
 module.exports = __toCommonJS(build_exports);
 
-// 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";
@@ -44,7 +56,15 @@ var isNode = runtime === "node";
 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;
 }
@@ -63,12 +83,37 @@ function dataToUint8Array(data) {
   }
   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) {
@@ -104,6 +149,8 @@ function statSync(path) {
   }
   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) {
@@ -112,6 +159,8 @@ function mkdirSync(path, options) {
     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);
@@ -119,67 +168,34 @@ function copyFileSync(src, dest, flags) {
     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] === "/";
 }
@@ -200,28 +216,18 @@ function isAbsoluteWin(path) {
   }
   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 === "..") {
@@ -236,21 +242,21 @@ function normalizePath(path, isWin) {
       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;
@@ -265,43 +271,43 @@ function joinPaths(paths, isWin) {
 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) || ".";
 }
@@ -309,15 +315,15 @@ function getDirname(path, isWin) {
   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);
   }
@@ -325,8 +331,8 @@ function getBasename(path, ext, isWin) {
 }
 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);
@@ -342,10 +348,8 @@ function parsePath(path, isWin) {
     } 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);
@@ -361,6 +365,26 @@ function formatPath(pathObject, isWin) {
   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);
 }
@@ -377,7 +401,141 @@ function extname(path) {
   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");
@@ -387,13 +545,14 @@ function readPackageJson(filePath) {
     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) {
@@ -402,20 +561,21 @@ function findWorkspacePackageRoot(startDir, packageName) {
     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" ? [
@@ -433,14 +593,24 @@ function getWorkspacePackageImportCandidates(packageRoot, specifier, options = {
   ];
   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)) {
@@ -451,22 +621,7 @@ function resolveWorkspacePackageImport(specifier, startDir, options = {}) {
   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",
@@ -478,6 +633,31 @@ function createWorkspacePackagePlugin(entryDir, options = {}) {
     }
   };
 }
+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,
@@ -488,206 +668,123 @@ function getMinifyOptions(minify) {
     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 import("esbuild");
+  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 };
+}
+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 };
 }
-function logBuildSuccess(buildTime, size) {
-  console.log(`
-\u2705 Build successful!`);
-  console.log(`  Time: ${buildTime}ms`);
-  console.log(`  Size: ${formatBytes(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 import("esbuild");
-      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);
     }
@@ -703,13 +800,6 @@ async function build(options) {
     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];
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build