@ionify/ionify 0.1.0 → 0.1.2

package/dist/cli/index.js

@@ -1,4 +1,17 @@
 #!/usr/bin/env node
+import {
+  computeGraphVersion,
+  ensureNativeGraph,
+  getCacheKey,
+  native,
+  readCache,
+  tryBundleNodeModule,
+  tryNativeTransform,
+  writeCache
+} from "../chunk-GOZUBOYH.js";
+import {
+  getCasArtifactPath
+} from "../chunk-X5UIMJDA.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -8,74 +21,2424 @@ import chalk from "chalk";
 function logInfo(message) {
   console.log(chalk.cyan(`[Ionify] ${message}`));
 }
+function logWarn(message) {
+  console.warn(chalk.yellow(`[Ionify] ${message}`));
+}
 function logError(message, err) {
   console.error(chalk.red(`[Ionify] ${message}`));
   if (err) console.error(err);
 }
 
-// src/cli/commands/analyze.ts
-import fs2 from "fs";
-import path2 from "path";
+// src/cli/commands/dev.ts
+import http from "http";
+import url from "url";
+import fs7 from "fs";
+import path9 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { createRequire as createRequire2 } from "module";
+
+// src/core/graph.ts
+import fs from "fs";
+import path from "path";
+var IONIFY_DIR = path.join(process.cwd(), ".ionify");
+var GRAPH_FILE = path.join(IONIFY_DIR, "graph.json");
+var GRAPH_DB_FILE = path.join(IONIFY_DIR, "graph.db");
+function ensureIonifyDir() {
+  if (!fs.existsSync(IONIFY_DIR)) fs.mkdirSync(IONIFY_DIR, { recursive: true });
+}
+var Graph = class {
+  nodes = /* @__PURE__ */ new Map();
+  dirty = false;
+  saveTimer = null;
+  native = native ?? null;
+  nativeFlushTimer = null;
+  queueSave() {
+    if (this.native) return;
+    this.dirty = true;
+    if (this.saveTimer) return;
+    this.saveTimer = setTimeout(() => this.save(), 300);
+  }
+  constructor(versionInputs) {
+    ensureIonifyDir();
+    if (this.native) {
+      const version = versionInputs ? computeGraphVersion(versionInputs) : void 0;
+      ensureNativeGraph(GRAPH_DB_FILE, version);
+    }
+    this.load();
+  }
+  load() {
+    if (this.native) {
+      try {
+        const snapshot = this.native.graphLoad();
+        for (const node of snapshot) {
+          const stat = fs.existsSync(node.id) ? fs.statSync(node.id) : null;
+          this.nodes.set(node.id, {
+            id: node.id,
+            hash: node.hash,
+            deps: node.deps,
+            dynamicDeps: node.dynamicDeps,
+            kind: node.kind,
+            configHash: node.config_hash ?? node.configHash ?? null,
+            mtimeMs: stat ? stat.mtimeMs : null
+          });
+        }
+      } catch {
+        this.loadFromDisk();
+      }
+      return;
+    }
+    this.loadFromDisk();
+  }
+  loadFromDisk() {
+    if (!fs.existsSync(GRAPH_FILE)) return;
+    try {
+      const raw = fs.readFileSync(GRAPH_FILE, "utf8");
+      const snap = JSON.parse(raw);
+      if (snap.version === 1 && snap.nodes) {
+        for (const [id, node] of Object.entries(snap.nodes)) {
+          this.nodes.set(id, node);
+        }
+      }
+    } catch {
+    }
+  }
+  scheduleNativeFlush() {
+    if (!this.native?.graphFlush) return;
+    if (this.nativeFlushTimer) return;
+    this.nativeFlushTimer = setTimeout(() => {
+      this.nativeFlushTimer = null;
+      try {
+        this.native?.graphFlush?.();
+      } catch {
+      }
+    }, 250);
+  }
+  scheduleSave() {
+    if (this.native) return;
+    this.queueSave();
+  }
+  save() {
+    if (this.native) return;
+    try {
+      const snap = {
+        version: 1,
+        nodes: Object.fromEntries(this.nodes.entries())
+      };
+      fs.writeFileSync(GRAPH_FILE, JSON.stringify(snap, null, 2), "utf8");
+      this.dirty = false;
+    } catch {
+    } finally {
+      if (this.saveTimer) {
+        clearTimeout(this.saveTimer);
+        this.saveTimer = null;
+      }
+    }
+  }
+  /** Upsert a node and its deps; returns true if hash changed */
+  recordFile(absPath, contentHash, depsAbs, dynamicDeps, kind) {
+    const stat = fs.existsSync(absPath) ? fs.statSync(absPath) : null;
+    const mtimeMs = stat ? stat.mtimeMs : null;
+    const configHash = process.env.IONIFY_CONFIG_HASH || null;
+    const prev = this.nodes.get(absPath);
+    let changed = !prev || prev.hash !== contentHash;
+    const node = {
+      id: absPath,
+      hash: contentHash,
+      deps: Array.from(new Set(depsAbs)),
+      dynamicDeps: dynamicDeps ? Array.from(new Set(dynamicDeps)) : void 0,
+      kind: kind || this.inferKind(absPath),
+      configHash,
+      mtimeMs
+    };
+    this.nodes.set(absPath, node);
+    if (this.native) {
+      try {
+        changed = this.native.graphRecord(
+          absPath,
+          contentHash,
+          node.deps,
+          node.dynamicDeps || [],
+          node.kind,
+          node.configHash ?? null
+        );
+        this.scheduleNativeFlush();
+      } catch (err) {
+        console.error(`[Graph] Failed to record ${absPath}:`, err);
+      }
+    }
+    this.scheduleSave();
+    return changed;
+  }
+  /** Infer module kind from file extension */
+  inferKind(absPath) {
+    const ext = path.extname(absPath).toLowerCase();
+    if (/\.(module)\.css$/i.test(absPath)) return "css-module";
+    if ([".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"].includes(ext)) return "js";
+    if (ext === ".css") return "css";
+    if ([".json"].includes(ext)) return "json";
+    return "asset";
+  }
+  getNode(absPath) {
+    return this.nodes.get(absPath);
+  }
+  getDeps(absPath) {
+    return this.nodes.get(absPath)?.deps ?? [];
+  }
+  /** Reverse edges: who depends on target? */
+  getDependents(targetAbs) {
+    const candidates = /* @__PURE__ */ new Set();
+    if (this.native?.graphDependents) {
+      try {
+        for (const dep of this.native.graphDependents(targetAbs) ?? []) {
+          candidates.add(dep);
+        }
+      } catch {
+      }
+    }
+    for (const [id, node] of this.nodes) {
+      if (node.deps.includes(targetAbs)) candidates.add(id);
+    }
+    return Array.from(candidates);
+  }
+  /** Collect dependents recursively (breadth-first) */
+  collectDependentsDeep(targetAbs) {
+    const result = /* @__PURE__ */ new Set();
+    const queue = [targetAbs];
+    while (queue.length) {
+      const current = queue.shift();
+      for (const dep of this.getDependents(current)) {
+        if (!result.has(dep)) {
+          result.add(dep);
+          queue.push(dep);
+        }
+      }
+    }
+    return Array.from(result);
+  }
+  /** Includes changed files and all dependents */
+  collectAffected(changed) {
+    const result = /* @__PURE__ */ new Set();
+    let usedNative = false;
+    if (this.native?.graphCollectAffected) {
+      try {
+        const nativeList = this.native.graphCollectAffected(changed);
+        for (const item of nativeList ?? []) {
+          result.add(item);
+        }
+        usedNative = true;
+      } catch {
+      }
+    }
+    for (const target of changed) {
+      result.add(target);
+    }
+    if (!usedNative || result.size === 0) {
+      for (const target of changed) {
+        result.add(target);
+        for (const dep of this.collectDependentsDeep(target)) {
+          result.add(dep);
+        }
+      }
+    }
+    return Array.from(result);
+  }
+  /** Remove file from graph and clean up dependents lists */
+  removeFile(absPath) {
+    const existed = this.nodes.delete(absPath);
+    if (existed) {
+      for (const node of this.nodes.values()) {
+        if (node.deps.includes(absPath)) {
+          node.deps = node.deps.filter((dep) => dep !== absPath);
+        }
+      }
+      if (this.native) {
+        try {
+          this.native.graphRemove(absPath);
+          this.scheduleNativeFlush();
+        } catch {
+        }
+      }
+      this.queueSave();
+    }
+  }
+  /** Persist immediately (e.g., on shutdown) */
+  flush() {
+    if (this.nativeFlushTimer) {
+      clearTimeout(this.nativeFlushTimer);
+      this.nativeFlushTimer = null;
+    }
+    if (this.native?.graphFlush) {
+      try {
+        this.native.graphFlush();
+      } catch {
+      }
+    }
+    if (this.dirty) this.save();
+  }
+};
+
+// src/core/resolver.ts
+import fs2 from "fs";
+import path2 from "path";
+import { createRequire } from "module";
+import { pathToFileURL, fileURLToPath } from "url";
+var SUPPORTED_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"];
+var CONFIG_FILES = ["tsconfig.json", "jsconfig.json"];
+var swc = null;
+(() => {
+  try {
+    const require2 = createRequire(import.meta.url);
+    swc = require2("@swc/core");
+  } catch {
+    swc = null;
+  }
+})();
+function extractImports(source, filename = "inline.ts") {
+  if (native?.parseModuleIr) {
+    try {
+      const result = native.parseModuleIr(filename, source);
+      return result.dependencies.map((dep) => dep.specifier);
+    } catch {
+    }
+  }
+  const deps = /* @__PURE__ */ new Set();
+  const fallbackRegex = () => {
+    const re = /(?:import\s+(?:[^'"]+\s+from\s+)??['"]([^'"]+)['"])|(?:export\s+[^'"]+\s+from\s+['"]([^'"]+)['"])|(?:import\s*?\(\s*?['"]([^'"]+)['"]\s*?\))/g;
+    let m;
+    while (m = re.exec(source)) {
+      const spec = m[1] || m[2] || m[3];
+      if (spec) deps.add(spec);
+    }
+  };
+  try {
+    const parseSync = swc?.parseSync;
+    if (parseSync) {
+      const ast = parseSync(source, {
+        filename,
+        isModule: true,
+        target: "es2022",
+        syntax: "typescript",
+        tsx: true,
+        decorators: true,
+        dynamicImport: true
+      });
+      const visit = (node) => {
+        if (!node || typeof node !== "object") return;
+        const anyNode = node;
+        const type = anyNode.type;
+        if (type === "ImportDeclaration" && anyNode.source && typeof anyNode.source.value === "string") {
+          deps.add(anyNode.source.value);
+        } else if (type === "ExportAllDeclaration" && anyNode.source && typeof anyNode.source.value === "string") {
+          deps.add(anyNode.source.value);
+        } else if (type === "ExportNamedDeclaration" && anyNode.source && typeof anyNode.source.value === "string") {
+          deps.add(anyNode.source.value);
+        } else if (type === "CallExpression") {
+          const callee = anyNode.callee ?? {};
+          if (callee.type === "Import") {
+            const args = anyNode.arguments ?? [];
+            const first = args[0];
+            if (first && typeof first === "object") {
+              const expr = first.expression;
+              if (expr && expr.type === "StringLiteral" && typeof expr.value === "string") {
+                deps.add(expr.value);
+              }
+            }
+          }
+        }
+        for (const value of Object.values(anyNode)) {
+          if (!value) continue;
+          if (Array.isArray(value)) {
+            for (const item of value) visit(item);
+          } else if (typeof value === "object") {
+            visit(value);
+          }
+        }
+      };
+      visit(ast);
+    } else {
+      fallbackRegex();
+    }
+  } catch {
+    fallbackRegex();
+  }
+  if (!deps.size) {
+    fallbackRegex();
+  }
+  return Array.from(deps);
+}
+function tryFile(p) {
+  if (fs2.existsSync(p) && fs2.statSync(p).isFile()) return p;
+  return null;
+}
+function tryWithExt(p) {
+  if (tryFile(p)) return p;
+  for (const ext of SUPPORTED_EXTS) {
+    const cand = p.endsWith(ext) ? p : p + ext;
+    const found = tryFile(cand);
+    if (found) return found;
+  }
+  if (fs2.existsSync(p) && fs2.statSync(p).isDirectory()) {
+    const pkgPath = path2.join(p, "package.json");
+    if (fs2.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+        if (pkg.main) {
+          const mainPath = path2.join(p, pkg.main);
+          const mainResolved = tryFile(mainPath) || tryWithExt(mainPath);
+          if (mainResolved) return mainResolved;
+        }
+        if (pkg.module) {
+          const modulePath = path2.join(p, pkg.module);
+          const moduleResolved = tryFile(modulePath) || tryWithExt(modulePath);
+          if (moduleResolved) return moduleResolved;
+        }
+      } catch {
+      }
+    }
+    for (const ext of SUPPORTED_EXTS) {
+      const idx = path2.join(p, "index" + ext);
+      const found = tryFile(idx);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+var cachedTsconfigAliases;
+var customAliasEntries = [];
+var resolvePathCache = /* @__PURE__ */ new Map();
+function createAliasEntry(pattern, targets) {
+  const hasWildcard = pattern.includes("*");
+  if (hasWildcard) {
+    const escaped = pattern.replace(/[-/\\^$+?.()|[\]{}]/g, "\\$&");
+    const matcher = new RegExp(`^${escaped.replace(/\*/g, "(.*)")}$`);
+    return {
+      resolveCandidates(specifier) {
+        const match = matcher.exec(specifier);
+        if (!match) return [];
+        const wildcards = match.slice(1);
+        return targets.map((target) => {
+          if (!target.includes("*")) return target;
+          const segments = target.split("*");
+          let rebuilt = segments[0] ?? "";
+          for (let i = 1; i < segments.length; i++) {
+            const replacement = wildcards[i - 1] ?? wildcards[wildcards.length - 1] ?? "";
+            rebuilt += replacement + segments[i];
+          }
+          return rebuilt;
+        });
+      }
+    };
+  }
+  const normalizedPattern = pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
+  return {
+    resolveCandidates(specifier) {
+      if (specifier === normalizedPattern) {
+        return targets;
+      }
+      if (normalizedPattern && specifier.startsWith(normalizedPattern + "/")) {
+        const remainder = specifier.slice(normalizedPattern.length + 1);
+        return targets.map((target) => path2.join(target, remainder));
+      }
+      return [];
+    }
+  };
+}
+function buildAliasEntries(aliases, baseDir) {
+  const entries = [];
+  for (const [pattern, value] of Object.entries(aliases)) {
+    const replacements = Array.isArray(value) ? value : [value];
+    const targets = replacements.filter((rep) => typeof rep === "string" && rep.trim().length > 0).map(
+      (rep) => path2.isAbsolute(rep) ? rep : path2.resolve(baseDir, rep)
+    );
+    if (!targets.length) continue;
+    entries.push(createAliasEntry(pattern, targets));
+  }
+  return entries;
+}
+function loadTsconfigAliases() {
+  if (cachedTsconfigAliases !== void 0) {
+    return cachedTsconfigAliases ?? [];
+  }
+  const rootDir = process.cwd();
+  for (const configName of CONFIG_FILES) {
+    const candidate = path2.resolve(rootDir, configName);
+    if (!fs2.existsSync(candidate) || !fs2.statSync(candidate).isFile()) {
+      continue;
+    }
+    try {
+      const raw = fs2.readFileSync(candidate, "utf8");
+      const parsed = JSON.parse(raw);
+      const compilerOptions = parsed?.compilerOptions ?? {};
+      const baseUrl = compilerOptions.baseUrl ? path2.resolve(path2.dirname(candidate), compilerOptions.baseUrl) : path2.dirname(candidate);
+      const paths = compilerOptions.paths ?? {};
+      cachedTsconfigAliases = buildAliasEntries(paths, baseUrl);
+      return cachedTsconfigAliases;
+    } catch {
+    }
+  }
+  cachedTsconfigAliases = [];
+  return cachedTsconfigAliases;
+}
+function resolveFromEntries(entries, specifier) {
+  for (const entry of entries) {
+    const candidates = entry.resolveCandidates(specifier);
+    for (const candidate of candidates) {
+      const resolved = tryWithExt(candidate);
+      if (resolved) return resolved;
+    }
+  }
+  return null;
+}
+function resolveWithAliases(specifier) {
+  const custom = resolveFromEntries(customAliasEntries, specifier);
+  if (custom) return custom;
+  const tsconfigEntries = loadTsconfigAliases();
+  return resolveFromEntries(tsconfigEntries, specifier);
+}
+function configureResolverAliases(aliases, baseDir) {
+  customAliasEntries = aliases ? buildAliasEntries(aliases, baseDir) : [];
+}
+function resolveImport(specifier, importerAbs) {
+  const cacheKey = `${importerAbs}\0${specifier}`;
+  if (resolvePathCache.has(cacheKey)) {
+    return resolvePathCache.get(cacheKey) ?? null;
+  }
+  if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
+    const aliasResolved = resolveWithAliases(specifier);
+    if (aliasResolved) {
+      resolvePathCache.set(cacheKey, aliasResolved);
+      return aliasResolved;
+    }
+    try {
+      const require2 = createRequire(importerAbs);
+      const resolved2 = require2.resolve(specifier);
+      resolvePathCache.set(cacheKey, resolved2);
+      return resolved2;
+    } catch {
+      try {
+        const importerUrl = pathToFileURL(importerAbs).href;
+        const resolvedUrl = import.meta.resolve(specifier, importerUrl);
+        if (resolvedUrl.startsWith("file://")) {
+          const resolved2 = fileURLToPath(resolvedUrl);
+          resolvePathCache.set(cacheKey, resolved2);
+          return resolved2;
+        }
+        resolvePathCache.set(cacheKey, resolvedUrl);
+        return resolvedUrl;
+      } catch {
+        const nodeModulesPath = path2.join(path2.dirname(importerAbs), "node_modules", specifier);
+        const resolvedNodeModules = tryWithExt(nodeModulesPath);
+        if (resolvedNodeModules) {
+          resolvePathCache.set(cacheKey, resolvedNodeModules);
+          return resolvedNodeModules;
+        }
+        const srcPath = path2.join(process.cwd(), "src", specifier);
+        const resolvedSrc = tryWithExt(srcPath);
+        if (resolvedSrc) {
+          resolvePathCache.set(cacheKey, resolvedSrc);
+          return resolvedSrc;
+        }
+        const rootPath = path2.join(process.cwd(), specifier);
+        const resolvedRoot = tryWithExt(rootPath);
+        if (resolvedRoot) {
+          resolvePathCache.set(cacheKey, resolvedRoot);
+          return resolvedRoot;
+        }
+        resolvePathCache.set(cacheKey, null);
+        return null;
+      }
+    }
+  }
+  const baseDir = path2.dirname(importerAbs);
+  const target = path2.resolve(baseDir, specifier);
+  const resolved = tryWithExt(target);
+  resolvePathCache.set(cacheKey, resolved);
+  return resolved;
+}
+function resolveImports(specs, importerAbs) {
+  const abs = specs.map((s) => resolveImport(s, importerAbs)).filter((x) => !!x);
+  return Array.from(new Set(abs));
+}
+
+// src/core/resolver/module-resolver.ts
+import path3 from "path";
+import fs3 from "fs";
+var DEFAULT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".json", ".mjs"];
+var DEFAULT_CONDITIONS = ["import", "default"];
+var DEFAULT_MAIN_FIELDS = ["module", "main"];
+var ModuleResolver = class {
+  options;
+  rootDir;
+  constructor(rootDir, options = {}) {
+    this.rootDir = rootDir;
+    this.options = {
+      baseUrl: options.baseUrl || ".",
+      paths: options.paths || {},
+      extensions: options.extensions || DEFAULT_EXTENSIONS,
+      alias: options.alias || {},
+      conditions: options.conditions || DEFAULT_CONDITIONS,
+      mainFields: options.mainFields || DEFAULT_MAIN_FIELDS
+    };
+  }
+  resolve(importSpecifier, importer) {
+    if (path3.isAbsolute(importSpecifier)) {
+      return this.tryResolveFile(importSpecifier);
+    }
+    const aliasResolved = this.resolveAlias(importSpecifier);
+    if (aliasResolved) {
+      return this.tryResolveFile(aliasResolved);
+    }
+    if (importSpecifier.startsWith(".")) {
+      const resolvedPath = path3.resolve(path3.dirname(importer), importSpecifier);
+      return this.tryResolveFile(resolvedPath);
+    }
+    return this.resolveBareModule(importSpecifier, importer);
+  }
+  resolveAlias(specifier) {
+    for (const [alias, target] of Object.entries(this.options.alias)) {
+      if (specifier === alias || specifier.startsWith(`${alias}/`)) {
+        const relativePath = specifier.slice(alias.length);
+        const targets = Array.isArray(target) ? target : [target];
+        for (const t of targets) {
+          const resolved = path3.join(this.rootDir, t, relativePath);
+          if (fs3.existsSync(resolved)) {
+            return resolved;
+          }
+        }
+      }
+    }
+    for (const [pattern, targets] of Object.entries(this.options.paths)) {
+      const wildcardIndex = pattern.indexOf("*");
+      if (wildcardIndex === -1) {
+        if (specifier === pattern) {
+          return path3.join(this.rootDir, this.options.baseUrl, targets[0]);
+        }
+      } else {
+        const prefix = pattern.slice(0, wildcardIndex);
+        const suffix = pattern.slice(wildcardIndex + 1);
+        if (specifier.startsWith(prefix) && specifier.endsWith(suffix)) {
+          const matchedPortion = specifier.slice(prefix.length, -suffix.length || void 0);
+          for (const target of targets) {
+            const resolved = path3.join(
+              this.rootDir,
+              this.options.baseUrl,
+              target.replace("*", matchedPortion)
+            );
+            if (fs3.existsSync(resolved)) {
+              return resolved;
+            }
+          }
+        }
+      }
+    }
+    return null;
+  }
+  resolveBareModule(specifier, importer) {
+    const parts = specifier.split("/");
+    const packageName = parts[0].startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0];
+    const subpath = parts.slice(packageName.startsWith("@") ? 2 : 1).join("/");
+    let dir = path3.dirname(importer);
+    while (dir !== "/") {
+      const nodeModulesPath = path3.join(dir, "node_modules", packageName);
+      if (fs3.existsSync(nodeModulesPath)) {
+        if (subpath) {
+          return this.tryResolveFile(path3.join(nodeModulesPath, subpath));
+        }
+        return this.resolvePackageMain(nodeModulesPath);
+      }
+      dir = path3.dirname(dir);
+    }
+    return null;
+  }
+  resolvePackageMain(packageDir) {
+    const pkgJsonPath = path3.join(packageDir, "package.json");
+    if (fs3.existsSync(pkgJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf8"));
+        if (pkg.exports) {
+          const resolved = this.resolveExports(pkg.exports, packageDir);
+          if (resolved) return resolved;
+        }
+        for (const field of this.options.mainFields) {
+          if (pkg[field]) {
+            const resolved = this.tryResolveFile(path3.join(packageDir, pkg[field]));
+            if (resolved) return resolved;
+          }
+        }
+      } catch {
+      }
+    }
+    return this.tryResolveFile(path3.join(packageDir, "index"));
+  }
+  resolveExports(exports, packageDir) {
+    if (typeof exports === "string") {
+      return this.tryResolveFile(path3.join(packageDir, exports));
+    }
+    if (Array.isArray(exports)) {
+      for (const exp of exports) {
+        const resolved = this.resolveExports(exp, packageDir);
+        if (resolved) return resolved;
+      }
+      return null;
+    }
+    if (typeof exports === "object") {
+      for (const condition of this.options.conditions) {
+        if (condition in exports) {
+          const resolved = this.resolveExports(exports[condition], packageDir);
+          if (resolved) return resolved;
+        }
+      }
+      if ("default" in exports) {
+        return this.resolveExports(exports.default, packageDir);
+      }
+    }
+    return null;
+  }
+  tryResolveFile(filepath) {
+    if (fs3.existsSync(filepath) && fs3.statSync(filepath).isFile()) {
+      return filepath;
+    }
+    for (const ext of this.options.extensions) {
+      const withExt = `${filepath}${ext}`;
+      if (fs3.existsSync(withExt) && fs3.statSync(withExt).isFile()) {
+        return withExt;
+      }
+    }
+    if (fs3.existsSync(filepath) && fs3.statSync(filepath).isDirectory()) {
+      for (const ext of this.options.extensions) {
+        const indexFile = path3.join(filepath, `index${ext}`);
+        if (fs3.existsSync(indexFile) && fs3.statSync(indexFile).isFile()) {
+          return indexFile;
+        }
+      }
+    }
+    return null;
+  }
+};
+
+// src/core/watcher.ts
+import fs4 from "fs";
+import path4 from "path";
+import { EventEmitter } from "events";
+var IonifyWatcher = class extends EventEmitter {
+  constructor(rootDir) {
+    super();
+    this.rootDir = rootDir;
+  }
+  watchers = /* @__PURE__ */ new Map();
+  debounce = /* @__PURE__ */ new Map();
+  polled = /* @__PURE__ */ new Set();
+  watchFile(filePath) {
+    const abs = path4.resolve(filePath);
+    if (this.watchers.has(abs)) return;
+    if (/(node_modules|\.git|\.ionify|dist)/.test(abs)) return;
+    if (!fs4.existsSync(abs)) return;
+    try {
+      const dir = path4.dirname(abs);
+      const watcher = fs4.watch(dir, (event, filename) => {
+        if (!filename) return;
+        const full = path4.join(dir, filename.toString());
+        if (full !== abs) return;
+        const now = Date.now();
+        const last = this.debounce.get(abs) || 0;
+        if (now - last < 100) return;
+        this.debounce.set(abs, now);
+        const exists = fs4.existsSync(abs);
+        this.emit("change", abs, exists ? "changed" : "deleted");
+      });
+      this.watchers.set(abs, watcher);
+      this.polled.add(abs);
+      fs4.watchFile(abs, { interval: 5e3 }, (curr, prev) => {
+        if (curr.mtimeMs !== prev.mtimeMs) {
+          this.emit("change", abs, "changed");
+        }
+      });
+    } catch {
+      this.polled.add(abs);
+      fs4.watchFile(abs, { interval: 8e3 }, (curr, prev) => {
+        if (curr.mtimeMs !== prev.mtimeMs) {
+          this.emit("change", abs, "changed");
+        }
+      });
+    }
+  }
+  unwatchFile(filePath) {
+    const abs = path4.resolve(filePath);
+    const watcher = this.watchers.get(abs);
+    if (watcher) watcher.close();
+    fs4.unwatchFile(abs);
+    this.watchers.delete(abs);
+    this.polled.delete(abs);
+  }
+  closeAll() {
+    for (const [abs, w] of this.watchers) {
+      w.close();
+      fs4.unwatchFile(abs);
+    }
+    this.watchers.clear();
+    for (const abs of this.polled) {
+      fs4.unwatchFile(abs);
+    }
+    this.polled.clear();
+  }
+};
+
+// src/core/transform.ts
+var TransformCache = class {
+  store = /* @__PURE__ */ new Map();
+  hits = 0;
+  misses = 0;
+  maxEntries;
+  constructor(maxEntries) {
+    const envMax = process.env.IONIFY_DEV_TRANSFORM_CACHE_MAX;
+    const parsedEnv = envMax ? parseInt(envMax, 10) : NaN;
+    this.maxEntries = Number.isFinite(parsedEnv) ? parsedEnv : maxEntries ?? 5e3;
+  }
+  setMaxEntries(maxEntries) {
+    this.maxEntries = maxEntries;
+    this.prune();
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (entry) {
+      this.hits += 1;
+      entry.timestamp = Date.now();
+      return entry;
+    }
+    this.misses += 1;
+    return null;
+  }
+  set(key, entry) {
+    this.store.set(key, { ...entry, timestamp: Date.now() });
+    this.prune();
+  }
+  prune(maxEntries) {
+    const limit = maxEntries ?? this.maxEntries;
+    if (this.store.size <= limit) return;
+    const sorted = Array.from(this.store.entries()).sort(
+      (a, b) => a[1].timestamp - b[1].timestamp
+    );
+    const removeCount = this.store.size - limit;
+    for (let i = 0; i < removeCount; i++) {
+      this.store.delete(sorted[i][0]);
+    }
+  }
+  metrics() {
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      size: this.store.size,
+      max: this.maxEntries
+    };
+  }
+};
+var transformCache = new TransformCache();
+var TransformEngine = class {
+  loaders = [];
+  cacheEnabled;
+  cacheVersion = "v1";
+  casRoot;
+  versionHash;
+  constructor(options) {
+    this.cacheEnabled = options?.cache ?? true;
+    this.casRoot = options?.casRoot;
+    this.versionHash = options?.versionHash;
+  }
+  useLoader(loader) {
+    this.loaders.push(loader);
+    this.loaders.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  async run(ctx) {
+    const { getCacheKey: getCacheKey2 } = await import("../cache-Y4NMRSZO.js");
+    const path13 = await import("path");
+    const fs11 = await import("fs");
+    const { getCasArtifactPath: getCasArtifactPath2 } = await import("../cas-FEOXFD7R.js");
+    const moduleHash = ctx.moduleHash || getCacheKey2(ctx.code);
+    const loaderSig = this.loaders.map((l) => l.name || "loader").join("|");
+    const loaderHash = getCacheKey2(loaderSig);
+    const memKey = `${moduleHash}-${loaderHash}`;
+    const casDir = this.casRoot && this.versionHash ? getCasArtifactPath2(this.casRoot, this.versionHash, moduleHash) : null;
+    const casFile = casDir ? path13.join(casDir, "transformed.js") : null;
+    const casMapFile = casDir ? path13.join(casDir, "transformed.js.map") : null;
+    const debug = process.env.IONIFY_DEV_TRANSFORM_CACHE_DEBUG === "1";
+    if (this.cacheEnabled) {
+      const memHit = transformCache.get(memKey);
+      if (memHit) {
+        if (debug) {
+          console.log(`[Dev Cache] HIT mem key=${memKey} size=${transformCache.metrics().size}`);
+        }
+        return { code: memHit.transformed, map: memHit.map };
+      }
+      if (casFile && fs11.existsSync(casFile)) {
+        try {
+          const code = fs11.readFileSync(casFile, "utf8");
+          const map = casMapFile && fs11.existsSync(casMapFile) ? fs11.readFileSync(casMapFile, "utf8") : void 0;
+          const parsed = { code, map };
+          transformCache.set(memKey, {
+            hash: moduleHash,
+            loaderHash,
+            transformed: parsed.code,
+            map: parsed.map,
+            timestamp: Date.now()
+          });
+          if (debug) {
+            console.log(`[Dev Cache] HIT cas key=${memKey} size=${transformCache.metrics().size}`);
+          }
+          return parsed;
+        } catch {
+        }
+      }
+    }
+    let working = { ...ctx };
+    let result = { code: ctx.code };
+    for (const loader of this.loaders) {
+      if (!loader.test(working)) continue;
+      const output = await loader.transform({ ...working, code: result.code });
+      if (output && output.code !== void 0) {
+        result = { ...result, ...output };
+        working = { ...working, code: result.code };
+      }
+    }
+    if (this.cacheEnabled) {
+      transformCache.set(memKey, {
+        hash: moduleHash,
+        loaderHash,
+        transformed: result.code,
+        map: result.map,
+        timestamp: Date.now()
+      });
+      if (casFile) {
+        try {
+          fs11.mkdirSync(path13.dirname(casFile), { recursive: true });
+          fs11.writeFileSync(casFile, result.code, "utf8");
+          if (result.map && casMapFile) {
+            fs11.writeFileSync(casMapFile, typeof result.map === "string" ? result.map : JSON.stringify(result.map), "utf8");
+          }
+        } catch {
+        }
+      }
+      if (debug) {
+        const m = transformCache.metrics();
+        console.log(`[Dev Cache] MISS stored key=${memKey} size=${m.size} hits=${m.hits} misses=${m.misses}`);
+      }
+    }
+    return result;
+  }
+};
+
+// src/core/hmr.ts
+var HMRServer = class {
+  clients = /* @__PURE__ */ new Set();
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  closed = false;
+  /** Handle an incoming SSE subscription request */
+  handleSSE(req, res) {
+    if (this.closed) {
+      res.writeHead(503);
+      res.end();
+      return;
+    }
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no"
+    });
+    res.write(`event: ready
+data: "ok"
+
+`);
+    this.clients.add(res);
+    req.on("close", () => {
+      this.clients.delete(res);
+      try {
+        res.end();
+      } catch {
+      }
+    });
+  }
+  send(event, payload) {
+    const data = (event ? `event: ${event}
+` : "") + `data: ${JSON.stringify(payload)}
+
+`;
+    for (const client of this.clients) {
+      try {
+        client.write(data);
+      } catch {
+      }
+    }
+  }
+  /** Broadcast a JSON event to all SSE clients */
+  broadcast(payload) {
+    this.send(null, payload);
+  }
+  broadcastEvent(event, payload) {
+    this.send(event, payload);
+  }
+  queueUpdate(modules) {
+    if (!modules.length) return null;
+    const timestamp = Date.now();
+    const id = `${timestamp}-${this.nextId++}`;
+    const summary = {
+      type: "update",
+      id,
+      timestamp,
+      modules: modules.map(({ url: url2, hash, reason }) => ({ url: url2, hash, reason }))
+    };
+    this.pending.set(id, { summary, modules, createdAt: timestamp });
+    this.broadcastEvent("update", summary);
+    return summary;
+  }
+  consumeUpdate(id) {
+    const pending = this.pending.get(id);
+    if (pending) {
+      this.pending.delete(id);
+    }
+    return pending;
+  }
+  broadcastError(payload) {
+    this.broadcastEvent("error", { type: "error", ...payload });
+  }
+  close() {
+    this.closed = true;
+    for (const client of this.clients) {
+      try {
+        client.end();
+      } catch {
+      }
+    }
+    this.clients.clear();
+    this.pending.clear();
+  }
+};
+function injectHMRClient(html) {
+  const tag = `<script type="module" src="/__ionify_hmr_client.js"></script>`;
+  return html.includes("</body>") ? html.replace("</body>", `${tag}
+</body>`) : html + "\n" + tag;
+}
+
+// src/core/loaders/css.ts
+import path5 from "path";
+import crypto from "crypto";
+import postcss from "postcss";
+import postcssLoadConfig from "postcss-load-config";
+import postcssModules from "postcss-modules";
+var cachedConfig = null;
+var configFailed = false;
+async function getPostcssConfig(rootDir) {
+  if (cachedConfig) return cachedConfig;
+  if (configFailed) return { plugins: [], options: {} };
+  try {
+    const result = await postcssLoadConfig({}, rootDir);
+    cachedConfig = {
+      plugins: Array.isArray(result.plugins) ? result.plugins : [],
+      options: result.options ?? {}
+    };
+  } catch {
+    configFailed = true;
+    cachedConfig = { plugins: [], options: {} };
+  }
+  return cachedConfig;
+}
+async function compileCss({
+  code,
+  filePath,
+  rootDir,
+  modules = false
+}) {
+  const loaderHash = getCacheKey(JSON.stringify({ modules, filePath: filePath.replace(/\\+/g, "/") }));
+  const contentHash = getCacheKey(code);
+  const cacheKey = `${contentHash}-${loaderHash}`;
+  const cached = transformCache.get(cacheKey);
+  if (cached) {
+    try {
+      const parsed = JSON.parse(cached.transformed);
+      return parsed;
+    } catch {
+    }
+  }
+  const { plugins, options } = await getPostcssConfig(rootDir);
+  const pipeline = [...plugins];
+  let tokens;
+  if (modules) {
+    const scopedName = (name, filename) => {
+      const relative = path5.relative(rootDir, filename || filePath).replace(/\\+/g, "/");
+      const seed = crypto.createHash("sha1").update(relative).digest("hex").slice(0, 6);
+      return `${name}___${seed}`;
+    };
+    pipeline.push(
+      postcssModules({
+        generateScopedName: scopedName,
+        getJSON(_filename, json) {
+          tokens = json;
+        }
+      })
+    );
+  }
+  const runner = postcss(pipeline);
+  const result = await runner.process(code, {
+    ...options,
+    from: filePath,
+    map: false
+  });
+  const compiled = {
+    css: result.css,
+    tokens
+  };
+  transformCache.set(cacheKey, {
+    hash: contentHash,
+    loaderHash,
+    transformed: JSON.stringify(compiled),
+    timestamp: Date.now()
+  });
+  return compiled;
+}
+function renderCssModule({
+  css,
+  filePath,
+  tokens
+}) {
+  const cssJson = JSON.stringify(css);
+  const styleId = `ionify-css-${getCacheKey(filePath).slice(0, 8)}`;
+  const tokensJson = tokens ? JSON.stringify(tokens) : "null";
+  return `
+const cssText = ${cssJson};
+const styleId = ${JSON.stringify(styleId)};
+let style = document.querySelector(\`style[data-ionify-id="\${styleId}"]\`);
+if (!style) {
+  style = document.createElement("style");
+  style.setAttribute("data-ionify-id", styleId);
+  document.head.appendChild(style);
+}
+style.textContent = cssText;
+${tokens ? `const tokens = ${tokensJson};` : ""}
+export const css = cssText;
+${tokens ? `export const classes = tokens;
+export default tokens;` : `export default cssText;`}
+if (import.meta.hot) {
+  import.meta.hot.accept();
+  import.meta.hot.dispose(() => {
+    const existing = document.querySelector(\`style[data-ionify-id="\${styleId}"]\`);
+    if (existing) existing.remove();
+  });
+}
+`.trim();
+}
+
+// src/core/utils/public-path.ts
+import path6 from "path";
+var MODULE_PREFIX = "/__ionify__/modules/";
+function publicPathForFile(rootDir, absPath) {
+  const normalizedRoot = path6.resolve(rootDir);
+  const normalizedFile = path6.resolve(absPath);
+  if (normalizedFile.startsWith(normalizedRoot + path6.sep) || normalizedFile === normalizedRoot) {
+    const relative = path6.relative(normalizedRoot, normalizedFile).split(path6.sep).join("/");
+    return "/" + (relative.length ? relative : "");
+  }
+  const encoded = Buffer.from(normalizedFile).toString("base64url");
+  return MODULE_PREFIX + encoded;
+}
+function decodePublicPath(rootDir, urlPath) {
+  if (urlPath.startsWith(MODULE_PREFIX)) {
+    const encoded = urlPath.slice(MODULE_PREFIX.length);
+    try {
+      const decoded = Buffer.from(encoded, "base64url").toString("utf8");
+      return path6.resolve(decoded);
+    } catch {
+      return null;
+    }
+  }
+  const normalizedRoot = path6.resolve(rootDir);
+  const joined = path6.resolve(normalizedRoot, "." + urlPath);
+  if (!joined.startsWith(normalizedRoot + path6.sep) && joined !== normalizedRoot) {
+    return null;
+  }
+  return joined;
+}
+
+// src/core/loaders/asset.ts
+function assetAsModule(urlPath) {
+  const safe = urlPath.replace(/"/g, "%22");
+  return `export default "${safe}";`;
+}
+function isAssetExt(ext) {
+  return [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".svg",
+    ".ico",
+    ".webp",
+    ".avif",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".otf",
+    ".eot"
+  ].includes(ext);
+}
+function contentTypeForAsset(ext) {
+  switch (ext) {
+    case ".png":
+      return "image/png";
+    case ".jpg":
+    case ".jpeg":
+      return "image/jpeg";
+    case ".gif":
+      return "image/gif";
+    case ".svg":
+      return "image/svg+xml";
+    case ".ico":
+      return "image/x-icon";
+    case ".webp":
+      return "image/webp";
+    case ".avif":
+      return "image/avif";
+    case ".woff":
+      return "font/woff";
+    case ".woff2":
+      return "font/woff2";
+    case ".ttf":
+      return "font/ttf";
+    case ".otf":
+      return "font/otf";
+    case ".eot":
+      return "application/vnd.ms-fontobject";
+    default:
+      return "application/octet-stream";
+  }
+}
+function normalizeUrlFromFs(rootDir, fsPath) {
+  return publicPathForFile(rootDir, fsPath);
+}
+
+// src/core/loaders/js.ts
+import { transform as swcTransform } from "@swc/core";
+import { init, parse } from "es-module-lexer";
+var JS_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx"]);
+function needsReactRefresh(ext) {
+  if (ext === ".jsx" || ext === ".tsx") return true;
+  if (!ext.endsWith("x")) return false;
+  return false;
+}
+function shouldTransform(ext, filePath) {
+  if (!JS_EXTENSIONS.has(ext)) return false;
+  if (filePath.endsWith(".d.ts")) return false;
+  return true;
+}
+async function swcTranspile(code, filePath, ext, reactRefresh) {
+  const isTypeScript = ext === ".ts" || ext === ".tsx";
+  const isTsx = ext === ".tsx";
+  const isJsx = ext === ".jsx";
+  const swcParser = isTypeScript ? {
+    syntax: "typescript",
+    tsx: isTsx,
+    decorators: true,
+    dynamicImport: true
+  } : {
+    syntax: "ecmascript",
+    jsx: isJsx,
+    decorators: true,
+    dynamicImport: true
+  };
+  const result = await swcTransform(code, {
+    filename: filePath,
+    jsc: {
+      parser: swcParser,
+      target: "es2022",
+      transform: reactRefresh ? {
+        react: {
+          development: true,
+          refresh: true,
+          runtime: "automatic"
+        }
+      } : void 0
+    },
+    sourceMaps: false,
+    module: {
+      type: "es6"
+    }
+  });
+  return result.code ?? code;
+}
+function currentMode() {
+  const mode = (process.env.IONIFY_PARSER || "hybrid").toLowerCase();
+  if (mode === "swc") return "swc";
+  if (mode === "oxc") return "oxc";
+  return "hybrid";
+}
+var jsLoader = {
+  name: "js",
+  order: 0,
+  test: ({ ext, path: filePath }) => shouldTransform(ext, filePath),
+  transform: async ({ path: filePath, code, ext }) => {
+    const isNodeModules = filePath.includes("node_modules");
+    let output = code;
+    if (isNodeModules) {
+      const bundled = tryBundleNodeModule(filePath, code);
+      if (bundled) {
+        output = bundled;
+      } else {
+        output = code;
+      }
+    } else {
+      const reactRefresh = needsReactRefresh(ext);
+      const mode = currentMode();
+      const nativeResult = tryNativeTransform(mode, code, {
+        filename: filePath,
+        jsx: ext === ".jsx" || ext === ".tsx",
+        typescript: ext === ".ts" || ext === ".tsx",
+        react_refresh: reactRefresh
+      });
+      if (nativeResult) {
+        output = nativeResult.code ?? code;
+      } else {
+        output = await swcTranspile(code, filePath, ext, reactRefresh);
+      }
+      if (reactRefresh) {
+        const prologue = `import { setupReactRefresh } from "/__ionify_react_refresh.js";
+const __ionifyRefresh__ = setupReactRefresh(import.meta.hot, import.meta.url);
+`;
+        const epilogue = `
+__ionifyRefresh__?.finalize?.();
+
+if (import.meta.hot) {
+  import.meta.hot.accept((newModule) => {
+    __ionifyRefresh__?.refresh?.(newModule);
+  });
+  import.meta.hot.dispose(() => {
+    __ionifyRefresh__?.dispose?.();
+  });
+}
+`;
+        output = prologue + output + epilogue;
+      } else {
+        output += `
+if (import.meta.hot) {
+  import.meta.hot.accept();
+}
+`;
+      }
+    }
+    await init;
+    const [imports] = parse(output);
+    if (imports.length) {
+      const rootDir = process.cwd();
+      let rewritten = "";
+      let lastIndex = 0;
+      let mutated = false;
+      for (const record of imports) {
+        if (!record.n) continue;
+        const spec = record.n;
+        if (spec.startsWith("http://") || spec.startsWith("https://") || spec.startsWith(MODULE_PREFIX)) {
+          continue;
+        }
+        let pathPart = spec;
+        let suffix = "";
+        const queryIndex = spec.indexOf("?");
+        const hashIndex = spec.indexOf("#");
+        const splitIndex = queryIndex === -1 ? hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
+        if (splitIndex !== -1) {
+          pathPart = spec.slice(0, splitIndex);
+          suffix = spec.slice(splitIndex);
+        }
+        const resolved = resolveImport(pathPart, filePath);
+        if (!resolved) continue;
+        const resolvedExt = resolved.slice(resolved.lastIndexOf("."));
+        let augmentedSuffix = suffix;
+        if (resolvedExt === ".css" && !suffix) {
+          augmentedSuffix = "?inline";
+        }
+        const assetExts = [
+          ".png",
+          ".jpg",
+          ".jpeg",
+          ".gif",
+          ".svg",
+          ".ico",
+          ".webp",
+          ".avif",
+          ".woff",
+          ".woff2",
+          ".ttf",
+          ".otf",
+          ".eot"
+        ];
+        if (assetExts.includes(resolvedExt) && !suffix) {
+          augmentedSuffix = "?import";
+        }
+        const replacementPath = publicPathForFile(rootDir, resolved);
+        const replacement = replacementPath + augmentedSuffix;
+        if (replacement === spec) continue;
+        if (!mutated) {
+          mutated = true;
+        }
+        if (record.t === 2) {
+          rewritten += output.slice(lastIndex, record.s + 1);
+          rewritten += replacement;
+          rewritten += output[record.e - 1];
+          lastIndex = record.e;
+        } else {
+          rewritten += output.slice(lastIndex, record.s);
+          rewritten += replacement;
+          lastIndex = record.e;
+        }
+      }
+      if (mutated) {
+        rewritten += output.slice(lastIndex);
+        output = rewritten;
+      }
+    }
+    return { code: output };
+  }
+};
+
+// src/core/loaders/registry.ts
+var registry = [];
+function registerLoader(registration) {
+  registry.push(registration);
+}
+async function applyRegisteredLoaders(engine, config) {
+  for (const registration of registry) {
+    await registration(engine, config ?? null);
+  }
+  if (config?.plugins) {
+    for (const plugin of config.plugins) {
+      if (plugin.loaders) {
+        for (const loader of plugin.loaders) {
+          engine.useLoader(loader);
+        }
+      }
+      if (plugin.setup) {
+        const context = {
+          registerLoader: (loader) => {
+            engine.useLoader(loader);
+          }
+        };
+        await plugin.setup(context);
+      }
+    }
+  }
+  if (config?.loaders) {
+    for (const loader of config.loaders) {
+      engine.useLoader(loader);
+    }
+  }
+}
+registerLoader((engine) => {
+  engine.useLoader(jsLoader);
+});
+
+// src/cli/utils/config.ts
+import fs5 from "fs";
+import path7 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { build } from "esbuild";
+var CONFIG_BASENAMES = [
+  "ionify.config.ts",
+  "ionify.config.mts",
+  "ionify.config.js",
+  "ionify.config.mjs",
+  "ionify.config.cjs"
+];
+var cachedConfig2 = null;
+var configLoaded = false;
+async function bundleConfig(entry) {
+  const absDir = path7.dirname(entry);
+  const inlineIonifyPlugin = {
+    name: "inline-ionify",
+    setup(build2) {
+      build2.onResolve({ filter: /^ionify$/ }, () => ({
+        path: "ionify-virtual",
+        namespace: "ionify-ns"
+      }));
+      build2.onLoad({ filter: /.*/, namespace: "ionify-ns" }, () => ({
+        contents: `
+          export function defineConfig(config) {
+            return typeof config === 'function' ? config : () => config;
+          }
+        `,
+        loader: "js"
+      }));
+    }
+  };
+  const result = await build({
+    entryPoints: [entry],
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    sourcemap: "inline",
+    write: false,
+    target: "node18",
+    logLevel: "silent",
+    absWorkingDir: absDir,
+    plugins: [inlineIonifyPlugin]
+  });
+  const output = result.outputFiles?.[0];
+  if (!output) throw new Error("Failed to bundle ionify config");
+  const dirnameLiteral = JSON.stringify(absDir);
+  const filenameLiteral = JSON.stringify(entry);
+  const importMetaLiteral = JSON.stringify(pathToFileURL2(entry).href);
+  let contents = output.text;
+  if (contents.includes("import.meta.url")) {
+    contents = contents.replace(/import\.meta\.url/g, "__IONIFY_IMPORT_META_URL");
+    contents = `const __IONIFY_IMPORT_META_URL = ${importMetaLiteral};
+${contents}`;
+  }
+  const preamble = `const __dirname = ${dirnameLiteral};
+const __filename = ${filenameLiteral};
+`;
+  return preamble + contents;
+}
+function findConfigFile(cwd) {
+  for (const name of CONFIG_BASENAMES) {
+    const candidate = path7.resolve(cwd, name);
+    if (fs5.existsSync(candidate) && fs5.statSync(candidate).isFile()) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function loadIonifyConfig(cwd = process.cwd()) {
+  if (configLoaded) return cachedConfig2;
+  configLoaded = true;
+  const configPath = findConfigFile(cwd);
+  if (!configPath) {
+    cachedConfig2 = null;
+    configureResolverAliases(void 0, cwd);
+    return cachedConfig2;
+  }
+  try {
+    const bundled = await bundleConfig(configPath);
+    const dataUrl = `data:text/javascript;base64,${Buffer.from(bundled).toString("base64")}`;
+    const imported = await import(dataUrl);
+    let resolved = imported?.default ?? imported?.config ?? imported ?? null;
+    if (resolved && typeof resolved === "function") {
+      resolved = resolved({ mode: process.env.NODE_ENV || "development" });
+    }
+    if (resolved && typeof resolved?.then === "function") {
+      resolved = await resolved;
+    }
+    if (resolved && typeof resolved === "object") {
+      cachedConfig2 = resolved;
+      const baseDir = path7.dirname(configPath);
+      const aliases = resolved?.resolve?.alias;
+      if (aliases && typeof aliases === "object") {
+        configureResolverAliases(aliases, baseDir);
+      } else {
+        configureResolverAliases(void 0, baseDir);
+      }
+      logInfo(`Loaded ionify config from ${path7.relative(cwd, configPath)}`);
+    } else {
+      throw new Error("Config did not export an object");
+    }
+  } catch (err) {
+    logError("Failed to load ionify.config", err);
+    cachedConfig2 = null;
+    configureResolverAliases(void 0, cwd);
+  }
+  return cachedConfig2;
+}
+
+// src/cli/utils/minifier.ts
+function normalize(value) {
+  if (value === "oxc" || value === "swc" || value === "auto") return value;
+  if (typeof value === "string") {
+    const v = value.toLowerCase();
+    if (v === "oxc" || v === "swc" || v === "auto") return v;
+  }
+  return null;
+}
+function resolveMinifier(config, opts = {}) {
+  const fromCli = normalize(opts.cliFlag);
+  if (fromCli) return fromCli;
+  const fromEnv = normalize(opts.envVar);
+  if (fromEnv) return fromEnv;
+  const fromConfig = normalize(config?.minifier);
+  if (fromConfig) return fromConfig;
+  return "auto";
+}
+function applyMinifierEnv(choice) {
+  process.env.IONIFY_MINIFIER = choice;
+}
+
+// src/cli/utils/env.ts
+import fs6 from "fs";
+import path8 from "path";
+function parseValue(raw) {
+  let value = raw.trim();
+  if (!value) return "";
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    value = value.slice(1, -1);
+  }
+  value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r");
+  return value;
+}
+function parseEnvFile(source) {
+  const env = {};
+  const lines = source.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = trimmed.match(/^(?:export\s+)?([A-Za-z_][A-Za-z0-9_\.]*)\s*=\s*(.*)$/);
+    if (!match) continue;
+    const [, key, rest] = match;
+    env[key] = parseValue(rest);
+  }
+  return env;
+}
+function loadEnv(mode = "development", rootDir = process.cwd()) {
+  const candidates = [
+    ".env",
+    ".env.local",
+    `.env.${mode}`,
+    `.env.${mode}.local`
+  ];
+  const merged = {};
+  for (const name of candidates) {
+    const filePath = path8.resolve(rootDir, name);
+    if (!fs6.existsSync(filePath) || !fs6.statSync(filePath).isFile()) {
+      continue;
+    }
+    const contents = fs6.readFileSync(filePath, "utf8");
+    const parsed = parseEnvFile(contents);
+    Object.assign(merged, parsed);
+  }
+  for (const [key, value] of Object.entries(merged)) {
+    process.env[key] = value;
+  }
+  return {
+    ...merged
+  };
+}
+
+// src/cli/utils/treeshake.ts
+var DEFAULT_RESOLUTION = {
+  mode: "safe",
+  include: [],
+  exclude: []
+};
+function parseMode(value) {
+  if (!value) return null;
+  switch (value.toLowerCase()) {
+    case "off":
+    case "false":
+      return "off";
+    case "aggressive":
+      return "aggressive";
+    case "safe":
+    case "true":
+      return "safe";
+    default:
+      return null;
+  }
+}
+function normalizeList(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) {
+    return value.filter((entry) => typeof entry === "string" && entry.length > 0);
+  }
+  return [];
+}
+function parseEnvList(raw) {
+  if (!raw || !raw.trim()) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return normalizeList(parsed);
+  } catch {
+    return null;
+  }
+}
+function extractConfigObject(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return null;
+}
+function resolveTreeshake(input, options = {}) {
+  let resolved = { ...DEFAULT_RESOLUTION };
+  const objectValue = extractConfigObject(input);
+  if (objectValue) {
+    resolved.include = normalizeList(objectValue.include);
+    resolved.exclude = normalizeList(objectValue.exclude);
+    if (objectValue.mode) {
+      const objectMode = parseMode(objectValue.mode);
+      if (objectMode) {
+        resolved.mode = objectMode;
+      }
+    }
+  } else if (typeof input === "boolean") {
+    resolved.mode = input ? "safe" : "off";
+  } else if (typeof input === "string") {
+    resolved.mode = parseMode(input) ?? DEFAULT_RESOLUTION.mode;
+  }
+  const envMode = parseMode(options.envMode);
+  if (envMode) {
+    resolved.mode = envMode;
+  }
+  const includeOverride = parseEnvList(options.includeEnv);
+  if (includeOverride) {
+    resolved.include = includeOverride;
+  }
+  const excludeOverride = parseEnvList(options.excludeEnv);
+  if (excludeOverride) {
+    resolved.exclude = excludeOverride;
+  }
+  return resolved;
+}
+function applyTreeshakeEnv(resolved) {
+  process.env.IONIFY_TREESHAKE = resolved.mode;
+  process.env.IONIFY_TREESHAKE_INCLUDE = JSON.stringify(resolved.include);
+  process.env.IONIFY_TREESHAKE_EXCLUDE = JSON.stringify(resolved.exclude);
+}
+
+// src/cli/utils/scope-hoist.ts
+var DEFAULT_SCOPE_HOIST = {
+  enable: true,
+  inlineFunctions: true,
+  constantFolding: true,
+  combineVariables: true
+};
+function parseBool(value) {
+  if (value === true || value === false) return value;
+  if (typeof value === "string") {
+    const normalized = value.toLowerCase();
+    if (["true", "1", "yes", "on", "enable"].includes(normalized)) return true;
+    if (["false", "0", "no", "off", "disable"].includes(normalized)) return false;
+  }
+  return null;
+}
+function parseEnvFlag(value) {
+  if (!value) return null;
+  return parseBool(value);
+}
+function resolveScopeHoist(configValue, options = {}) {
+  let resolved = { ...DEFAULT_SCOPE_HOIST };
+  const scopeConfig = configValue;
+  if (typeof scopeConfig === "boolean") {
+    resolved.enable = scopeConfig;
+  } else if (scopeConfig && typeof scopeConfig === "object") {
+    resolved.enable = true;
+    if (scopeConfig.inlineFunctions !== void 0) {
+      resolved.inlineFunctions = !!scopeConfig.inlineFunctions;
+    }
+    if (scopeConfig.constantFolding !== void 0) {
+      resolved.constantFolding = !!scopeConfig.constantFolding;
+    }
+    if (scopeConfig.combineVariables !== void 0) {
+      resolved.combineVariables = !!scopeConfig.combineVariables;
+    }
+  }
+  const envMode = parseEnvFlag(options.envMode);
+  if (envMode !== null) {
+    resolved.enable = envMode;
+  }
+  const inlineEnv = parseEnvFlag(options.inlineEnv);
+  if (inlineEnv !== null) {
+    resolved.inlineFunctions = inlineEnv;
+  } else if (!resolved.enable) {
+    resolved.inlineFunctions = false;
+  }
+  const constantEnv = parseEnvFlag(options.constantEnv);
+  if (constantEnv !== null) {
+    resolved.constantFolding = constantEnv;
+  } else if (!resolved.enable) {
+    resolved.constantFolding = false;
+  }
+  const combineEnv = parseEnvFlag(options.combineEnv);
+  if (combineEnv !== null) {
+    resolved.combineVariables = combineEnv;
+  } else if (!resolved.enable) {
+    resolved.combineVariables = false;
+  }
+  return resolved;
+}
+function applyScopeHoistEnv(result) {
+  process.env.IONIFY_SCOPE_HOIST = result.enable ? "true" : "false";
+  process.env.IONIFY_SCOPE_HOIST_INLINE = result.inlineFunctions ? "true" : "false";
+  process.env.IONIFY_SCOPE_HOIST_CONST = result.constantFolding ? "true" : "false";
+  process.env.IONIFY_SCOPE_HOIST_COMBINE = result.combineVariables ? "true" : "false";
+}
 
