@teamvelix/cli 5.3.3 → 5.3.5

package/dist/src-BXA4CRFC.js

@@ -0,0 +1,822 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+
+// ../velix-pack/src/index.ts
+import path9 from "path";
+import fs6 from "fs";
+
+// ../velix-pack/src/resolver/index.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// ../velix-pack/src/resolver/aliases.ts
+import fs from "fs";
+import path from "path";
+function loadPathAliases(projectRoot) {
+  const tsconfigPath = path.join(projectRoot, "tsconfig.json");
+  if (!fs.existsSync(tsconfigPath)) return [];
+  try {
+    const raw = fs.readFileSync(tsconfigPath, "utf-8");
+    const jsonStr = raw.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, "");
+    const tsconfig = JSON.parse(jsonStr);
+    const compilerOptions = tsconfig?.compilerOptions || {};
+    const paths = compilerOptions.paths || {};
+    const baseUrl = compilerOptions.baseUrl ? path.resolve(projectRoot, compilerOptions.baseUrl) : projectRoot;
+    const aliases = [];
+    for (const [key, value] of Object.entries(paths)) {
+      if (Array.isArray(value) && value.length > 0) {
+        const prefix = key.replace(/\/\*$/, "");
+        const targetRelative = value[0].replace(/\/\*$/, "");
+        aliases.push({
+          prefix,
+          target: path.resolve(baseUrl, targetRelative)
+        });
+      }
+    }
+    return aliases;
+  } catch {
+    return [];
+  }
+}
+
+// ../velix-pack/src/resolver/index.ts
+var Resolver = class {
+  projectRoot;
+  aliases;
+  extensions;
+  constructor(options) {
+    this.projectRoot = options.projectRoot;
+    this.aliases = loadPathAliases(this.projectRoot);
+    this.extensions = options.extensions || [".tsx", ".ts", ".jsx", ".js", ".json", ".css"];
+  }
+  resolve(importPath, importerPath) {
+    if (!importPath.startsWith(".") && !importPath.startsWith("/") && !this.isAliasMatch(importPath)) {
+      return null;
+    }
+    let targetPath = importPath;
+    for (const alias of this.aliases) {
+      if (importPath === alias.prefix || importPath.startsWith(alias.prefix + "/")) {
+        targetPath = importPath.replace(alias.prefix, alias.target);
+        break;
+      }
+    }
+    let absolutePath = targetPath;
+    if (!path2.isAbsolute(targetPath)) {
+      absolutePath = path2.resolve(path2.dirname(importerPath), targetPath);
+    }
+    if (fs2.existsSync(absolutePath) && fs2.statSync(absolutePath).isFile()) {
+      return absolutePath;
+    }
+    if (absolutePath.endsWith(".js")) {
+      const tsPath = absolutePath.slice(0, -3) + ".ts";
+      const tsxPath = absolutePath.slice(0, -3) + ".tsx";
+      if (fs2.existsSync(tsPath) && fs2.statSync(tsPath).isFile()) return tsPath;
+      if (fs2.existsSync(tsxPath) && fs2.statSync(tsxPath).isFile()) return tsxPath;
+    }
+    for (const ext of this.extensions) {
+      const pathWithExt = absolutePath + ext;
+      if (fs2.existsSync(pathWithExt) && fs2.statSync(pathWithExt).isFile()) {
+        return pathWithExt;
+      }
+    }
+    for (const ext of this.extensions) {
+      const indexPath = path2.join(absolutePath, `index${ext}`);
+      if (fs2.existsSync(indexPath) && fs2.statSync(indexPath).isFile()) {
+        return indexPath;
+      }
+    }
+    return null;
+  }
+  isAliasMatch(importPath) {
+    return this.aliases.some((alias) => importPath === alias.prefix || importPath.startsWith(alias.prefix + "/"));
+  }
+};
+
+// ../velix-pack/src/graph/module-graph.ts
+import path3 from "path";
+
+// ../velix-pack/src/graph/module.ts
+var Module = class {
+  id;
+  path;
+  type;
+  dependencies = /* @__PURE__ */ new Set();
+  dependents = /* @__PURE__ */ new Set();
+  hash;
+  lastModified;
+  isEntry;
+  constructor(id, path10, type = "shared") {
+    this.id = id;
+    this.path = path10;
+    this.type = type;
+  }
+  addDependency(depId) {
+    this.dependencies.add(depId);
+  }
+  removeDependency(depId) {
+    this.dependencies.delete(depId);
+  }
+  addDependent(dependentId) {
+    this.dependents.add(dependentId);
+  }
+  removeDependent(dependentId) {
+    this.dependents.delete(dependentId);
+  }
+};
+
+// ../velix-pack/src/graph/boundary.ts
+function isServerModule(filePath, content) {
+  const normalized = filePath.replace(/\\/g, "/");
+  if (normalized.includes("/server/") || normalized.startsWith("server/")) return true;
+  if (content) {
+    const firstLines = content.split("\n").slice(0, 5).map((l) => l.trim());
+    if (firstLines.some((l) => l === "'use server'" || l === '"use server"')) {
+      return true;
+    }
+  }
+  return false;
+}
+function isClientModule(filePath, content) {
+  if (content) {
+    const firstLines = content.split("\n").slice(0, 5).map((l) => l.trim());
+    if (firstLines.some((l) => l === "'use client'" || l === '"use client"' || l === "'use island'" || l === '"use island"')) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkBoundaryViolations(modules) {
+  const violations = [];
+  for (const [id, mod] of modules.entries()) {
+    if (mod.type === "client") {
+      for (const depId of mod.dependencies) {
+        const dep = modules.get(depId);
+        if (dep && dep.type === "server") {
+          violations.push({
+            clientModule: id,
+            serverModule: depId,
+            importStatement: `Import of server module "${depId}" from client module "${id}"`
+          });
+        }
+      }
+    }
+  }
+  return violations;
+}
+
+// ../velix-pack/src/graph/module-graph.ts
+var ModuleGraph = class {
+  modules = /* @__PURE__ */ new Map();
+  projectRoot;
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  getModule(id) {
+    return this.modules.get(id);
+  }
+  getModuleByPath(filePath) {
+    const id = this.toRelativeId(filePath);
+    return this.modules.get(id);
+  }
+  addModule(filePath, type = "shared") {
+    const id = this.toRelativeId(filePath);
+    let mod = this.modules.get(id);
+    if (!mod) {
+      mod = new Module(id, filePath, type);
+      this.modules.set(id, mod);
+    } else {
+      mod.type = type;
+    }
+    return mod;
+  }
+  removeModule(filePath) {
+    const id = this.toRelativeId(filePath);
+    const mod = this.modules.get(id);
+    const affectedDependents = /* @__PURE__ */ new Set();
+    if (mod) {
+      for (const depId of mod.dependents) {
+        affectedDependents.add(depId);
+        const depMod = this.modules.get(depId);
+        if (depMod) {
+          depMod.removeDependency(id);
+        }
+      }
+      for (const depId of mod.dependencies) {
+        const depMod = this.modules.get(depId);
+        if (depMod) {
+          depMod.removeDependent(id);
+        }
+      }
+      this.modules.delete(id);
+    }
+    return affectedDependents;
+  }
+  updateDependencies(filePath, dependencyPaths) {
+    const id = this.toRelativeId(filePath);
+    const mod = this.getModule(id);
+    if (!mod) return;
+    const newDepIds = new Set(dependencyPaths.map((p) => this.toRelativeId(p)));
+    for (const oldDepId of Array.from(mod.dependencies)) {
+      if (!newDepIds.has(oldDepId)) {
+        mod.removeDependency(oldDepId);
+        const depMod = this.modules.get(oldDepId);
+        if (depMod) {
+          depMod.removeDependent(id);
+        }
+      }
+    }
+    for (const newDepId of newDepIds) {
+      if (!mod.dependencies.has(newDepId)) {
+        mod.addDependency(newDepId);
+        const depMod = this.modules.get(newDepId);
+        if (depMod) {
+          depMod.addDependent(id);
+        }
+      }
+    }
+  }
+  /**
+   * Finds all affected modules recursively when a file changes
+   */
+  getAffectedModules(filePath) {
+    const startId = this.toRelativeId(filePath);
+    const affected = /* @__PURE__ */ new Set();
+    const queue = [startId];
+    while (queue.length > 0) {
+      const currentId = queue.shift();
+      if (!affected.has(currentId)) {
+        affected.add(currentId);
+        const mod = this.modules.get(currentId);
+        if (mod) {
+          for (const dependentId of mod.dependents) {
+            queue.push(dependentId);
+          }
+        }
+      }
+    }
+    return affected;
+  }
+  getAllModules() {
+    return this.modules;
+  }
+  checkBoundaries() {
+    return checkBoundaryViolations(this.modules);
+  }
+  toRelativeId(filePath) {
+    const relative = path3.relative(this.projectRoot, filePath);
+    return relative.replace(/\\/g, "/");
+  }
+  clear() {
+    this.modules.clear();
+  }
+};
+
+// ../velix-pack/src/transform/index.ts
+import fs3 from "fs";
+import path5 from "path";
+import crypto from "crypto";
+
+// ../velix-pack/src/transform/typescript.ts
+import esbuild from "esbuild";
+import path4 from "path";
+async function transformTypeScript(filePath, content, resolver) {
+  const ext = path4.extname(filePath);
+  const loader = ext === ".tsx" ? "tsx" : ext === ".jsx" ? "jsx" : "ts";
+  const result = await esbuild.transform(content, {
+    loader,
+    target: "es2022",
+    format: "esm",
+    jsx: "automatic",
+    sourcemap: "inline",
+    sourcefile: filePath
+  });
+  const imports = extractImports(content, filePath, resolver);
+  let type = "shared";
+  if (isServerModule(filePath, content)) {
+    type = "server";
+  } else if (isClientModule(filePath, content)) {
+    type = "client";
+  }
+  return {
+    code: result.code,
+    map: result.map,
+    imports,
+    type
+  };
+}
+function extractImports(content, filePath, resolver) {
+  const imports = [];
+  const importRegex = /(?:import|export)\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]|import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    const importPath = match[1] || match[2];
+    if (importPath) {
+      const resolved = resolver.resolve(importPath, filePath);
+      if (resolved) {
+        imports.push(resolved);
+      }
+    }
+  }
+  return Array.from(new Set(imports));
+}
+
+// ../velix-pack/src/transform/css.ts
+async function transformCSS(filePath, content) {
+  return {
+    code: content,
+    imports: [],
+    type: "shared"
+  };
+}
+
+// ../velix-pack/src/transform/json.ts
+async function transformJSON(filePath, content) {
+  let code = "";
+  try {
+    const json = JSON.parse(content);
+    code = `export default ${JSON.stringify(json)};`;
+  } catch {
+    code = `export default {};`;
+  }
+  return {
+    code,
+    imports: [],
+    type: "shared"
+  };
+}
+
+// ../velix-pack/src/transform/index.ts
+var TransformPipeline = class {
+  resolver;
+  constructor(resolver) {
+    this.resolver = resolver;
+  }
+  async transform(filePath) {
+    const content = fs3.readFileSync(filePath, "utf-8");
+    const hash = crypto.createHash("md5").update(content).digest("hex");
+    const ext = path5.extname(filePath);
+    if (ext === ".ts" || ext === ".tsx" || ext === ".js" || ext === ".jsx") {
+      const result = await transformTypeScript(filePath, content, this.resolver);
+      return { ...result, hash };
+    } else if (ext === ".css") {
+      const result = await transformCSS(filePath, content);
+      return { ...result, hash };
+    } else if (ext === ".json") {
+      const result = await transformJSON(filePath, content);
+      return { ...result, hash };
+    }
+    return {
+      code: content,
+      imports: [],
+      type: "shared",
+      hash
+    };
+  }
+};
+
+// ../velix-pack/src/cache/fs-cache.ts
+import fs4 from "fs";
+import path6 from "path";
+var FSCache = class {
+  cacheDir;
+  memoryCache = /* @__PURE__ */ new Map();
+  constructor(projectRoot) {
+    this.cacheDir = path6.join(projectRoot, ".velix", "cache", "pack");
+    this.ensureCacheDir();
+  }
+  ensureCacheDir() {
+    if (!fs4.existsSync(this.cacheDir)) {
+      fs4.mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+  get(id, currentHash) {
+    const mem = this.memoryCache.get(id);
+    if (mem && mem.hash === currentHash) {
+      return mem;
+    }
+    const safeFilename = encodeURIComponent(id) + ".json";
+    const filePath = path6.join(this.cacheDir, safeFilename);
+    if (fs4.existsSync(filePath)) {
+      try {
+        const raw = fs4.readFileSync(filePath, "utf-8");
+        const entry = JSON.parse(raw);
+        if (entry.hash === currentHash) {
+          this.memoryCache.set(id, entry);
+          return entry;
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  set(id, entry) {
+    this.memoryCache.set(id, entry);
+    const safeFilename = encodeURIComponent(id) + ".json";
+    const filePath = path6.join(this.cacheDir, safeFilename);
+    try {
+      this.ensureCacheDir();
+      fs4.writeFileSync(filePath, JSON.stringify(entry), "utf-8");
+    } catch {
+    }
+  }
+  invalidate(id) {
+    this.memoryCache.delete(id);
+    const safeFilename = encodeURIComponent(id) + ".json";
+    const filePath = path6.join(this.cacheDir, safeFilename);
+    if (fs4.existsSync(filePath)) {
+      try {
+        fs4.unlinkSync(filePath);
+      } catch {
+      }
+    }
+  }
+  clear() {
+    this.memoryCache.clear();
+    if (fs4.existsSync(this.cacheDir)) {
+      try {
+        fs4.rmSync(this.cacheDir, { recursive: true, force: true });
+        this.ensureCacheDir();
+      } catch {
+      }
+    }
+  }
+};
+
+// ../velix-pack/src/cache/index.ts
+var CacheManager = class {
+  fsCache;
+  hits = 0;
+  misses = 0;
+  constructor(projectRoot) {
+    this.fsCache = new FSCache(projectRoot);
+  }
+  get(id, currentHash) {
+    const entry = this.fsCache.get(id, currentHash);
+    if (entry) {
+      this.hits++;
+      return entry;
+    }
+    this.misses++;
+    return null;
+  }
+  set(id, entry) {
+    this.fsCache.set(id, entry);
+  }
+  invalidate(id) {
+    this.fsCache.invalidate(id);
+  }
+  clear() {
+    this.fsCache.clear();
+    this.hits = 0;
+    this.misses = 0;
+  }
+  getStats() {
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      hitRatio: this.hits + this.misses > 0 ? this.hits / (this.hits + this.misses) * 100 : 0
+    };
+  }
+};
+
+// ../velix-pack/src/bundler/index.ts
+import esbuild2 from "esbuild";
+import path7 from "path";
+import fs5 from "fs";
+
+// ../velix-pack/src/bundler/chunk.ts
+var Chunk = class {
+  name;
+  isInitial;
+  type;
+  modules = /* @__PURE__ */ new Set();
+  size = 0;
+  constructor(options) {
+    this.name = options.name;
+    this.isInitial = options.isInitial ?? false;
+    this.type = options.type;
+  }
+  addModule(moduleId, moduleSize = 0) {
+    this.modules.add(moduleId);
+    this.size += moduleSize;
+  }
+};
+
+// ../velix-pack/src/bundler/code-splitter.ts
+var CodeSplitter = class {
+  moduleGraph;
+  constructor(moduleGraph) {
+    this.moduleGraph = moduleGraph;
+  }
+  splitIntoChunks() {
+    const chunks = [];
+    const allModules = Array.from(this.moduleGraph.getAllModules().values());
+    const serverChunk = new Chunk({ name: "server-bundle", isInitial: true, type: "server" });
+    const clientInitialChunk = new Chunk({ name: "client-main", isInitial: true, type: "client" });
+    const routeChunksMap = /* @__PURE__ */ new Map();
+    for (const mod of allModules) {
+      const estimatedSize = mod.path.length * 10;
+      if (mod.type === "server") {
+        serverChunk.addModule(mod.id, estimatedSize);
+      } else {
+        const isRoute = (mod.id.includes("app/") || mod.id.includes("app\\")) && (mod.id.endsWith("page.tsx") || mod.id.endsWith("page.jsx"));
+        if (isRoute) {
+          const normalizedId = mod.id.replace(/\\/g, "/");
+          const routeName = normalizedId.replace(/^app\//, "").replace(/(?:^|\/)page\.[tj]sx?$/, "").replace(/[\/\\]/g, "_") || "home";
+          let chunk = routeChunksMap.get(routeName);
+          if (!chunk) {
+            chunk = new Chunk({ name: `route-${routeName}`, isInitial: false, type: "client" });
+            routeChunksMap.set(routeName, chunk);
+          }
+          chunk.addModule(mod.id, estimatedSize);
+        } else {
+          clientInitialChunk.addModule(mod.id, estimatedSize);
+        }
+      }
+    }
+    chunks.push(serverChunk);
+    chunks.push(clientInitialChunk);
+    for (const routeChunk of routeChunksMap.values()) {
+      chunks.push(routeChunk);
+    }
+    return chunks;
+  }
+};
+
+// ../velix-pack/src/bundler/index.ts
+var Bundler = class {
+  projectRoot;
+  outDir;
+  minify;
+  sourcemap;
+  constructor(options) {
+    this.projectRoot = options.projectRoot;
+    this.outDir = options.outDir;
+    this.minify = options.minify ?? false;
+    this.sourcemap = options.sourcemap ?? true;
+  }
+  async bundle(moduleGraph) {
+    const splitter = new CodeSplitter(moduleGraph);
+    const chunks = splitter.splitIntoChunks();
+    const entryFiles = Array.from(moduleGraph.getAllModules().values()).map((m) => m.path).filter((p) => fs5.existsSync(p));
+    if (entryFiles.length === 0) return chunks;
+    const serverOutDir = path7.join(this.outDir, "server");
+    const clientOutDir = path7.join(this.outDir, "client");
+    if (!fs5.existsSync(serverOutDir)) fs5.mkdirSync(serverOutDir, { recursive: true });
+    if (!fs5.existsSync(clientOutDir)) fs5.mkdirSync(clientOutDir, { recursive: true });
+    await esbuild2.build({
+      entryPoints: entryFiles,
+      outdir: serverOutDir,
+      bundle: false,
+      format: "esm",
+      platform: "node",
+      target: "es2022",
+      minify: this.minify,
+      sourcemap: this.sourcemap,
+      jsx: "automatic",
+      logLevel: "silent"
+    });
+    return chunks;
+  }
+};
+
+// ../velix-pack/src/watcher/index.ts
+import chokidar from "chokidar";
+import path8 from "path";
+var FileWatcher = class {
+  watcher = null;
+  watchPaths;
+  constructor(watchPaths) {
+    this.watchPaths = watchPaths;
+  }
+  start(events) {
+    this.watcher = chokidar.watch(this.watchPaths, {
+      ignored: /(^|[\/\\])\..|node_modules|\.velix|dist/,
+      persistent: true,
+      ignoreInitial: true
+    });
+    this.watcher.on("change", (filePath) => events.onChange(path8.resolve(filePath)));
+    this.watcher.on("add", (filePath) => events.onAdd(path8.resolve(filePath)));
+    this.watcher.on("unlink", (filePath) => events.onUnlink(path8.resolve(filePath)));
+  }
+  close() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+};
+
+// ../velix-pack/src/hmr/index.ts
+var HMRBridge = class {
+  broadcaster = null;
+  setBroadcaster(broadcaster) {
+    this.broadcaster = broadcaster;
+  }
+  notifyFileChanged(filePath, affectedModules) {
+    if (this.broadcaster) {
+      this.broadcaster({
+        type: "file-changed",
+        file: filePath,
+        affectedModules,
+        timestamp: Date.now()
+      });
+    }
+  }
+  notifyBoundaryError(error) {
+    if (this.broadcaster) {
+      this.broadcaster({
+        type: "boundary-error",
+        error,
+        timestamp: Date.now()
+      });
+    }
+  }
+};
+
+// ../velix-pack/src/analyzer/index.ts
+import pc from "picocolors";
+function formatBuildStats(stats) {
+  const lines = [];
+  lines.push(pc.bold(pc.green("VELIX PACK ANALYSIS")));
+  lines.push("");
+  lines.push(pc.bold("Build Stats"));
+  lines.push(pc.dim("\u2500\u2500\u2500\u2500\u2500"));
+  lines.push(`Time:       ${pc.cyan((stats.duration / 1e3).toFixed(2) + "s")}`);
+  lines.push(`Modules:    ${pc.yellow(stats.modulesCount.toString())}`);
+  lines.push(`Chunks:     ${pc.cyan(stats.chunksCount.toString())}`);
+  lines.push(`Cache hit:  ${pc.green(stats.cacheHits + " / " + (stats.cacheHits + stats.cacheMisses))}`);
+  lines.push("");
+  lines.push(pc.bold("Client"));
+  lines.push(pc.dim("\u2500\u2500\u2500\u2500\u2500\u2500"));
+  lines.push(`Modules:    ${stats.clientModulesCount}`);
+  lines.push(`Initial JS: ${pc.cyan((stats.initialJsSize / 1024).toFixed(1) + " KB")}`);
+  lines.push(`Async JS:   ${pc.cyan((stats.asyncJsSize / 1024).toFixed(1) + " KB")}`);
+  lines.push("");
+  lines.push(pc.bold("Server"));
+  lines.push(pc.dim("\u2500\u2500\u2500\u2500\u2500\u2500"));
+  lines.push(`Modules:    ${stats.serverModulesCount}`);
+  return lines.join("\n");
+}
+
+// ../velix-pack/src/index.ts
+var VelixPack = class {
+  options;
+  resolver;
+  moduleGraph;
+  pipeline;
+  cache;
+  bundler;
+  watcher = null;
+  hmr = new HMRBridge();
+  stats = {
+    duration: 0,
+    modulesCount: 0,
+    chunksCount: 0,
+    cacheHits: 0,
+    cacheMisses: 0,
+    serverModulesCount: 0,
+    clientModulesCount: 0,
+    sharedModulesCount: 0,
+    initialJsSize: 0,
+    asyncJsSize: 0
+  };
+  constructor(options = {}) {
+    const projectRoot = options.projectRoot || process.cwd();
+    this.options = {
+      projectRoot,
+      appDir: options.appDir || path9.join(projectRoot, "app"),
+      outDir: options.outDir || path9.join(projectRoot, ".velix"),
+      mode: options.mode || "development",
+      minify: options.minify ?? false,
+      sourcemap: options.sourcemap ?? true
+    };
+    this.resolver = new Resolver({ projectRoot });
+    this.moduleGraph = new ModuleGraph(projectRoot);
+    this.pipeline = new TransformPipeline(this.resolver);
+    this.cache = new CacheManager(projectRoot);
+    this.bundler = new Bundler({
+      projectRoot,
+      outDir: this.options.outDir,
+      minify: this.options.minify,
+      sourcemap: this.options.sourcemap
+    });
+  }
+  async build() {
+    const startTime = Date.now();
+    const sourceFiles = this.findSourceFiles(this.options.appDir);
+    const serverFiles = fs6.existsSync(path9.join(this.options.projectRoot, "server")) ? this.findSourceFiles(path9.join(this.options.projectRoot, "server")) : [];
+    const allFiles = Array.from(/* @__PURE__ */ new Set([...sourceFiles, ...serverFiles]));
+    for (const filePath of allFiles) {
+      await this.processFile(filePath);
+    }
+    const violations = this.moduleGraph.checkBoundaries();
+    if (violations.length > 0) {
+      for (const v of violations) {
+        console.error(`ERROR [VELIX_PACK]
+Server module imported from client module.
+client: ${v.clientModule}
+server: ${v.serverModule}
+`);
+      }
+    }
+    const chunks = await this.bundler.bundle(this.moduleGraph);
+    const cacheStats = this.cache.getStats();
+    const modules = Array.from(this.moduleGraph.getAllModules().values());
+    this.stats = {
+      duration: Date.now() - startTime,
+      modulesCount: modules.length,
+      chunksCount: chunks.length,
+      cacheHits: cacheStats.hits,
+      cacheMisses: cacheStats.misses,
+      serverModulesCount: modules.filter((m) => m.type === "server").length,
+      clientModulesCount: modules.filter((m) => m.type === "client").length,
+      sharedModulesCount: modules.filter((m) => m.type === "shared").length,
+      initialJsSize: chunks.filter((c) => c.isInitial).reduce((acc, c) => acc + c.size, 0),
+      asyncJsSize: chunks.filter((c) => !c.isInitial).reduce((acc, c) => acc + c.size, 0)
+    };
+    return this.stats;
+  }
+  watch(onRebuild) {
+    const serverDir = path9.join(this.options.projectRoot, "server");
+    const watchPaths = [this.options.appDir];
+    if (fs6.existsSync(serverDir)) watchPaths.push(serverDir);
+    this.watcher = new FileWatcher(watchPaths);
+    this.watcher.start({
+      onChange: async (filePath) => {
+        const affected = await this.rebuildIncremental(filePath);
+        this.hmr.notifyFileChanged(filePath, Array.from(affected));
+        if (onRebuild) onRebuild(Array.from(affected));
+      },
+      onAdd: async (filePath) => {
+        await this.processFile(filePath);
+        const affected = this.moduleGraph.getAffectedModules(filePath);
+        if (onRebuild) onRebuild(Array.from(affected));
+      },
+      onUnlink: (filePath) => {
+        const affected = this.moduleGraph.removeModule(filePath);
+        this.cache.invalidate(this.moduleGraph.toRelativeId(filePath));
+        if (onRebuild) onRebuild(Array.from(affected));
+      }
+    });
+    return this.watcher;
+  }
+  async rebuildIncremental(filePath) {
+    await this.processFile(filePath);
+    return this.moduleGraph.getAffectedModules(filePath);
+  }
+  async processFile(filePath) {
+    const relativeId = this.moduleGraph.toRelativeId(filePath);
+    const transformResult = await this.pipeline.transform(filePath);
+    let cached = this.cache.get(relativeId, transformResult.hash);
+    if (!cached) {
+      cached = {
+        hash: transformResult.hash,
+        code: transformResult.code,
+        imports: transformResult.imports,
+        type: transformResult.type,
+        timestamp: Date.now()
+      };
+      this.cache.set(relativeId, cached);
+    }
+    const mod = this.moduleGraph.addModule(filePath, transformResult.type);
+    mod.hash = transformResult.hash;
+    this.moduleGraph.updateDependencies(filePath, transformResult.imports);
+    for (const importPath of transformResult.imports) {
+      if (!this.moduleGraph.getModuleByPath(importPath)) {
+        if (fs6.existsSync(importPath)) {
+          await this.processFile(importPath);
+        }
+      }
+    }
+  }
+  findSourceFiles(dir) {
+    const results = [];
+    if (!fs6.existsSync(dir)) return results;
+    const entries = fs6.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path9.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "node_modules" && entry.name !== ".velix" && entry.name !== "dist") {
+          results.push(...this.findSourceFiles(fullPath));
+        }
+      } else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
+        results.push(fullPath);
+      }
+    }
+    return results;
+  }
+  getHMR() {
+    return this.hmr;
+  }
+  getStats() {
+    return this.stats;
+  }
+};
+export {
+  CacheManager,
+  ModuleGraph,
+  Resolver,
+  VelixPack,
+  formatBuildStats
+};
+//# sourceMappingURL=src-BXA4CRFC.js.map