-// src/native/index.ts
-import fs from "fs";
-import path from "path";
-import { createRequire } from "module";
+// src/cli/utils/parser.ts
+function normalize2(mode) {
+  if (typeof mode !== "string") return null;
+  const lower = mode.toLowerCase();
+  if (lower === "swc") return "swc";
+  if (lower === "hybrid") return "hybrid";
+  if (lower === "oxc") return "oxc";
+  return null;
+}
+function resolveParser(config, opts) {
+  const envRaw = opts?.envMode ?? process.env.IONIFY_PARSER;
+  const env = normalize2(envRaw);
+  if (env) return env;
+  const fromConfig = normalize2(config?.parser);
+  return fromConfig ?? "hybrid";
+}
+function applyParserEnv(mode) {
+  process.env.IONIFY_PARSER = mode;
+}
 
-// src/core/version.ts
-import { createHash } from "crypto";
-
-// src/native/index.ts
-function resolveCandidates() {
-  const cwd = process.cwd();
-  const releaseDir = path.resolve(cwd, "target", "release");
-  const debugDir = path.resolve(cwd, "target", "debug");
-  const nativeDir = path.resolve(cwd, "native");
-  const moduleDir = path.dirname(new URL(import.meta.url).pathname);
-  const packageNativeDir = path.resolve(moduleDir, "..", "native");
-  const packageDistDir = path.resolve(moduleDir, "..");
-  const platformFile = process.platform === "win32" ? "ionify_core.dll" : process.platform === "darwin" ? "libionify_core.dylib" : "libionify_core.so";
-  const candidates = [
-    // Installed package locations (checked first)
-    path.join(packageDistDir, "ionify_core.node"),
-    path.join(packageNativeDir, "ionify_core.node"),
-    // Development locations
-    path.join(nativeDir, "ionify_core.node"),
-    path.join(releaseDir, "ionify_core.node"),
-    path.join(releaseDir, platformFile),
-    path.join(debugDir, "ionify_core.node"),
-    path.join(debugDir, platformFile)
-  ];
-  return candidates.filter((candidate) => {
-    try {
-      return fs.existsSync(candidate) && fs.statSync(candidate).isFile();
-    } catch {
-      return false;
+// src/cli/commands/dev.ts
+import crypto2 from "crypto";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path9.dirname(__filename2);
+var CLIENT_DIR = path9.resolve(__dirname2, "../client");
+var CLIENT_FALLBACK_DIR = path9.resolve(process.cwd(), "src/client");
+function readClientAssetFile(fileName) {
+  const primary = path9.join(CLIENT_DIR, fileName);
+  if (fs7.existsSync(primary)) {
+    return { filePath: primary, code: fs7.readFileSync(primary, "utf8") };
+  }
+  const fallback = path9.join(CLIENT_FALLBACK_DIR, fileName);
+  if (fs7.existsSync(fallback)) {
+    return { filePath: fallback, code: fs7.readFileSync(fallback, "utf8") };
+  }
+  throw new Error(`Missing Ionify client asset: ${fileName}`);
+}
+function readClientAsset(fileName) {
+  return readClientAssetFile(fileName).code;
+}
+function guessContentType(filePath) {
+  const ext = path9.extname(filePath);
+  if (ext === ".html") return "text/html; charset=utf-8";
+  if (ext === ".css") return "text/css; charset=utf-8";
+  if (ext === ".json") return "application/json; charset=utf-8";
+  if ([".mjs", ".js", ".ts", ".tsx", ".jsx", ".cjs", ".mts", ".cts"].includes(ext))
+    return "application/javascript; charset=utf-8";
+  if ([".wasm"].includes(ext))
+    return "application/wasm";
+  if ([".map"].includes(ext))
+    return "application/json; charset=utf-8";
+  return "text/plain; charset=utf-8";
+}
+async function startDevServer({
+  port = 5173,
+  enableSignalHandlers = true
+} = {}) {
+  const rootDir = process.cwd();
+  const watcher = new IonifyWatcher(rootDir);
+  const cacheDebug = process.env.IONIFY_DEV_TRANSFORM_CACHE_DEBUG === "1";
+  const userConfig = await loadIonifyConfig();
+  const minifier = resolveMinifier(userConfig, { envVar: process.env.IONIFY_MINIFIER });
+  applyMinifierEnv(minifier);
+  const parserMode = resolveParser(userConfig, { envMode: process.env.IONIFY_PARSER });
+  applyParserEnv(parserMode);
+  const treeshake = resolveTreeshake(userConfig?.treeshake, {
+    envMode: process.env.IONIFY_TREESHAKE,
+    includeEnv: process.env.IONIFY_TREESHAKE_INCLUDE,
+    excludeEnv: process.env.IONIFY_TREESHAKE_EXCLUDE
+  });
+  applyTreeshakeEnv(treeshake);
+  const scopeHoist = resolveScopeHoist(userConfig?.scopeHoist, {
+    envMode: process.env.IONIFY_SCOPE_HOIST,
+    inlineEnv: process.env.IONIFY_SCOPE_HOIST_INLINE,
+    constantEnv: process.env.IONIFY_SCOPE_HOIST_CONST,
+    combineEnv: process.env.IONIFY_SCOPE_HOIST_COMBINE
+  });
+  applyScopeHoistEnv(scopeHoist);
+  const resolvedEntry = userConfig?.entry ? userConfig.entry.startsWith("/") ? path9.join(rootDir, userConfig.entry) : path9.resolve(rootDir, userConfig.entry) : void 0;
+  const pluginNames = Array.isArray(userConfig?.plugins) ? userConfig.plugins.map((p) => typeof p === "string" ? p : p?.name).filter((name) => typeof name === "string" && name.length > 0) : void 0;
+  const rawVersionInputs = {
+    parserMode,
+    minifier,
+    treeshake,
+    scopeHoist,
+    plugins: pluginNames,
+    entry: resolvedEntry ? [resolvedEntry] : null,
+    cssOptions: userConfig?.css,
+    assetOptions: userConfig?.assets ?? userConfig?.asset
+  };
+  const configHash = computeGraphVersion(rawVersionInputs);
+  logInfo(`[Dev] Version hash: ${configHash}`);
+  process.env.IONIFY_CONFIG_HASH = configHash;
+  const casRoot = path9.join(rootDir, ".ionify", "cas");
+  const transformer = new TransformEngine({ casRoot, versionHash: configHash });
+  const graph = new Graph(rawVersionInputs);
+  if (native?.initAstCache) {
+    const versionHash = JSON.stringify(rawVersionInputs);
+    native.initAstCache(versionHash);
+    logInfo(`AST cache initialized with version hash`);
+    if (native?.astCacheWarmup) {
+      try {
+        native.astCacheWarmup();
+      } catch (err) {
+        logWarn(`AST cache warmup skipped: ${err}`);
+      }
+    }
+    if (native?.astCacheStats) {
+      try {
+        const stats = native.astCacheStats();
+        const entries = stats.total_entries ?? stats.totalEntries ?? 0;
+        const sizeBytes = stats.total_size_bytes ?? stats.totalSizeBytes ?? 0;
+        const hits = stats.total_hits ?? stats.totalHits ?? 0;
+        const hitRate = stats.hit_rate ?? stats.hitRate ?? 0;
+        logInfo(`[AST Cache] entries=${entries}, size=${sizeBytes} bytes, hits=${hits}, hitRate=${hitRate}`);
+      } catch {
+      }
     }
+  }
+  const moduleResolver = new ModuleResolver(rootDir, {
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".json", ".mjs"],
+    conditions: ["import", "default"],
+    mainFields: ["module", "main"],
+    ...userConfig?.resolve || {}
   });
-}
-var nativeBinding = null;
-(() => {
-  const require2 = createRequire(import.meta.url);
-  for (const candidate of resolveCandidates()) {
+  await applyRegisteredLoaders(transformer, userConfig);
+  const hmr = new HMRServer();
+  const envFromFiles = loadEnv("development", rootDir);
+  process.env.NODE_ENV = process.env.NODE_ENV ?? "development";
+  process.env.MODE = process.env.MODE ?? "development";
+  const envValues = {
+    ...envFromFiles,
+    NODE_ENV: process.env.NODE_ENV,
+    MODE: process.env.MODE
+  };
+  const envPlaceholderPattern = /%([A-Z0-9_]+)%/g;
+  const envEnabledExts = /* @__PURE__ */ new Set([
+    ".html",
+    ".js",
+    ".mjs",
+    ".cjs",
+    ".ts",
+    ".tsx",
+    ".jsx"
+  ]);
+  const applyEnvPlaceholders = (input, extname) => {
+    if (!envEnabledExts.has(extname)) return input;
+    return input.replace(envPlaceholderPattern, (match, key) => {
+      if (key === "NODE_ENV" || key === "MODE" || key.startsWith("VITE_") || key.startsWith("IONIFY_")) {
+        const replacement = envValues[key];
+        return replacement !== void 0 ? replacement : match;
+      }
+      return match;
+    });
+  };
+  const parseJsonBody = async (req) => {
+    const chunks = [];
+    await new Promise((resolve, reject) => {
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", () => resolve());
+      req.on("error", (err) => reject(err));
+    });
+    if (!chunks.length) return null;
+    const raw = Buffer.concat(chunks).toString("utf8");
+    if (!raw.trim()) return null;
+    return JSON.parse(raw);
+  };
+  const sendJson = (res, status, payload) => {
+    const body = JSON.stringify(payload);
+    res.writeHead(status, {
+      "Content-Type": "application/json; charset=utf-8",
+      "Cache-Control": "no-store"
+    });
+    res.end(body);
+  };
+  const buildUpdatePayload = async (modules) => {
+    const updates = [];
+    for (const mod of modules) {
+      const exists = fs7.existsSync(mod.absPath);
+      if (mod.reason === "deleted" || !exists) {
+        graph.removeFile(mod.absPath);
+        watcher.unwatchFile(mod.absPath);
+        updates.push({
+          url: mod.url,
+          hash: null,
+          deps: [],
+          reason: mod.reason,
+          status: "deleted"
+        });
+        continue;
+      }
+      watcher.watchFile(mod.absPath);
+      let code;
+      try {
+        code = fs7.readFileSync(mod.absPath, "utf8");
+      } catch (err) {
+        logError("Failed to read module during HMR apply", err);
+        throw err;
+      }
+      let hash;
+      let specs;
+      if (native?.parseModuleIr) {
+        try {
+          const ir = native.parseModuleIr(mod.absPath, code);
+          hash = ir.hash;
+          specs = ir.dependencies.map((dep) => dep.specifier);
+        } catch {
+          hash = getCacheKey(code);
+          specs = extractImports(code, mod.absPath);
+        }
+      } else {
+        hash = getCacheKey(code);
+        specs = extractImports(code, mod.absPath);
+      }
+      const depsAbs = resolveImports(specs, mod.absPath);
+      graph.recordFile(mod.absPath, hash, depsAbs);
+      for (const dep of depsAbs) {
+        watcher.watchFile(dep);
+      }
+      const result = await transformer.run({
+        path: mod.absPath,
+        code,
+        ext: path9.extname(mod.absPath),
+        moduleHash: hash
+      });
+      const transformed = result.code;
+      const envApplied = applyEnvPlaceholders(
+        transformed,
+        path9.extname(mod.absPath)
+      );
+      updates.push({
+        url: mod.url,
+        hash,
+        deps: depsAbs.map((dep) => normalizeUrlFromFs(rootDir, dep)),
+        reason: mod.reason,
+        status: "updated",
+        code: envApplied
+      });
+    }
+    return updates;
+  };
+  const server = http.createServer(async (req, res) => {
     try {
-      const mod = require2(candidate);
-      if (mod) {
-        nativeBinding = mod;
-        break;
+      const parsed = url.parse(req.url || "/", true);
+      let reqPath = parsed.pathname || "/";
+      try {
+        reqPath = decodeURIComponent(reqPath);
+      } catch {
       }
-    } catch {
+      const q = parsed.query || {};
+      if (reqPath === "/__ionify_hmr") {
+        hmr.handleSSE(req, res);
+        return;
+      }
+      if (reqPath === "/__ionify_hmr_client.js") {
+        res.writeHead(200, { "Content-Type": "application/javascript; charset=utf-8" });
+        res.end(readClientAsset("hmr.js"));
+        return;
+      }
+      if (reqPath === "/__ionify_overlay.js") {
+        res.writeHead(200, { "Content-Type": "application/javascript; charset=utf-8" });
+        res.end(readClientAsset("overlay.js"));
+        return;
+      }
+      if (reqPath === "/__ionify_react_refresh.js") {
+        try {
+          const asset = readClientAssetFile("react-refresh-runtime.js");
+          let reactRefreshPath;
+          try {
+            const projectRequire = createRequire2(path9.join(rootDir, "package.json"));
+            reactRefreshPath = projectRequire.resolve("react-refresh/runtime");
+          } catch (err) {
+            logError("Failed to resolve react-refresh/runtime", err);
+            res.statusCode = 500;
+            res.end("Failed to resolve react-refresh/runtime. Make sure react-refresh is installed.");
+            return;
+          }
+          const reactRefreshUrl = normalizeUrlFromFs(rootDir, reactRefreshPath);
+          let code2 = asset.code.replace(
+            'import RefreshRuntime from "react-refresh/runtime"',
+            `import RefreshRuntime from "${reactRefreshUrl}"`
+          );
+          res.writeHead(200, { "Content-Type": "application/javascript; charset=utf-8" });
+          res.end(code2);
+        } catch (err) {
+          logError("Failed to serve react refresh runtime", err);
+          res.statusCode = 500;
+          res.end("Internal Server Error");
+        }
+        return;
+      }
+      if (reqPath === "/__ionify_hmr/apply") {
+        if (req.method !== "POST") {
+          res.writeHead(405, { Allow: "POST" });
+          res.end("Method Not Allowed");
+          return;
+        }
+        let body;
+        try {
+          body = await parseJsonBody(req);
+        } catch (err) {
+          logError("Invalid JSON body for HMR apply", err);
+          sendJson(res, 400, { error: "Invalid JSON body" });
+          return;
+        }
+        const id = typeof body?.id === "string" ? body.id : null;
+        if (!id) {
+          sendJson(res, 400, { error: "Missing update id" });
+          return;
+        }
+        const pending = hmr.consumeUpdate(id);
+        if (!pending) {
+          sendJson(res, 404, { error: "Update not found", id });
+          return;
+        }
+        try {
+          const modules = await buildUpdatePayload(pending.modules);
+          sendJson(res, 200, {
+            type: "update",
+            id: pending.summary.id,
+            timestamp: Date.now(),
+            modules
+          });
+        } catch (err) {
+          logError("Failed to build HMR update payload", err);
+          hmr.broadcastError({
+            id,
+            message: "Failed to compile update; falling back to full reload"
+          });
+          sendJson(res, 500, { error: "Failed to compile update", id });
+        }
+        return;
+      }
+      if (reqPath === "/__ionify_hmr/error") {
+        if (req.method !== "POST") {
+          res.writeHead(405, { Allow: "POST" });
+          res.end("Method Not Allowed");
+          return;
+        }
+        let body;
+        try {
+          body = await parseJsonBody(req);
+        } catch {
+          body = null;
+        }
+        const id = typeof body?.id === "string" ? body.id : void 0;
+        const message = typeof body?.message === "string" ? body.message : "Unknown HMR error";
+        logError(`[HMR] client reported error${id ? ` ${id}` : ""}: ${message}`);
+        hmr.broadcastError({ id, message });
+        sendJson(res, 200, { ok: true });
+        return;
+      }
+      const fsPath = decodePublicPath(rootDir, reqPath);
+      if (!fsPath) {
+        res.statusCode = 404;
+        res.end("Not found");
+        return;
+      }
+      let effectiveFsPath = fsPath;
+      let effectiveUrlPath = reqPath;
+      if (fs7.existsSync(effectiveFsPath) && fs7.statSync(effectiveFsPath).isDirectory()) {
+        const indexExtensions = [".html", ".js", ".ts", ".tsx", ".jsx"];
+        let found = false;
+        for (const ext2 of indexExtensions) {
+          const indexFile = path9.join(effectiveFsPath, `index${ext2}`);
+          if (fs7.existsSync(indexFile)) {
+            effectiveFsPath = indexFile;
+            effectiveUrlPath = effectiveUrlPath.endsWith("/") ? `${effectiveUrlPath}index${ext2}` : `${effectiveUrlPath}/index${ext2}`;
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          const packageJson = path9.join(effectiveFsPath, "package.json");
+          if (fs7.existsSync(packageJson)) {
+            try {
+              const pkg = JSON.parse(fs7.readFileSync(packageJson, "utf8"));
+              if (pkg.main) {
+                const mainFile = path9.join(effectiveFsPath, pkg.main);
+                if (fs7.existsSync(mainFile)) {
+                  effectiveFsPath = mainFile;
+                  found = true;
+                }
+              }
+            } catch (e) {
+            }
+          }
+        }
+        if (!found) {
+          for (const ext2 of indexExtensions) {
+            const moduleFile = path9.join(effectiveFsPath, `module${ext2}`);
+            if (fs7.existsSync(moduleFile)) {
+              effectiveFsPath = moduleFile;
+              found = true;
+              break;
+            }
+          }
+        }
+        if (!found) {
+          res.statusCode = 404;
+          res.end("Module not found");
+          return;
+        }
+      }
+      if (!fs7.existsSync(effectiveFsPath)) {
+        res.statusCode = 404;
+        res.end("Not found");
+        return;
+      }
+      const ext = path9.extname(effectiveFsPath);
+      if (isAssetExt(ext)) {
+        try {
+          const data = fs7.readFileSync(effectiveFsPath);
+          const assetHash = crypto2.createHash("sha256").update(data).digest("hex");
+          const kind = "asset";
+          const changed2 = graph.recordFile(effectiveFsPath, assetHash, [], [], kind);
+          watcher.watchFile(effectiveFsPath);
+          if (changed2) {
+            logInfo(`[Graph] Asset updated: ${effectiveFsPath}`);
+          }
+        } catch {
+        }
+        if ("import" in q) {
+          const js = assetAsModule(normalizeUrlFromFs(rootDir, effectiveFsPath));
+          res.writeHead(200, { "Content-Type": "application/javascript; charset=utf-8" });
+          res.end(js);
+          return;
+        } else {
+          res.writeHead(200, { "Content-Type": contentTypeForAsset(ext) });
+          fs7.createReadStream(effectiveFsPath).pipe(res);
+          return;
+        }
+      }
+      if (ext === ".css") {
+        try {
+          const cssSource = fs7.readFileSync(effectiveFsPath, "utf8");
+          const isModule = "module" in q || /\.module\.css$/i.test(effectiveFsPath);
+          const isInline = "inline" in q;
+          const mode = isModule ? "css:module" : isInline ? "css:inline" : "css:raw";
+          const contentHash = getCacheKey(cssSource);
+          watcher.watchFile(effectiveFsPath);
+          const kind = isModule ? "css-module" : "css";
+          const changed2 = graph.recordFile(effectiveFsPath, contentHash, [], [], kind);
+          const casDir = getCasArtifactPath(casRoot, configHash, contentHash);
+          const casFile = path9.join(casDir, "transformed.js");
+          let finalBuffer = null;
+          if (fs7.existsSync(casFile)) {
+            try {
+              finalBuffer = fs7.readFileSync(casFile);
+              res.setHeader("X-Ionify-Cache", "HIT");
+            } catch {
+              finalBuffer = null;
+            }
+          }
+          if (!finalBuffer) {
+            const { css: compiledCss, tokens } = await compileCss({
+              code: cssSource,
+              filePath: effectiveFsPath,
+              rootDir,
+              modules: isModule
+            });
+            const body = isModule || isInline ? renderCssModule({
+              css: compiledCss,
+              filePath: effectiveFsPath,
+              tokens: isModule ? tokens ?? {} : void 0
+            }) : compiledCss;
+            finalBuffer = Buffer.from(body, "utf8");
+            res.setHeader("X-Ionify-Cache", "MISS");
+            try {
+              fs7.mkdirSync(casDir, { recursive: true });
+              fs7.writeFileSync(casFile, finalBuffer);
+            } catch {
+            }
+          }
+          if (isModule || isInline) {
+            res.writeHead(200, { "Content-Type": "application/javascript; charset=utf-8" });
+          } else {
+            res.writeHead(200, { "Content-Type": "text/css; charset=utf-8" });
+          }
+          res.end(finalBuffer);
+          logInfo(`Served: ${effectiveUrlPath} deps:0 ${changed2 ? "(updated)" : "(cached)"}`);
+          return;
+        } catch (err) {
+          logError("Failed to process CSS", err);
+          res.statusCode = 500;
+          res.end("Failed to process CSS");
+          return;
+        }
+      }
+      const code = fs7.readFileSync(effectiveFsPath, "utf8");
+      let hash;
+      let specs;
+      if (native?.parseModuleIr) {
+        try {
+          const ir = native.parseModuleIr(effectiveFsPath, code);
+          hash = ir.hash;
+          specs = ir.dependencies.map((dep) => dep.specifier);
+        } catch {
+          hash = getCacheKey(code);
+          specs = extractImports(code, effectiveFsPath);
+        }
+      } else {
+        hash = getCacheKey(code);
+        specs = extractImports(code, effectiveFsPath);
+      }
+      const depsAbs = resolveImports(specs, effectiveFsPath);
+      const changed = graph.recordFile(effectiveFsPath, hash, depsAbs);
+      watcher.watchFile(effectiveFsPath);
+      for (const dep of depsAbs) {
+        watcher.watchFile(dep);
+      }
+      const result = await transformer.run({
+        path: effectiveFsPath,
+        code,
+        ext,
+        moduleHash: hash
+      });
+      const transformedCode = result.code;
+      res.setHeader("X-Ionify-Cache", changed ? "MISS" : "HIT");
+      const envApplied = applyEnvPlaceholders(transformedCode, ext);
+      if (path9.extname(effectiveFsPath) === ".html") {
+        const injected = injectHMRClient(envApplied);
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.end(injected);
+      } else {
+        const finalBuffer = Buffer.from(envApplied);
+        res.setHeader("Content-Type", guessContentType(effectiveFsPath));
+        res.end(finalBuffer);
+      }
+      logInfo(`Served: ${effectiveUrlPath} deps:${depsAbs.length} ${changed ? "(updated)" : "(cached)"}`);
+      if (cacheDebug) {
+        const m = transformCache.metrics();
+        logInfo(`[Ionify][Dev Cache] hits:${m.hits} misses:${m.misses} size:${m.size}`);
+      }
+    } catch (err) {
+      logError("Error serving request:", err);
+      res.statusCode = 500;
+      res.end("Internal Server Error");
+    }
+  });
+  watcher.on("change", (file, status) => {
+    logInfo(`[Watcher] ${status}: ${file}`);
+    const affected = graph.collectAffected([file]);
+    if (!affected.includes(file)) {
+      affected.unshift(file);
+    }
+    const modules = [];
+    for (const absPath of affected) {
+      const reason = absPath === file ? status === "deleted" ? "deleted" : "changed" : "dependent";
+      let hash = null;
+      if (reason !== "deleted") {
+        if (absPath === file) {
+          try {
+            const code = fs7.readFileSync(absPath, "utf8");
+            hash = getCacheKey(code);
+          } catch {
+            hash = graph.getNode(absPath)?.hash ?? null;
+          }
+        } else {
+          hash = graph.getNode(absPath)?.hash ?? null;
+        }
+      }
+      modules.push({
+        absPath,
+        url: normalizeUrlFromFs(rootDir, absPath),
+        hash,
+        reason
+      });
+    }
+    const summary = hmr.queueUpdate(modules);
+    if (summary) {
+      logInfo(
+        `[HMR] update ${summary.id} -> ${summary.modules.length} module(s) queued`
+      );
+    }
+    if (status === "deleted") {
+      graph.removeFile(file);
+      watcher.unwatchFile(file);
+    }
+  });
+  let closingPromise = null;
+  let cleanedUp = false;
+  const signalHandlers = [];
+  const cleanup = (force = false) => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    if (force) {
+      server.getConnections((err, count) => {
+        if (!err && count > 0) {
+          server.closeAllConnections();
+        }
+      });
+    }
+    try {
+      watcher.closeAll();
+    } catch (err) {
+      logError("Error closing watcher:", err);
+    }
+    try {
+      hmr.close();
+    } catch (err) {
+      logError("Error closing HMR:", err);
+    }
+    graph.flush();
+    for (const { event, handler } of signalHandlers) {
+      process.off(event, handler);
+    }
+  };
+  server.on("close", () => cleanup(false));
+  const shutdown = async (exitProcess) => {
+    if (!closingPromise) {
+      closingPromise = new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          logInfo("Server shutdown taking too long, forcing cleanup...");
+          cleanup(true);
+          resolve();
+        }, 3e3);
+        server.close((err) => {
+          clearTimeout(timeoutId);
+          if (err) {
+            logError("Error during server shutdown:", err);
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+      });
+    }
+    try {
+      await Promise.race([
+        closingPromise,
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Shutdown timeout")), 5e3)
+        )
+      ]);
+    } catch (err) {
+      logError("Shutdown error:", err);
+      cleanup(true);
     }
+    if (exitProcess) {
+      setTimeout(() => process.exit(0), 100);
+    }
+  };
+  if (enableSignalHandlers) {
+    const onSignal = () => {
+      void shutdown(true);
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+    signalHandlers.push({ event: "SIGINT", handler: onSignal });
+    signalHandlers.push({ event: "SIGTERM", handler: onSignal });
   }
-})();
-var native = nativeBinding;
+  await new Promise((resolve) => {
+    server.listen(port, () => resolve());
+  });
+  const address = server.address();
+  const actualPort = address && typeof address === "object" && address?.port ? address.port : port;
+  logInfo(`Ionify Dev Server (Phase 2) at http://localhost:${actualPort}`);
+  logInfo(`HMR listening at /__ionify_hmr (SSE)`);
+  return {
+    server,
+    port: actualPort,
+    close: async () => {
+      await shutdown(false);
+    }
+  };
+}
 
 // src/cli/commands/analyze.ts
+import fs8 from "fs";
+import path10 from "path";
 function readGraphFromDisk(root) {
-  const file = path2.join(root, ".ionify", "graph.json");
-  if (!fs2.existsSync(file)) return null;
+  const file = path10.join(root, ".ionify", "graph.json");
+  if (!fs8.existsSync(file)) return null;
   try {
-    const raw = fs2.readFileSync(file, "utf8");
+    const raw = fs8.readFileSync(file, "utf8");
     const snapshot = JSON.parse(raw);
     if (snapshot?.version !== 1 || !snapshot?.nodes) return null;
     return Object.entries(snapshot.nodes).map(([id, node]) => ({
@@ -170,23 +2533,971 @@ async function runAnalyzeCommand(options = {}) {
   }
 }
 
+// src/cli/commands/build.ts
+import fs10 from "fs";
+import path12 from "path";
+
+// src/cli/utils/optimization-level.ts
+function getOptimizationPreset(level) {
+  switch (level) {
+    case 0:
+      return {
+        minifier: "swc",
+        treeshake: {
+          mode: "off",
+          include: [],
+          exclude: []
+        },
+        scopeHoist: {
+          enable: false,
+          inlineFunctions: false,
+          constantFolding: false,
+          combineVariables: false
+        }
+      };
+    case 1:
+      return {
+        minifier: "oxc",
+        treeshake: {
+          mode: "safe",
+          include: [],
+          exclude: []
+        },
+        scopeHoist: {
+          enable: true,
+          inlineFunctions: true,
+          constantFolding: false,
+          combineVariables: false
+        }
+      };
+    case 2:
+      return {
+        minifier: "oxc",
+        treeshake: {
+          mode: "safe",
+          include: [],
+          exclude: []
+        },
+        scopeHoist: {
+          enable: true,
+          inlineFunctions: true,
+          constantFolding: true,
+          combineVariables: true
+        }
+      };
+    case 3:
+      return {
+        minifier: "oxc",
+        treeshake: {
+          mode: "aggressive",
+          include: [],
+          exclude: []
+        },
+        scopeHoist: {
+          enable: true,
+          inlineFunctions: true,
+          constantFolding: true,
+          combineVariables: true
+        }
+      };
+    default:
+      return getOptimizationPreset(2);
+  }
+}
+function resolveOptimizationLevel(configLevel, options = {}) {
+  if (options.cliLevel !== void 0) {
+    const parsed = typeof options.cliLevel === "number" ? options.cliLevel : parseInt(options.cliLevel, 10);
+    if ([0, 1, 2, 3].includes(parsed)) {
+      return parsed;
+    }
+  }
+  if (options.envLevel) {
+    const parsed = parseInt(options.envLevel, 10);
+    if ([0, 1, 2, 3].includes(parsed)) {
+      return parsed;
+    }
+  }
+  if (configLevel !== void 0 && [0, 1, 2, 3].includes(configLevel)) {
+    return configLevel;
+  }
+  return null;
+}
+
+// src/core/bundler.ts
+import fs9 from "fs";
+import path11 from "path";
+import crypto3 from "crypto";
+function readGraphSnapshot() {
+  if (native?.graphLoadMap) {
+    try {
+      const nativeMap = native.graphLoadMap();
+      if (nativeMap && Object.keys(nativeMap).length > 0) {
+        return Object.values(nativeMap).map((node) => ({
+          id: node.id,
+          hash: node.hash,
+          deps: node.deps || [],
+          dynamicDeps: node.dynamicDeps || [],
+          kind: node.kind
+        }));
+      }
+    } catch (err) {
+      logWarn(`Failed to load native graph: ${String(err)}`);
+    }
+  }
+  const file = path11.join(process.cwd(), ".ionify", "graph.json");
+  if (!fs9.existsSync(file)) return [];
+  try {
+    const raw = fs9.readFileSync(file, "utf8");
+    const snapshot = JSON.parse(raw);
+    if (snapshot?.version !== 1 || !snapshot?.nodes) return [];
+    return Object.entries(snapshot.nodes).map(([id, node]) => ({
+      id,
+      hash: typeof node.hash === "string" ? node.hash : null,
+      deps: Array.isArray(node.deps) ? node.deps : []
+    }));
+  } catch (err) {
+    logWarn(`Failed to read graph snapshot: ${String(err)}`);
+    return [];
+  }
+}
+var JS_EXTENSIONS2 = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"]);
+var CSS_EXTENSIONS = /* @__PURE__ */ new Set([".css"]);
+function classifyModuleKind(id) {
+  const ext = path11.extname(id).toLowerCase();
+  if (CSS_EXTENSIONS.has(ext)) return "css";
+  if (JS_EXTENSIONS2.has(ext)) return "js";
+  return "asset";
+}
+var isNonEmptyString = (value) => typeof value === "string" && value.length > 0;
+var toPosix = (p) => p.split(path11.sep).join("/");
+function minifyCss(input) {
+  return input.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/\s*([{};:,])\s*/g, "$1").trim();
+}
+function orderCssModules(chunk) {
+  const cssModules = chunk.modules.filter((m) => m.kind === "css");
+  const cssSet = new Set(cssModules.map((m) => m.id));
+  const adj = /* @__PURE__ */ new Map();
+  for (const mod of cssModules) {
+    const deps = [...mod.deps || [], ...mod.dynamicDeps || []].filter((d) => cssSet.has(d));
+    deps.sort();
+    adj.set(mod.id, deps);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const temp = /* @__PURE__ */ new Set();
+  const ordered = [];
+  const dfs = (id) => {
+    if (visited.has(id) || temp.has(id)) return;
+    temp.add(id);
+    const edges = adj.get(id) || [];
+    for (const dep of edges) dfs(dep);
+    temp.delete(id);
+    visited.add(id);
+    ordered.push(id);
+  };
+  const sorted = [...cssModules.map((m) => m.id)].sort();
+  for (const id of sorted) {
+    dfs(id);
+  }
+  return ordered;
+}
+function normalizeModules(rawModules) {
+  const modules = [];
+  for (const raw of rawModules) {
+    if (typeof raw === "string") {
+      modules.push({
+        id: raw,
+        hash: null,
+        kind: classifyModuleKind(raw),
+        deps: [],
+        dynamicDeps: []
+      });
+      continue;
+    }
+    if (!raw || typeof raw !== "object") continue;
+    const id = typeof raw.id === "string" ? raw.id : null;
+    if (!id) continue;
+    const rawKind = typeof raw.kind === "string" ? raw.kind : classifyModuleKind(id);
+    const kind = rawKind === "css" || rawKind === "asset" ? rawKind : "js";
+    const deps = Array.isArray(raw.deps) ? raw.deps.filter(isNonEmptyString) : [];
+    const dynamicSource = Array.isArray(raw.dynamicDeps) ? raw.dynamicDeps : Array.isArray(raw.dynamic_deps) ? raw.dynamic_deps : [];
+    const dynamicDeps = dynamicSource.filter(isNonEmptyString);
+    const hash = typeof raw.hash === "string" && raw.hash.length ? raw.hash : null;
+    modules.push({
+      id,
+      hash,
+      kind,
+      deps,
+      dynamicDeps
+    });
+  }
+  return modules;
+}
+function normalizePlan(plan) {
+  const entries = Array.isArray(plan?.entries) ? Array.from(new Set(plan.entries.filter(isNonEmptyString))) : [];
+  const rawChunks = Array.isArray(plan?.chunks) ? plan.chunks : [];
+  const normalizedChunks = rawChunks.map((chunk, index) => {
+    const id = typeof chunk?.id === "string" && chunk.id.length ? chunk.id : `chunk-${index}`;
+    const modules = normalizeModules(Array.isArray(chunk?.modules) ? chunk.modules : []);
+    const consumersRaw = Array.isArray(chunk?.consumers) ? chunk.consumers.filter(isNonEmptyString) : null;
+    const cssRaw = Array.isArray(chunk?.css) ? chunk.css.filter(isNonEmptyString) : null;
+    const assetsRaw = Array.isArray(chunk?.assets) ? chunk.assets.filter(isNonEmptyString) : null;
+    const consumers = consumersRaw && consumersRaw.length ? Array.from(new Set(consumersRaw)) : [...entries];
+    const inferredCss = cssRaw && cssRaw.length ? cssRaw : modules.filter((m) => m.kind === "css").map((m) => m.id);
+    const inferredAssets = assetsRaw && assetsRaw.length ? assetsRaw : modules.filter((m) => m.kind === "asset").map((m) => m.id);
+    return {
+      id,
+      modules,
+      entry: chunk?.entry === true,
+      shared: chunk?.shared === true,
+      consumers,
+      css: inferredCss,
+      assets: inferredAssets
+    };
+  });
+  return {
+    entries,
+    chunks: normalizedChunks
+  };
+}
+function fallbackPlan(entries) {
+  const nodes = readGraphSnapshot();
+  logInfo(`[Fallback] modules: ${nodes.length}, entries: ${entries?.length ?? 0}`);
+  logInfo(`[Fallback] module IDs: ${nodes.map((n) => n.id).join(", ")}`);
+  logInfo(`[Fallback] entry IDs: ${entries?.join(", ") ?? "none"}`);
+  const modules = nodes.map((n) => n.id);
+  const deps = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    for (const dep of node.deps) deps.add(dep);
+  }
+  let finalEntries = entries && entries.length ? [...entries] : modules.filter((m) => !deps.has(m));
+  if (!finalEntries.length && modules.length) {
+    finalEntries = [modules[0]];
+  }
+  const nodeMap = new Map(nodes.map((node) => [node.id, node]));
+  const planModules = modules.map((id) => {
+    const node = nodeMap.get(id);
+    return {
+      id,
+      hash: node?.hash ?? null,
+      kind: node?.kind ?? classifyModuleKind(id),
+      deps: node?.deps ?? [],
+      dynamicDeps: node?.dynamicDeps ?? []
+    };
+  });
+  const css = planModules.filter((m) => m.kind === "css").map((m) => m.id);
+  const assets = planModules.filter((m) => m.kind === "asset").map((m) => m.id);
+  return normalizePlan({
+    entries: finalEntries,
+    chunks: [
+      {
+        id: "chunk-main",
+        modules: planModules,
+        entry: true,
+        shared: false,
+        consumers: finalEntries,
+        css,
+        assets
+      }
+    ]
+  });
+}
+async function generateBuildPlan(entries, versionInputs) {
+  const version = versionInputs ? computeGraphVersion(versionInputs) : void 0;
+  logInfo(`Graph version: ${version || "default"}`);
+  const graphDbPath = path11.join(process.cwd(), ".ionify", "graph.db");
+  ensureNativeGraph(graphDbPath, version);
+  let moduleCount = 0;
+  if (native?.graphLoadMap) {
+    try {
+      const persistedGraph = native.graphLoadMap();
+      const graphSize = persistedGraph ? Object.keys(persistedGraph).length : 0;
+      moduleCount = graphSize;
+      logInfo(`Native graph loaded: ${graphSize} modules`);
+      if (persistedGraph && graphSize > 0) {
+        logInfo(`Loaded persisted graph with ${graphSize} modules`);
+      }
+    } catch (err) {
+      logWarn(`Failed to load persisted graph: ${String(err)}`);
+    }
+  } else {
+    logWarn(`graphLoadMap not available, native binding: ${!!native}`);
+  }
+  if (moduleCount === 0 && entries?.length && native) {
+    logWarn(`[Build] Graph is empty \u2014 rebuilding dependency graph from entries...`);
+    const queue = [...entries];
+    const seen = new Set(queue);
+    while (queue.length) {
+      const file = queue.shift();
+      if (!fs9.existsSync(file)) continue;
+      const code = fs9.readFileSync(file, "utf8");
+      let hash = getCacheKey(code);
+      let specs = [];
+      if (native.parseModuleIr) {
+        try {
+          const ir = native.parseModuleIr(file, code);
+          hash = ir.hash;
+          specs = ir.dependencies.map((d) => d.specifier);
+        } catch {
+          specs = extractImports(code, file);
+        }
+      } else {
+        specs = extractImports(code, file);
+      }
+      const depsAbs = resolveImports(specs, file);
+      if (typeof native.graphRecord === "function") {
+        native.graphRecord(file, hash, depsAbs, [], "module");
+      } else if (typeof native.recordFile === "function") {
+        native.recordFile(file, hash, depsAbs, [], "module");
+      }
+      for (const dep of depsAbs) {
+        if (!seen.has(dep)) {
+          seen.add(dep);
+          queue.push(dep);
+        }
+      }
+    }
+    try {
+      if (typeof native.loadModulesCount === "function") {
+        moduleCount = native.loadModulesCount() ?? moduleCount;
+      } else if (native.graphLoadMap) {
+        const persistedGraph = native.graphLoadMap();
+        moduleCount = persistedGraph ? Object.keys(persistedGraph).length : moduleCount;
+      }
+    } catch {
+    }
+    logInfo(`[Build] Dependency graph rebuilt: ${moduleCount} modules`);
+  }
+  if (native?.plannerPlanBuild) {
+    try {
+      const start = Date.now();
+      logInfo(`[Planner] Calling native plannerPlanBuild with ${entries?.length ?? 0} entries`);
+      const plan = native.plannerPlanBuild(entries ?? []);
+      logInfo(`[Planner] Native plan returned: ${plan.entries.length} entries, ${plan.chunks.length} chunks in ${Date.now() - start}ms`);
+      return normalizePlan(plan);
+    } catch (err) {
+      logWarn(`plannerPlanBuild failed, falling back to JS planner: ${String(err)}`);
+    }
+  }
+  return fallbackPlan(entries);
+}
+async function writeBuildManifest(outputDir, plan, artifacts) {
+  const filesByChunk = /* @__PURE__ */ new Map();
+  for (const artifact of artifacts) {
+    filesByChunk.set(artifact.id, artifact.files);
+  }
+  const manifest = {
+    entries: plan.entries,
+    chunks: plan.chunks.map((chunk) => ({
+      id: chunk.id,
+      entry: chunk.entry,
+      shared: chunk.shared,
+      consumers: chunk.consumers,
+      modules: chunk.modules.map((mod) => ({
+        id: mod.id,
+        kind: mod.kind,
+        deps: mod.deps,
+        dynamicDeps: mod.dynamicDeps
+      })),
+      files: filesByChunk.get(chunk.id) ?? { js: [], css: [], assets: [] }
+    }))
+  };
+  const dir = path11.resolve(outputDir);
+  await fs9.promises.mkdir(dir, { recursive: true });
+  const file = path11.join(dir, "manifest.json");
+  await fs9.promises.writeFile(file, JSON.stringify(manifest, null, 2), "utf8");
+}
+async function emitChunks(outputDir, plan, moduleOutputs, opts) {
+  if (!native?.buildChunks) {
+    logWarn("Native buildChunks binding is not available; using JS fallback emitter.");
+    const rawArtifacts2 = buildJsFallbackArtifacts(plan, moduleOutputs);
+    return emitChunksFromArtifacts(outputDir, plan, moduleOutputs, rawArtifacts2);
+  }
+  const start = Date.now();
+  const rawArtifacts = native.buildChunks(plan, opts?.casRoot, opts?.versionHash) ?? [];
+  logInfo(`[Bundler] buildChunks completed in ${Date.now() - start}ms (native)`);
+  return emitChunksFromArtifacts(outputDir, plan, moduleOutputs, rawArtifacts);
+}
+function buildJsFallbackArtifacts(plan, moduleOutputs) {
+  const artifacts = [];
+  for (const chunk of plan.chunks) {
+    const jsParts = [];
+    const assets = [];
+    for (const mod of chunk.modules) {
+      const output = moduleOutputs.get(mod.id);
+      if (output?.type === "js") {
+        jsParts.push(`// ${mod.id}
+${output.code}`);
+      }
+    }
+    for (const assetPath of chunk.assets) {
+      try {
+        const data = fs9.readFileSync(assetPath);
+        if (data.length < 4096) {
+          const mime = "application/octet-stream";
+          const inline = `data:${mime};base64,${data.toString("base64")}`;
+          jsParts.push(`// ${assetPath}
+export const __ionify_asset = "${inline}";`);
+          continue;
+        }
+        const hash = crypto3.createHash("sha256").update(data).digest("hex").slice(0, 16);
+        const ext = path11.extname(assetPath) || ".bin";
+        const fileName = `assets/${hash}${ext}`;
+        assets.push({
+          source: assetPath,
+          file_name: fileName
+        });
+      } catch {
+        const fileName = path11.basename(assetPath) || "asset";
+        assets.push({
+          source: assetPath,
+          file_name: fileName
+        });
+      }
+    }
+    const code = jsParts.length ? jsParts.join("\n\n") : `// Ionify JS fallback for ${chunk.id}
+export default {};`;
+    artifacts.push({
+      id: chunk.id,
+      file_name: `${chunk.id}.fallback.js`,
+      code,
+      map: null,
+      assets,
+      code_bytes: Buffer.byteLength(code, "utf8"),
+      map_bytes: 0
+    });
+  }
+  return artifacts;
+}
+function normalizeNativeArtifact(raw) {
+  const id = raw.id;
+  if (!id) {
+    throw new Error("Native artifact missing id");
+  }
+  const file_name = raw.file_name ?? `${id.replace(/::/g, ".")}.native.js`;
+  const code = raw.code ?? "";
+  const map = raw.map ?? null;
+  const code_bytes = typeof raw.code_bytes === "number" ? raw.code_bytes : Buffer.byteLength(code, "utf8");
+  const map_bytes = typeof raw.map_bytes === "number" ? raw.map_bytes : map ? Buffer.byteLength(map, "utf8") : 0;
+  const assets = Array.isArray(raw.assets) ? raw.assets.map((asset) => ({
+    source: asset.source,
+    file_name: asset.file_name ?? asset.fileName ?? path11.basename(asset.source ?? "asset")
+  })) : [];
+  return { id, file_name, code, map, assets, code_bytes, map_bytes };
+}
+async function emitChunksFromArtifacts(outputDir, plan, moduleOutputs, rawArtifacts) {
+  const chunkDir = path11.join(outputDir, "chunks");
+  await fs9.promises.mkdir(chunkDir, { recursive: true });
+  const assetsDir = path11.join(outputDir, "assets");
+  await fs9.promises.mkdir(assetsDir, { recursive: true });
+  const enableSourceMaps = process.env.IONIFY_SOURCEMAPS === "true";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const raw of rawArtifacts) {
+    const artifact = normalizeNativeArtifact(raw);
+    const baseId = artifact.id.split("::")[0] ?? artifact.id;
+    const bucket = grouped.get(baseId);
+    if (bucket) bucket.push(artifact);
+    else grouped.set(baseId, [artifact]);
+  }
+  const buildStats = {};
+  const results = [];
+  for (const chunk of plan.chunks) {
+    const artifacts = grouped.get(chunk.id);
+    if (!artifacts || !artifacts.length) {
+      throw new Error(`Native bundler did not emit artifacts for ${chunk.id}`);
+    }
+    const chunkOutDir = path11.join(chunkDir, chunk.id);
+    await fs9.promises.mkdir(chunkOutDir, { recursive: true });
+    artifacts.sort((a, b) => {
+      if (a.id === chunk.id) return -1;
+      if (b.id === chunk.id) return 1;
+      return a.id.localeCompare(b.id);
+    });
+    const jsFiles = [];
+    const cssFiles = [];
+    const assetFiles = [];
+    const assetWritten = /* @__PURE__ */ new Set();
+    const copyAssets = async (assets) => {
+      for (const asset of assets) {
+        if (!asset?.source) continue;
+        const relName = asset.file_name ?? path11.basename(asset.source);
+        const assetFile = path11.join(outputDir, relName);
+        if (assetWritten.has(assetFile)) continue;
+        try {
+          const data = await fs9.promises.readFile(asset.source);
+          await fs9.promises.mkdir(path11.dirname(assetFile), { recursive: true });
+          await fs9.promises.writeFile(assetFile, data);
+          const rel = toPosix(path11.relative(outputDir, assetFile));
+          buildStats[rel] = {
+            bytes: data.length,
+            emitter: "native",
+            type: "asset"
+          };
+          assetFiles.push(rel);
+          assetWritten.add(assetFile);
+        } catch (err) {
+          logWarn(`Failed to emit asset ${asset.source}: ${String(err)}`);
+        }
+      }
+    };
+    const cssOrder = orderCssModules(chunk);
+    let cssFileRel = null;
+    if (cssOrder.length) {
+      const seenCss = /* @__PURE__ */ new Set();
+      const cssPieces = [];
+      for (const cssPath of cssOrder) {
+        let cssSource = moduleOutputs.get(cssPath)?.code;
+        if (!cssSource && fs9.existsSync(cssPath)) {
+          try {
+            cssSource = await fs9.promises.readFile(cssPath, "utf8");
+          } catch (err) {
+            logWarn(`Failed to read CSS source ${cssPath}: ${String(err)}`);
+          }
+        }
+        if (!cssSource) continue;
+        const minified = minifyCss(cssSource);
+        if (!minified.length) continue;
+        const key = getCacheKey(minified);
+        if (seenCss.has(key)) continue;
+        seenCss.add(key);
+        cssPieces.push(minified);
+      }
+      if (cssPieces.length) {
+        const combinedCss = cssPieces.join("\n");
+        const cssHash = getCacheKey(combinedCss).slice(0, 8);
+        const cssFileName = `assets/${chunk.id}.${cssHash}.css`;
+        const cssFilePath = path11.join(outputDir, cssFileName);
+        await fs9.promises.writeFile(cssFilePath, combinedCss, "utf8");
+        cssFileRel = toPosix(path11.relative(outputDir, cssFilePath));
+        buildStats[cssFileRel] = {
+          bytes: Buffer.byteLength(combinedCss),
+          emitter: "native",
+          type: "css"
+        };
+        cssFiles.push(cssFileRel);
+      }
+    }
+    for (const artifact of artifacts) {
+      const nativeFile = path11.join(chunkOutDir, artifact.file_name);
+      let nativeCode = artifact.code;
+      if (cssFileRel) {
+        const absCss = path11.join(outputDir, cssFileRel);
+        const relCss = toPosix(path11.relative(path11.dirname(nativeFile), absCss));
+        const inject = `(()=>{const url=new URL(${JSON.stringify(
+          relCss
+        )},import.meta.url).toString();if(typeof document!=="undefined"&&!document.querySelector('link[data-ionify-css="'+url+'"]')){const l=document.createElement("link");l.rel="stylesheet";l.href=url;l.setAttribute("data-ionify-css",url);document.head.appendChild(l);}})();`;
+        nativeCode = `${inject}
+${nativeCode}`;
+      }
+      if (enableSourceMaps && artifact.map) {
+        const mapFile = `${nativeFile}.map`;
+        await fs9.promises.writeFile(mapFile, artifact.map, "utf8");
+        nativeCode = `${nativeCode}
+//# sourceMappingURL=${path11.basename(mapFile)}`;
+        const relMap = toPosix(path11.relative(outputDir, mapFile));
+        buildStats[relMap] = {
+          bytes: artifact.map_bytes,
+          emitter: "native",
+          type: "map"
+        };
+        jsFiles.push(relMap);
+      }
+      await fs9.promises.writeFile(nativeFile, nativeCode, "utf8");
+      const relNative = toPosix(path11.relative(outputDir, nativeFile));
+      buildStats[relNative] = {
+        bytes: artifact.code_bytes,
+        emitter: "native",
+        type: "js"
+      };
+      jsFiles.push(relNative);
+      await copyAssets(artifact.assets);
+    }
+    if (chunk.css.length) {
+      const seenCss = /* @__PURE__ */ new Set();
+      const cssSources = [];
+      for (const cssPath of chunk.css) {
+        if (!seenCss.add(cssPath)) continue;
+        const output = moduleOutputs.get(cssPath);
+        if (output?.type === "css") {
+          cssSources.push(output.code);
+        } else if (fs9.existsSync(cssPath)) {
+          try {
+            cssSources.push(await fs9.promises.readFile(cssPath, "utf8"));
+          } catch (err) {
+            logWarn(`Failed to read CSS source ${cssPath}: ${String(err)}`);
+          }
+        }
+      }
+      if (cssSources.length) {
+        const combinedCss = cssSources.join("\n\n");
+        const cssHash = crypto3.createHash("sha256").update(combinedCss).digest("hex").slice(0, 8);
+        const cssFileName = `${chunk.id}.${cssHash}.native.css`;
+        const cssFilePath = path11.join(chunkOutDir, cssFileName);
+        await fs9.promises.writeFile(cssFilePath, combinedCss, "utf8");
+        const relCss = path11.relative(outputDir, cssFilePath);
+        buildStats[relCss] = {
+          bytes: Buffer.byteLength(combinedCss),
+          emitter: "native",
+          type: "css"
+        };
+        cssFiles.push(relCss);
+      }
+    }
+    results.push({
+      id: chunk.id,
+      files: {
+        js: jsFiles,
+        css: cssFiles,
+        assets: assetFiles
+      }
+    });
+  }
+  return { artifacts: results, stats: buildStats };
+}
+async function writeAssetsManifest(outputDir, artifacts) {
+  const dir = path11.resolve(outputDir);
+  await fs9.promises.mkdir(dir, { recursive: true });
+  const file = path11.join(dir, "manifest.assets.json");
+  const payload = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    chunks: artifacts
+  };
+  await fs9.promises.writeFile(file, JSON.stringify(payload, null, 2), "utf8");
+}
+
+// src/core/worker/pool.ts
+import { Worker } from "worker_threads";
+import os from "os";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var workerPath = fileURLToPath3(new URL("./worker.cjs", import.meta.url));
+var TransformWorkerPool = class {
+  workers = [];
+  queue = [];
+  active = /* @__PURE__ */ new Map();
+  callbacks = /* @__PURE__ */ new Map();
+  waiters = [];
+  pendingBytes = 0;
+  closed = false;
+  size;
+  maxQueueBytes;
+  constructor(options = {}) {
+    const cpuDefault = Math.max(1, os.cpus().length - 1);
+    this.size = Math.max(1, options.size ?? cpuDefault);
+    this.maxQueueBytes = options.maxQueueBytes;
+    for (let i = 0; i < this.size; i++) {
+      this.spawnWorker();
+    }
+  }
+  spawnWorker() {
+    const worker = new Worker(workerPath, { env: process.env });
+    const id = worker.threadId;
+    worker.on("message", (message) => {
+      const item = this.active.get(id);
+      if (item) {
+        this.active.delete(id);
+        this.pendingBytes -= item.size;
+        this.resolveWaiters();
+      }
+      const cb = message ? this.callbacks.get(message.id) : void 0;
+      if (message && cb) cb(message);
+      if (message) this.callbacks.delete(message.id);
+      this.dequeue(worker);
+    });
+    worker.on("error", (err) => {
+      logWarn(`Transform worker error: ${String(err)}`);
+      const item = this.active.get(id);
+      if (item) {
+        this.active.delete(id);
+        this.queue.unshift(item);
+      }
+      this.spawnWorker();
+    });
+    worker.on("exit", (code) => {
+      const item = this.active.get(id);
+      if (item) {
+        this.active.delete(id);
+        this.queue.unshift(item);
+      }
+      if (!this.closed && code !== 0) {
+        logWarn(`Transform worker exited unexpectedly (${code}), respawning`);
+        this.spawnWorker();
+      }
+    });
+    this.workers.push(worker);
+  }
+  dequeue(worker) {
+    if (this.queue.length === 0) return;
+    const item = this.queue.shift();
+    this.active.set(worker.threadId, item);
+    worker.postMessage(item.job);
+  }
+  resolveWaiters() {
+    if (!this.maxQueueBytes) return;
+    while (this.waiters.length && this.pendingBytes < this.maxQueueBytes) {
+      const resolve = this.waiters.shift();
+      resolve && resolve();
+    }
+  }
+  async run(job) {
+    if (this.closed) {
+      throw new Error("Worker pool already closed");
+    }
+    const size = Buffer.byteLength(job.code, "utf8");
+    if (this.maxQueueBytes) {
+      while (this.pendingBytes + size > this.maxQueueBytes) {
+        await new Promise((resolve) => this.waiters.push(resolve));
+        await new Promise((r) => setTimeout(r, 50 + Math.random() * 100));
+      }
+    }
+    this.pendingBytes += size;
+    return new Promise((resolve) => {
+      this.callbacks.set(job.id, resolve);
+      const idleWorker = this.workers.find((w) => !this.active.has(w.threadId));
+      const item = { job, size };
+      if (idleWorker) {
+        this.active.set(idleWorker.threadId, item);
+        idleWorker.postMessage(job);
+      } else {
+        this.queue.push(item);
+      }
+    });
+  }
+  async runMany(jobs) {
+    const resultMap = /* @__PURE__ */ new Map();
+    await Promise.all(
+      jobs.map(async (job) => {
+        const res = await this.run(job);
+        resultMap.set(job.id, res);
+      })
+    );
+    return jobs.map((job) => resultMap.get(job.id));
+  }
+  async close() {
+    this.closed = true;
+    await Promise.all(this.workers.map((worker) => worker.terminate()));
+    this.workers = [];
+    this.queue = [];
+    this.active.clear();
+    this.callbacks.clear();
+    this.waiters.forEach((resolve) => resolve());
+    this.waiters = [];
+    this.pendingBytes = 0;
+  }
+  async drain() {
+    while (!this.closed && (this.queue.length || this.active.size)) {
+      await new Promise((r) => setTimeout(r, 100));
+    }
+  }
+};
+
+// src/cli/commands/build.ts
+async function runBuildCommand(options = {}) {
+  try {
+    const config = await loadIonifyConfig();
+    const optLevel = resolveOptimizationLevel(config?.optimizationLevel, {
+      cliLevel: options.level,
+      envLevel: process.env.IONIFY_OPTIMIZATION_LEVEL
+    });
+    let minifier;
+    const parserMode = resolveParser(config, { envMode: process.env.IONIFY_PARSER });
+    let treeshake;
+    let scopeHoist;
+    if (optLevel !== null) {
+      const preset = getOptimizationPreset(optLevel);
+      minifier = preset.minifier;
+      treeshake = preset.treeshake;
+      scopeHoist = preset.scopeHoist;
+      logInfo(`Using optimization level ${optLevel} (preset)`);
+    } else {
+      minifier = resolveMinifier(config, { envVar: process.env.IONIFY_MINIFIER });
+      treeshake = resolveTreeshake(config?.treeshake, {
+        envMode: process.env.IONIFY_TREESHAKE,
+        includeEnv: process.env.IONIFY_TREESHAKE_INCLUDE,
+        excludeEnv: process.env.IONIFY_TREESHAKE_EXCLUDE
+      });
+      scopeHoist = resolveScopeHoist(config?.scopeHoist, {
+        envMode: process.env.IONIFY_SCOPE_HOIST,
+        inlineEnv: process.env.IONIFY_SCOPE_HOIST_INLINE,
+        constantEnv: process.env.IONIFY_SCOPE_HOIST_CONST,
+        combineEnv: process.env.IONIFY_SCOPE_HOIST_COMBINE
+      });
+    }
+    applyMinifierEnv(minifier);
+    applyParserEnv(parserMode);
+    applyTreeshakeEnv(treeshake);
+    applyScopeHoistEnv(scopeHoist);
+    const entries = config?.entry ? [config.entry.startsWith("/") ? path12.join(process.cwd(), config.entry) : path12.resolve(process.cwd(), config.entry)] : void 0;
+    if (entries) {
+      logInfo(`Build entries: ${entries.join(", ")}`);
+    } else {
+      logInfo(`No entries in config, planner will infer from graph`);
+    }
+    const pluginNames = Array.isArray(config?.plugins) ? config.plugins.map((p) => typeof p === "string" ? p : p?.name).filter((name) => typeof name === "string" && name.length > 0) : void 0;
+    const rawVersionInputs = {
+      parserMode,
+      minifier,
+      treeshake,
+      scopeHoist,
+      plugins: pluginNames,
+      entry: entries ?? null,
+      cssOptions: config?.css,
+      assetOptions: config?.assets ?? config?.asset
+    };
+    const configHash = computeGraphVersion(rawVersionInputs);
+    logInfo(`[Build] Version hash: ${configHash}`);
+    process.env.IONIFY_CONFIG_HASH = configHash;
+    if (native?.initAstCache) {
+      const versionHash = JSON.stringify(rawVersionInputs);
+      native.initAstCache(versionHash);
+      logInfo(`AST cache initialized with version hash`);
+    }
+    const plan = await generateBuildPlan(entries, rawVersionInputs);
+    const outDir = options.outDir || "dist";
+    const moduleHashes = /* @__PURE__ */ new Map();
+    for (const chunk of plan.chunks) {
+      for (const mod of chunk.modules) {
+        if (mod.hash) {
+          moduleHashes.set(mod.id, mod.hash);
+        }
+      }
+    }
+    const uniqueModules = /* @__PURE__ */ new Set();
+    for (const chunk of plan.chunks) {
+      for (const mod of chunk.modules) uniqueModules.add(mod.id);
+    }
+    const moduleOutputs = /* @__PURE__ */ new Map();
+    const pool = new TransformWorkerPool();
+    try {
+      const jobs = Array.from(uniqueModules).filter((filePath) => fs10.existsSync(filePath)).map((filePath) => {
+        const code = fs10.readFileSync(filePath, "utf8");
+        const sourceHash = getCacheKey(code);
+        const moduleHash = moduleHashes.get(filePath) ?? sourceHash;
+        const cacheKey = getCacheKey(`build-worker:v1:${path12.extname(filePath)}:${moduleHash}:${filePath}`);
+        const cached = readCache(cacheKey);
+        if (cached) {
+          try {
+            const parsed = JSON.parse(cached.toString("utf8"));
+            if (parsed?.code) {
+              const transformedHash = getCacheKey(parsed.code);
+              moduleHashes.set(filePath, transformedHash);
+              const casRoot2 = path12.join(process.cwd(), ".ionify", "cas");
+              const cacheDir = getCasArtifactPath(casRoot2, configHash, transformedHash);
+              if (!fs10.existsSync(path12.join(cacheDir, "transformed.js"))) {
+                fs10.mkdirSync(cacheDir, { recursive: true });
+                fs10.writeFileSync(path12.join(cacheDir, "transformed.js"), parsed.code, "utf8");
+                if (parsed.map) {
+                  fs10.writeFileSync(path12.join(cacheDir, "transformed.js.map"), parsed.map, "utf8");
+                }
+              }
+              moduleOutputs.set(filePath, { code: parsed.code, type: parsed.type ?? "js" });
+              return null;
+            }
+          } catch {
+          }
+        }
+        return {
+          id: filePath,
+          filePath,
+          ext: path12.extname(filePath),
+          code,
+          cacheKey
+        };
+      }).filter((job) => !!job);
+      const results = await pool.runMany(
+        jobs.map((job) => ({
+          id: job.id,
+          filePath: job.filePath,
+          ext: job.ext,
+          code: job.code
+        }))
+      );
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        const job = jobs[i];
+        if (result.error) {
+          throw new Error(`Transform failed for ${result.filePath}: ${result.error}`);
+        }
+        const payload = JSON.stringify({ code: result.code, map: result.map, type: result.type });
+        writeCache(job.cacheKey, Buffer.from(payload));
+        const transformedHash = getCacheKey(result.code);
+        const moduleHash = transformedHash;
+        const casRoot2 = path12.join(process.cwd(), ".ionify", "cas");
+        const versionHash = configHash;
+        const cacheDir = getCasArtifactPath(casRoot2, versionHash, moduleHash);
+        fs10.mkdirSync(cacheDir, { recursive: true });
+        fs10.writeFileSync(path12.join(cacheDir, "transformed.js"), result.code, "utf8");
+        if (result.map) {
+          fs10.writeFileSync(path12.join(cacheDir, "transformed.js.map"), result.map, "utf8");
+        }
+        moduleHashes.set(job.filePath, moduleHash);
+        for (const chunk of plan.chunks) {
+          for (const mod of chunk.modules) {
+            if (mod.id === job.filePath) {
+              mod.hash = moduleHash;
+            }
+          }
+        }
+        moduleOutputs.set(result.filePath, { code: result.code, type: result.type });
+      }
+    } finally {
+      await pool.close();
+    }
+    for (const chunk of plan.chunks) {
+      for (const mod of chunk.modules) {
+        const updatedHash = moduleHashes.get(mod.id);
+        if (updatedHash) {
+          mod.hash = updatedHash;
+        }
+      }
+    }
+    const absOutDir = path12.resolve(outDir);
+    const casRoot = path12.join(process.cwd(), ".ionify", "cas");
+    const { artifacts, stats } = await emitChunks(absOutDir, plan, moduleOutputs, {
+      casRoot,
+      versionHash: configHash
+    });
+    await writeBuildManifest(absOutDir, plan, artifacts);
+    await writeAssetsManifest(absOutDir, artifacts);
+    await fs10.promises.writeFile(
+      path12.join(absOutDir, "build.stats.json"),
+      JSON.stringify(stats, null, 2),
+      "utf8"
+    );
+    logInfo(`Build plan generated \u2192 ${path12.join(absOutDir, "manifest.json")}`);
+    logInfo(`Entries: ${plan.entries.length}, Chunks: ${plan.chunks.length}`);
+    logInfo(`Modules transformed: ${moduleOutputs.size}`);
+  } catch (err) {
+    logError("ionify build failed", err);
+    throw err;
+  }
+}
+
 // src/cli/index.ts
 var program = new Command();
-program.name("ionify").description("Ionify \u2013 Instant, Intelligent, Unified Build Engine").version("0.1.0");
-program.command("dev").description("Start Ionify development server (coming in full release)").option("-p, --port <port>", "Port to run the server on", "5173").action(async () => {
-  logError("Dev server is not available in this release. Stay tuned!");
-  process.exit(1);
+program.name("ionify").description("Ionify \u2013 Instant, Intelligent, Unified Build Engine").version("0.0.1");
+program.command("dev").description("Start Ionify development server").option("-p, --port <port>", "Port to run the server on", "5173").action(async (options) => {
+  try {
+    const port = parseInt(options.port, 10);
+    await startDevServer({ port });
+  } catch (err) {
+    logError("Failed to start dev server", err);
+    process.exit(1);
+  }
 });
-program.command("build").description("Build for production (coming in full release)").option("-o, --outDir <dir>", "Output directory", "dist").option("-l, --level <level>", "Optimization level (0-4)", "3").action(async () => {
-  logError("Build command is not available in this release. Stay tuned!");
-  process.exit(1);
+program.command("build").description("Create production build using Ionify bundler").option("-o, --out-dir <dir>", "Output directory", "dist").action(async (options) => {
+  try {
+    await runBuildCommand({ outDir: options.outDir });
+  } catch {
+    process.exit(1);
+  }
 });
-program.command("analyze").description("Analyze bundle and performance").option("-f, --format <format>", "Output format (json|text)", "text").action(async (options) => {
+program.command("migrate").description("Migrate from Vite/Rollup config (not implemented yet)").action(() => logInfo("Migrate command coming soon..."));
+program.command("analyze").description("Inspect cached dependency graph stats").option("--json", "Output summary as JSON").option("-l, --limit <count>", "Limit list outputs", "10").action(async (options) => {
   try {
-    await runAnalyzeCommand(options);
+    const limit = parseInt(options.limit ?? "10", 10);
+    await runAnalyzeCommand({ json: !!options.json, limit: Number.isFinite(limit) ? limit : 10 });
   } catch (err) {
-    logError(`Analyzer failed: ${err.message}`);
+    logError("Analyzer failed", err);
     process.exit(1);
   }
 });
-program.parse();
+program.parse(process.argv);