@ionify/ionify 0.1.2 → 0.1.4

package/dist/cli/index.js

@@ -8,7 +8,7 @@ import {
   tryBundleNodeModule,
   tryNativeTransform,
   writeCache
-} from "../chunk-GOZUBOYH.js";
+} from "../chunk-QQSYYX7B.js";
 import {
   getCasArtifactPath
 } from "../chunk-X5UIMJDA.js";
@@ -21,7 +21,7 @@ import chalk from "chalk";
 function logInfo(message) {
   console.log(chalk.cyan(`[Ionify] ${message}`));
 }
-function logWarn(message) {
+function logWarn2(message) {
   console.warn(chalk.yellow(`[Ionify] ${message}`));
 }
 function logError(message, err) {
@@ -32,8 +32,8 @@ function logError(message, err) {
 // src/cli/commands/dev.ts
 import http from "http";
 import url from "url";
-import fs7 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path12 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createRequire as createRequire2 } from "module";
 
@@ -447,9 +447,12 @@ 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)
-    );
+    const targets = replacements.filter((rep) => typeof rep === "string" && rep.trim().length > 0).map((rep) => {
+      if (rep.startsWith("/")) {
+        return path2.resolve(baseDir, rep.slice(1));
+      }
+      return path2.isAbsolute(rep) ? rep : path2.resolve(baseDir, rep);
+    });
     if (!targets.length) continue;
     entries.push(createAliasEntry(pattern, targets));
   }
@@ -480,20 +483,41 @@ function loadTsconfigAliases() {
   return cachedTsconfigAliases;
 }
 function resolveFromEntries(entries, specifier) {
+  const debug = process.env.IONIFY_RESOLVE_DEBUG === "1";
   for (const entry of entries) {
     const candidates = entry.resolveCandidates(specifier);
+    if (debug && candidates.length > 0) {
+      console.log(`[RESOLVE] Candidates for ${specifier}:`, candidates);
+    }
     for (const candidate of candidates) {
       const resolved = tryWithExt(candidate);
-      if (resolved) return resolved;
+      if (resolved) {
+        if (debug) console.log(`[RESOLVE] Found: ${resolved}`);
+        return resolved;
+      }
     }
   }
   return null;
 }
 function resolveWithAliases(specifier) {
+  const debug = process.env.IONIFY_RESOLVE_DEBUG === "1";
+  if (debug) {
+    console.log(`[RESOLVE] Trying to resolve: ${specifier}`);
+    console.log(`[RESOLVE] Custom aliases count: ${customAliasEntries.length}`);
+  }
   const custom = resolveFromEntries(customAliasEntries, specifier);
-  if (custom) return custom;
+  if (custom) {
+    if (debug) console.log(`[RESOLVE] \u2705 Resolved via custom alias: ${custom}`);
+    return custom;
+  }
   const tsconfigEntries = loadTsconfigAliases();
-  return resolveFromEntries(tsconfigEntries, specifier);
+  if (debug) console.log(`[RESOLVE] Tsconfig aliases count: ${tsconfigEntries.length}`);
+  const result = resolveFromEntries(tsconfigEntries, specifier);
+  if (debug) {
+    if (result) console.log(`[RESOLVE] \u2705 Resolved via tsconfig: ${result}`);
+    else console.log(`[RESOLVE] \u274C Not resolved`);
+  }
+  return result;
 }
 function configureResolverAliases(aliases, baseDir) {
   customAliasEntries = aliases ? buildAliasEntries(aliases, baseDir) : [];
@@ -569,6 +593,7 @@ var DEFAULT_MAIN_FIELDS = ["module", "main"];
 var ModuleResolver = class {
   options;
   rootDir;
+  metadataByPath = /* @__PURE__ */ new Map();
   constructor(rootDir, options = {}) {
     this.rootDir = rootDir;
     this.options = {
@@ -594,6 +619,9 @@ var ModuleResolver = class {
     }
     return this.resolveBareModule(importSpecifier, importer);
   }
+  getMetadata(resolvedPath) {
+    return this.metadataByPath.get(resolvedPath);
+  }
   resolveAlias(specifier) {
     for (const [alias, target] of Object.entries(this.options.alias)) {
       if (specifier === alias || specifier.startsWith(`${alias}/`)) {
@@ -634,6 +662,33 @@ var ModuleResolver = class {
     return null;
   }
   resolveBareModule(specifier, importer) {
+    const nativeResolved = native?.resolveModule?.(specifier, importer);
+    if (nativeResolved?.kind) {
+      const fsPath = nativeResolved.fsPath ?? nativeResolved.fs_path ?? null;
+      const kind = normalizeResolveKind(nativeResolved.kind);
+      if (kind === "pkg_cjs") {
+        if (fsPath) {
+          this.metadataByPath.set(fsPath, {
+            format: "cjs",
+            needsInterop: true
+          });
+        }
+        if (process.env.IONIFY_DEBUG) {
+          const name = nativeResolved.pkg?.name ?? specifier;
+          console.log(`[resolver] CJS package detected: ${name} (conversion deferred)`);
+        }
+      }
+      if (kind === "pkg_esm" && fsPath) {
+        return fsPath;
+      }
+      if (kind === "pkg_cjs" && fsPath) {
+        return fsPath;
+      }
+      if (kind === "local" && fsPath) {
+        return fsPath;
+      }
+      return null;
+    }
     const parts = specifier.split("/");
     const packageName = parts[0].startsWith("@") ? `${parts[0]}/${parts[1]}` : parts[0];
     const subpath = parts.slice(packageName.startsWith("@") ? 2 : 1).join("/");
@@ -715,6 +770,19 @@ var ModuleResolver = class {
     return null;
   }
 };
+function normalizeResolveKind(kind) {
+  const mapping = {
+    PkgEsm: "pkg_esm",
+    PkgCjs: "pkg_cjs",
+    Builtin: "builtin",
+    Virtual: "virtual",
+    Local: "local"
+  };
+  if (kind in mapping) {
+    return mapping[kind];
+  }
+  return kind.toLowerCase();
+}
 
 // src/core/watcher.ts
 import fs4 from "fs";
@@ -849,17 +917,17 @@ var TransformEngine = class {
     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 { getCacheKey: getCacheKey2 } = await import("../cache-LH24ZR2B.js");
+    const path16 = await import("path");
+    const fs13 = 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 casFile = casDir ? path16.join(casDir, "transformed.js") : null;
+    const casMapFile = casDir ? path16.join(casDir, "transformed.js.map") : null;
     const debug = process.env.IONIFY_DEV_TRANSFORM_CACHE_DEBUG === "1";
     if (this.cacheEnabled) {
       const memHit = transformCache.get(memKey);
@@ -869,10 +937,10 @@ var TransformEngine = class {
         }
         return { code: memHit.transformed, map: memHit.map };
       }
-      if (casFile && fs11.existsSync(casFile)) {
+      if (casFile && fs13.existsSync(casFile)) {
         try {
-          const code = fs11.readFileSync(casFile, "utf8");
-          const map = casMapFile && fs11.existsSync(casMapFile) ? fs11.readFileSync(casMapFile, "utf8") : void 0;
+          const code = fs13.readFileSync(casFile, "utf8");
+          const map = casMapFile && fs13.existsSync(casMapFile) ? fs13.readFileSync(casMapFile, "utf8") : void 0;
           const parsed = { code, map };
           transformCache.set(memKey, {
             hash: moduleHash,
@@ -909,10 +977,10 @@ var TransformEngine = class {
       });
       if (casFile) {
         try {
-          fs11.mkdirSync(path13.dirname(casFile), { recursive: true });
-          fs11.writeFileSync(casFile, result.code, "utf8");
+          fs13.mkdirSync(path16.dirname(casFile), { recursive: true });
+          fs13.writeFileSync(casFile, result.code, "utf8");
           if (result.map && casMapFile) {
-            fs11.writeFileSync(casMapFile, typeof result.map === "string" ? result.map : JSON.stringify(result.map), "utf8");
+            fs13.writeFileSync(casMapFile, typeof result.map === "string" ? result.map : JSON.stringify(result.map), "utf8");
           }
         } catch {
         }
@@ -1048,17 +1116,6 @@ async function compileCss({
   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;
@@ -1083,16 +1140,34 @@ async function compileCss({
     from: filePath,
     map: false
   });
+  const deps = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addDep = (depPath) => {
+    const normalized = depPath.replace(/\\+/g, "/");
+    if (seen.has(normalized)) return;
+    seen.add(normalized);
+    deps.push({ filePath: depPath, kind: "dependency" });
+  };
+  for (const message of result.messages || []) {
+    const anyMsg = message;
+    if (anyMsg?.type === "dependency" && typeof anyMsg.file === "string") {
+      addDep(anyMsg.file);
+    }
+  }
+  const importRe = /@import\s+(?:url\(\s*)?(?:'([^']+)'|"([^"]+)"|([^'"\s)]+))\s*\)?[^;]*;/gi;
+  let match;
+  while (match = importRe.exec(code)) {
+    const spec = (match[1] || match[2] || match[3] || "").trim();
+    if (!spec) continue;
+    if (/^(data:|https?:|\/\/)/i.test(spec)) continue;
+    const resolved = spec.startsWith("/") ? path5.resolve(rootDir, "." + spec) : path5.resolve(path5.dirname(filePath), spec);
+    addDep(resolved);
+  }
   const compiled = {
     css: result.css,
-    tokens
+    tokens,
+    deps
   };
-  transformCache.set(cacheKey, {
-    hash: contentHash,
-    loaderHash,
-    transformed: JSON.stringify(compiled),
-    timestamp: Date.now()
-  });
   return compiled;
 }
 function renderCssModule({
@@ -1104,6 +1179,7 @@ function renderCssModule({
   const styleId = `ionify-css-${getCacheKey(filePath).slice(0, 8)}`;
   const tokensJson = tokens ? JSON.stringify(tokens) : "null";
   return `
+// ionify:css
 const cssText = ${cssJson};
 const styleId = ${JSON.stringify(styleId)};
 let style = document.querySelector(\`style[data-ionify-id="\${styleId}"]\`);
@@ -1126,6 +1202,22 @@ if (import.meta.hot) {
 }
 `.trim();
 }
+function renderCssRawStringModule(cssText) {
+  return `
+// ionify:css
+const css = ${JSON.stringify(cssText)};
+export { css };
+export default css;
+`.trim();
+}
+function renderCssUrlModule(url2) {
+  return `
+// ionify:css
+const url = ${JSON.stringify(url2)};
+export { url };
+export default url;
+`.trim();
+}
 
 // src/core/utils/public-path.ts
 import path6 from "path";
@@ -1218,17 +1310,350 @@ function normalizeUrlFromFs(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;
+
+// src/core/deps/registry.ts
+import crypto2 from "crypto";
+import fs5 from "fs";
+import path7 from "path";
+var registry = /* @__PURE__ */ new Map();
+function computeStableDepFileName(options) {
+  const pkgName = sanitizePackageName(options.packageName);
+  const pkgVersion = options.packageVersion || "0.0.0";
+  const subpath = normalizeSubpath(options.subpath);
+  let canonicalPath = options.entryPath;
+  try {
+    canonicalPath = fs5.realpathSync(options.entryPath);
+  } catch {
+  }
+  const hash = crypto2.createHash("sha256").update(canonicalPath).digest("hex").slice(0, 6);
+  const subpathSuffix = subpath ? `__${subpath}` : "";
+  return `${pkgName}@${pkgVersion}${subpathSuffix}_${hash}.js`;
+}
+function registerDepEntry(entry) {
+  const fileName = computeStableDepFileName({
+    entryPath: entry.entryPath,
+    packageName: entry.packageName,
+    packageVersion: entry.packageVersion,
+    subpath: entry.subpath
+  });
+  const existing = registry.get(fileName);
+  if (existing) {
+    return existing;
+  }
+  const record = { ...entry, fileName };
+  registry.set(fileName, record);
+  return record;
+}
+function getDepEntry(fileName) {
+  return registry.get(fileName);
+}
+function computeSubpathFromEntryPath(entryPath) {
+  const packageRoot = findPackageRoot(entryPath);
+  if (!packageRoot) {
+    if (process.env.DEBUG_DEPS) {
+      console.log(`[computeSubpathFromEntryPath] No package root for: ${entryPath}`);
+    }
+    return "";
+  }
+  let rel = path7.relative(packageRoot, entryPath).replace(/\\/g, "/");
+  const extIndex = rel.lastIndexOf(".");
+  if (extIndex !== -1) {
+    rel = rel.substring(0, extIndex);
+  }
+  if (rel.endsWith("/index")) {
+    rel = rel.substring(0, rel.length - "/index".length);
+  }
+  const pkgName = path7.basename(packageRoot);
+  if (process.env.DEBUG_DEPS) {
+    console.log(`[subpath] entry: ${path7.basename(entryPath)}, root: ${pkgName}, rel: "${rel}", isMain: ${rel === pkgName}`);
+  }
+  if (rel === pkgName || rel === "index" || rel === "" || rel === ".") {
+    return "";
+  }
+  return rel || "";
+}
+function findPackageRoot(entryPath) {
+  let currentDir = path7.dirname(entryPath);
+  let previousDir = entryPath;
+  while (currentDir && currentDir !== previousDir) {
+    const parent = path7.dirname(currentDir);
+    const grandparent = path7.dirname(parent);
+    if (path7.basename(parent) === "node_modules") {
+      const pkgJsonPath = path7.join(currentDir, "package.json");
+      if (fs5.existsSync(pkgJsonPath)) {
+        return currentDir;
+      }
+    }
+    if (path7.basename(grandparent) === "node_modules" && path7.basename(parent).startsWith("@")) {
+      const pkgJsonPath = path7.join(currentDir, "package.json");
+      if (fs5.existsSync(pkgJsonPath)) {
+        return currentDir;
+      }
+    }
+    previousDir = currentDir;
+    currentDir = parent;
+  }
+  return null;
+}
+function sanitizePackageName(name) {
+  return name.replace(/^@/, "").replace(/\//g, "__");
+}
+function normalizeSubpath(subpath) {
+  if (!subpath) return "";
+  const cleaned = subpath.replace(/^\.\//, "").replace(/^\//, "");
+  if (!cleaned || cleaned === "." || cleaned === "index") return "";
+  return cleaned.replace(/\//g, "__");
+}
+
+// src/core/refresh/reactRefreshInstrumentation.ts
+function isPascalCaseIdentifier(name) {
+  return /^[A-Z][A-Za-z0-9_$]*$/.test(name);
+}
+function hasRefreshRegistrationsAlready(code) {
+  return /\$RefreshReg\$/.test(code);
+}
+function dedupeByExportName(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const it of items) {
+    const key = `${it.exportName}::${it.localName}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(it);
+  }
+  return out;
+}
+function detectRefreshBoundaryExports(code) {
+  const out = [];
+  function isValidIdentifier(name) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+  }
+  {
+    const re = /export\s+(?:async\s+)?function\s+([A-Z][A-Za-z0-9_$]*)\s*\(/g;
+    let m;
+    while (m = re.exec(code)) {
+      const name = m[1];
+      out.push({ exportName: name, localName: name });
+    }
+  }
+  {
+    const re = /export\s+(?:const|let)\s+([A-Z][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?(?:function\b|\([^)]*\)\s*=>|[A-Za-z_$][A-Za-z0-9_$]*\s*=>)/g;
+    let m;
+    while (m = re.exec(code)) {
+      const name = m[1];
+      out.push({ exportName: name, localName: name });
+    }
+  }
+  {
+    const re = /export\s+default\s+(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)\b/g;
+    const m = re.exec(code);
+    if (m?.[1]) {
+      const local = m[1];
+      if (isPascalCaseIdentifier(local)) {
+        out.push({ exportName: "default", localName: local });
+      }
+    }
+  }
+  {
+    const re = /export\s+default\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*;?/g;
+    let m;
+    while (m = re.exec(code)) {
+      const local = m[1];
+      if (local === "function" || local === "class") continue;
+      if (isPascalCaseIdentifier(local)) {
+        out.push({ exportName: "default", localName: local });
+      }
+    }
+  }
+  {
+    const re = /export\s+(default\s+)?class\s+([A-Z][A-Za-z0-9_$]*)\b/g;
+    let m;
+    while (m = re.exec(code)) {
+      const isDefault = Boolean(m[1]);
+      const local = m[2];
+      if (!isPascalCaseIdentifier(local)) continue;
+      out.push({ exportName: isDefault ? "default" : local, localName: local });
+    }
+  }
+  {
+    const re = /export\s+(?:const|let)\s+([A-Z][A-Za-z0-9_$]*)\s*=\s*class\b/g;
+    let m;
+    while (m = re.exec(code)) {
+      const name = m[1];
+      if (!isPascalCaseIdentifier(name)) continue;
+      out.push({ exportName: name, localName: name });
+    }
+  }
+  {
+    const re = /export\s*{\s*([^}]+)\s*}\s*(?:from\s*(['"][^'"]+['"]))?\s*;?/g;
+    let m;
+    while (m = re.exec(code)) {
+      const from = m[2];
+      if (from) continue;
+      const specList = m[1] ?? "";
+      const parts = specList.split(",").map((p) => p.trim()).filter(Boolean);
+      for (const part of parts) {
+        if (part.startsWith("type ")) continue;
+        const asMatch = part.split(/\s+as\s+/);
+        const local = (asMatch[0] ?? "").trim();
+        const exported = (asMatch[1] ?? local).trim();
+        if (!local || !exported) continue;
+        if (local === "default") continue;
+        if (!isValidIdentifier(local) || !isValidIdentifier(exported)) continue;
+        if (!isPascalCaseIdentifier(local)) continue;
+        if (exported !== "default" && !isPascalCaseIdentifier(exported)) continue;
+        out.push({ exportName: exported, localName: local });
+      }
+    }
+  }
+  return dedupeByExportName(out);
+}
+async function buildReactRefreshRegistrations(code, _filePath) {
+  if (hasRefreshRegistrationsAlready(code)) return "";
+  const candidates = detectRefreshBoundaryExports(code);
+  if (!candidates.length) return "";
+  const lines = candidates.map(({ exportName, localName }) => {
+    return `window.$RefreshReg$?.(${localName}, normalizeRefreshModuleId(import.meta.url) + ":" + ${JSON.stringify(exportName)});`;
+  });
+  return "\n" + lines.join("\n") + "\n";
+}
+function needsReactRefresh(ext, isDev) {
+  if (!isDev) return false;
+  return ext === ".jsx" || ext === ".tsx";
+}
+async function instrumentReactRefresh(options) {
+  const { code, filePath, ext, isDev, isEntry = false } = options;
+  if (!needsReactRefresh(ext, isDev)) {
+    return { shouldInstrument: false, prologue: "", registrations: "", epilogue: "" };
+  }
+  const registrations = isEntry ? "" : await buildReactRefreshRegistrations(code, filePath);
+  const prologue = `import { setupReactRefresh, normalizeRefreshModuleId } from "/__ionify_react_refresh.js";
+const __ionifyRefresh__ = setupReactRefresh(import.meta.hot ?? { accept() {}, dispose() {} }, normalizeRefreshModuleId(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?.();
+  });
+}
+`;
+  return { shouldInstrument: true, prologue, registrations, epilogue };
+}
+
+// src/core/refresh/entryDetection.ts
+import path8 from "path";
+var ENTRY_PATTERNS = [
+  /\/src\/main\.(tsx?|jsx?)$/,
+  /\/src\/index\.(tsx?|jsx?)$/
+];
+function normalizePath(input) {
+  const normalized = path8.normalize(input).replace(/\\/g, "/");
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function isEntryModule(filePath, config) {
+  const normalized = normalizePath(path8.resolve(filePath));
+  if (config?.entry) {
+    const root = config.root ?? process.cwd();
+    const entries = Array.isArray(config.entry) ? config.entry : [config.entry];
+    for (const entry of entries) {
+      const resolvedEntry = path8.resolve(root, entry);
+      const normalizedEntry = normalizePath(resolvedEntry);
+      if (normalized === normalizedEntry) return true;
+    }
+  }
+  return ENTRY_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+
+// src/core/refresh/refreshEligibility.ts
+function containsJSX(code) {
+  const sample = code.slice(0, 8 * 1024);
+  if (sample.includes("React.createElement")) return true;
+  if (/\bjsx(?:s)?\s*\(/.test(sample)) return true;
+  if (sample.includes("<>") || sample.includes("</>")) return true;
+  if (/<[A-Za-z][A-Za-z0-9.$_-]*\b[^>]*\/>/.test(sample)) return true;
+  if (/<[A-Za-z][A-Za-z0-9.$_-]*\b[^>]*>/.test(sample) && /<\/[A-Za-z]/.test(sample)) {
+    return true;
+  }
   return false;
 }
+function shouldUseReactRefresh(options) {
+  const { ext, code, isDev, config } = options;
+  if (!isDev) return false;
+  if (config?.fastRefresh === false) return false;
+  if (ext === ".jsx" || ext === ".tsx") return containsJSX(code);
+  if (ext === ".js" || ext === ".ts" || ext === ".mjs" || ext === ".mts") return containsJSX(code);
+  return false;
+}
+
+// src/core/loaders/js.ts
+import fs6 from "fs";
+import path9 from "path";
+var JS_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts"]);
 function shouldTransform(ext, filePath) {
   if (!JS_EXTENSIONS.has(ext)) return false;
   if (filePath.endsWith(".d.ts")) return false;
   return true;
 }
+function computeSubpathForDep(fsPath, pkg) {
+  const computed = computeSubpathFromEntryPath(fsPath);
+  if (!computed && !fs6.existsSync(fsPath) && pkg && typeof pkg.subpath === "string") {
+    const raw = pkg.subpath;
+    const cleaned = raw.replace(/^\.\//, "").replace(/^\/+/, "");
+    if (cleaned && cleaned !== "." && cleaned !== "index") {
+      return cleaned;
+    }
+  }
+  if (process.env.DEBUG_DEPS) {
+    console.log(`[computeSubpathForDep] fsPath: ${fsPath}`);
+    console.log(`[computeSubpathForDep] pkg.name: ${pkg?.name}, pkg.subpath: ${pkg?.subpath}`);
+    console.log(`[computeSubpathForDep] computed: "${computed}"`);
+  }
+  return computed || null;
+}
+function looksLikeCjsWrapperSource(source) {
+  const sample = source.slice(0, 16 * 1024);
+  return sample.includes("module.exports") || sample.includes("exports.") || sample.includes("Object.defineProperty(exports") || sample.includes("Object.defineProperty(module.exports") || sample.includes("require(") || sample.includes("require (");
+}
+function looksLikeEsmSource(source) {
+  const sample = source.slice(0, 16 * 1024);
+  return sample.includes("import ") || sample.includes("export ") || sample.includes("import{") || sample.includes("export{") || sample.includes("import(");
+}
+function findNearestPackageJson(filePath) {
+  let current = path9.dirname(filePath);
+  for (let i = 0; i < 25; i++) {
+    const candidate = path9.join(current, "package.json");
+    if (fs6.existsSync(candidate)) return candidate;
+    const parent = path9.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function makeDepsProxyForFile(filePath, code) {
+  if (!looksLikeCjsWrapperSource(code)) return null;
+  const pkgJsonPath = findNearestPackageJson(filePath);
+  if (!pkgJsonPath) return null;
+  try {
+    const pkg = JSON.parse(fs6.readFileSync(pkgJsonPath, "utf8"));
+    const fileName = registerDepEntry({
+      entryPath: filePath,
+      packageName: pkg?.name ?? "dep",
+      packageVersion: pkg?.version ?? "0.0.0",
+      subpath: null
+    }).fileName;
+    return `import * as __ionify_dep__ from "/@deps/${fileName}";
+export default __ionify_dep__;
+export * from "/@deps/${fileName}";
+`;
+  } catch {
+    return null;
+  }
+}
 async function swcTranspile(code, filePath, ext, reactRefresh) {
   const isTypeScript = ext === ".ts" || ext === ".tsx";
   const isTsx = ext === ".tsx";
@@ -1274,18 +1699,30 @@ var jsLoader = {
   name: "js",
   order: 0,
   test: ({ ext, path: filePath }) => shouldTransform(ext, filePath),
-  transform: async ({ path: filePath, code, ext }) => {
+  transform: async ({ path: filePath, code, ext, config }) => {
     const isNodeModules = filePath.includes("node_modules");
+    const rewriteDebug = process.env.IONIFY_IMPORT_REWRITE_DEBUG === "1";
     let output = code;
     if (isNodeModules) {
-      const bundled = tryBundleNodeModule(filePath, code);
-      if (bundled) {
-        output = bundled;
+      const depsProxy = makeDepsProxyForFile(filePath, code);
+      if (depsProxy) {
+        output = depsProxy;
       } else {
-        output = code;
+        const shouldAttemptBundle = ext === ".cjs" || looksLikeCjsWrapperSource(code) || !looksLikeEsmSource(code) && ext !== ".mjs";
+        if (shouldAttemptBundle) {
+          const bundled = tryBundleNodeModule(filePath, code);
+          if (bundled) {
+            output = bundled;
+          } else {
+            output = code;
+          }
+        } else {
+          output = code;
+        }
       }
     } else {
-      const reactRefresh = needsReactRefresh(ext);
+      const isDev = process.env.NODE_ENV !== "production";
+      const reactRefresh = shouldUseReactRefresh({ ext, code, isDev, config });
       const mode = currentMode();
       const nativeResult = tryNativeTransform(mode, code, {
         filename: filePath,
@@ -1299,22 +1736,29 @@ var jsLoader = {
         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?.();
-  });
-}
+        const isEntry = isEntryModule(filePath, config ?? void 0);
+        if (process.env.IONIFY_REFRESH_DEBUG === "1") {
+          console.log(`[Refresh] ${filePath} \u2192 isEntry=${isEntry}, ext=${ext}`);
+        }
+        const result = await instrumentReactRefresh({
+          code: output,
+          filePath,
+          ext,
+          isDev,
+          isEntry
+        });
+        if (process.env.IONIFY_REFRESH_DEBUG === "1") {
+          console.log(
+            `[Refresh] instrument=${result.shouldInstrument} ${filePath} \u2192 isEntry=${isEntry}`
+          );
+        }
+        if (result.shouldInstrument) {
+          output = result.prologue + output + result.registrations + result.epilogue;
+        } else {
+          output += `
+if (import.meta.hot) import.meta.hot.accept();
 `;
-        output = prologue + output + epilogue;
+        }
       } else {
         output += `
 if (import.meta.hot) {
@@ -1325,8 +1769,11 @@ if (import.meta.hot) {
     }
     await init;
     const [imports] = parse(output);
+    if (rewriteDebug && ext === ".mjs" && isNodeModules) {
+      console.warn(`[Ionify][rewrite] scanning ${imports.length} import(s) in ${filePath}`);
+    }
     if (imports.length) {
-      const rootDir = process.cwd();
+      const rootDir = config?.root ? path9.resolve(config.root) : process.cwd();
       let rewritten = "";
       let lastIndex = 0;
       let mutated = false;
@@ -1345,8 +1792,96 @@ if (import.meta.hot) {
           pathPart = spec.slice(0, splitIndex);
           suffix = spec.slice(splitIndex);
         }
+        const isBare = !pathPart.startsWith(".") && !pathPart.startsWith("/") && !pathPart.startsWith("http://") && !pathPart.startsWith("https://");
+        if (isBare && native?.resolveModule) {
+          const resolvedNative = native.resolveModule(pathPart, filePath);
+          const kind = resolvedNative?.kind;
+          const fsPath = resolvedNative?.fsPath ?? resolvedNative?.fs_path ?? null;
+          if (kind === "PkgCjs" && fsPath) {
+            const pkg = resolvedNative?.pkg;
+            const fileName = registerDepEntry({
+              entryPath: fsPath,
+              packageName: pkg?.name ?? pathPart,
+              packageVersion: pkg?.version ?? "0.0.0",
+              subpath: computeSubpathForDep(fsPath, pkg)
+            }).fileName;
+            const replacement2 = `/@deps/${fileName}`;
+            if (!mutated) {
+              mutated = true;
+            }
+            if (record.t === 2) {
+              rewritten += output.slice(lastIndex, record.s + 1);
+              rewritten += replacement2;
+              rewritten += output[record.e - 1];
+              lastIndex = record.e;
+            } else {
+              rewritten += output.slice(lastIndex, record.s);
+              rewritten += replacement2;
+              lastIndex = record.e;
+            }
+            continue;
+          }
+          if (kind === "PkgEsm" && fsPath) {
+            try {
+              const resolvedCode = fs6.readFileSync(fsPath, "utf8");
+              if (looksLikeCjsWrapperSource(resolvedCode)) {
+                const pkg2 = resolvedNative?.pkg;
+                const fileName2 = registerDepEntry({
+                  entryPath: fsPath,
+                  packageName: pkg2?.name ?? pathPart,
+                  packageVersion: pkg2?.version ?? "0.0.0",
+                  subpath: computeSubpathForDep(fsPath, pkg2)
+                }).fileName;
+                const replacement3 = `/@deps/${fileName2}`;
+                if (!mutated) mutated = true;
+                if (record.t === 2) {
+                  rewritten += output.slice(lastIndex, record.s + 1);
+                  rewritten += replacement3;
+                  rewritten += output[record.e - 1];
+                  lastIndex = record.e;
+                } else {
+                  rewritten += output.slice(lastIndex, record.s);
+                  rewritten += replacement3;
+                  lastIndex = record.e;
+                }
+                continue;
+              }
+            } catch {
+            }
+            const pkg = resolvedNative?.pkg;
+            const fileName = registerDepEntry({
+              entryPath: fsPath,
+              packageName: pkg?.name ?? pathPart,
+              packageVersion: pkg?.version ?? "0.0.0",
+              subpath: computeSubpathForDep(fsPath, pkg)
+            }).fileName;
+            const replacement2 = `/@deps/${fileName}`;
+            if (!mutated) mutated = true;
+            if (record.t === 2) {
+              rewritten += output.slice(lastIndex, record.s + 1);
+              rewritten += replacement2;
+              rewritten += output[record.e - 1];
+              lastIndex = record.e;
+            } else {
+              rewritten += output.slice(lastIndex, record.s);
+              rewritten += replacement2;
+              lastIndex = record.e;
+            }
+            continue;
+          }
+          if (kind === "Builtin" || kind === "Virtual") {
+            continue;
+          }
+        }
         const resolved = resolveImport(pathPart, filePath);
-        if (!resolved) continue;
+        if (!resolved) {
+          if (rewriteDebug) {
+            console.warn(
+              `[Ionify][rewrite] FAILED to resolve '${pathPart}' from '${filePath}'`
+            );
+          }
+          continue;
+        }
         const resolvedExt = resolved.slice(resolved.lastIndexOf("."));
         let augmentedSuffix = suffix;
         if (resolvedExt === ".css" && !suffix) {
@@ -1390,6 +1925,11 @@ if (import.meta.hot) {
       if (mutated) {
         rewritten += output.slice(lastIndex);
         output = rewritten;
+      } else if (rewriteDebug && isNodeModules) {
+        const sample = imports.slice(0, 8).map((r) => r.n).filter(Boolean).join(", ");
+        console.warn(
+          `[Ionify][rewrite] no rewrites applied for ${filePath}; first imports: ${sample}`
+        );
       }
     }
     return { code: output };
@@ -1397,12 +1937,12 @@ if (import.meta.hot) {
 };
 
 // src/core/loaders/registry.ts
-var registry = [];
+var registry2 = /* @__PURE__ */ new Set();
 function registerLoader(registration) {
-  registry.push(registration);
+  registry2.add(registration);
 }
 async function applyRegisteredLoaders(engine, config) {
-  for (const registration of registry) {
+  for (const registration of registry2) {
     await registration(engine, config ?? null);
   }
   if (config?.plugins) {
@@ -1414,9 +1954,8 @@ async function applyRegisteredLoaders(engine, config) {
       }
       if (plugin.setup) {
         const context = {
-          registerLoader: (loader) => {
-            engine.useLoader(loader);
-          }
+          config: config ?? null,
+          registerLoader: (loader) => engine.useLoader(loader)
         };
         await plugin.setup(context);
       }
@@ -1433,8 +1972,8 @@ registerLoader((engine) => {
 });
 
 // src/cli/utils/config.ts
-import fs5 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path10 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { build } from "esbuild";
 var CONFIG_BASENAMES = [
@@ -1447,7 +1986,7 @@ var CONFIG_BASENAMES = [
 var cachedConfig2 = null;
 var configLoaded = false;
 async function bundleConfig(entry) {
-  const absDir = path7.dirname(entry);
+  const absDir = path10.dirname(entry);
   const inlineIonifyPlugin = {
     name: "inline-ionify",
     setup(build2) {
@@ -1495,8 +2034,8 @@ const __filename = ${filenameLiteral};
 }
 function findConfigFile(cwd) {
   for (const name of CONFIG_BASENAMES) {
-    const candidate = path7.resolve(cwd, name);
-    if (fs5.existsSync(candidate) && fs5.statSync(candidate).isFile()) {
+    const candidate = path10.resolve(cwd, name);
+    if (fs7.existsSync(candidate) && fs7.statSync(candidate).isFile()) {
       return candidate;
     }
   }
@@ -1507,7 +2046,7 @@ async function loadIonifyConfig(cwd = process.cwd()) {
   configLoaded = true;
   const configPath = findConfigFile(cwd);
   if (!configPath) {
-    cachedConfig2 = null;
+    cachedConfig2 = { root: cwd };
     configureResolverAliases(void 0, cwd);
     return cachedConfig2;
   }
@@ -1523,15 +2062,33 @@ async function loadIonifyConfig(cwd = process.cwd()) {
       resolved = await resolved;
     }
     if (resolved && typeof resolved === "object") {
+      if (resolved.root) {
+        const rootPath = path10.isAbsolute(resolved.root) ? resolved.root : path10.resolve(path10.dirname(configPath), resolved.root);
+        if (!fs7.existsSync(rootPath)) {
+          logError(`Config error: root directory does not exist: ${rootPath}`);
+          throw new Error(`Invalid root: ${rootPath}`);
+        }
+        if (!fs7.statSync(rootPath).isDirectory()) {
+          logError(`Config error: root must be a directory: ${rootPath}`);
+          throw new Error(`Invalid root: ${rootPath}`);
+        }
+        resolved.root = rootPath;
+        logInfo(`Using project root: ${path10.relative(cwd, rootPath)}`);
+      } else {
+        resolved.root = path10.dirname(configPath);
+      }
+      if (resolved.optimizeDeps?.esbuildOptions) {
+        logWarn("optimizeDeps.esbuildOptions is not supported in Ionify (uses native Rust optimizer). This option will be ignored.");
+      }
       cachedConfig2 = resolved;
-      const baseDir = path7.dirname(configPath);
+      const baseDir = path10.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)}`);
+      logInfo(`Loaded ionify config from ${path10.relative(cwd, configPath)}`);
     } else {
       throw new Error("Config did not export an object");
     }
@@ -1561,13 +2118,10 @@ function resolveMinifier(config, opts = {}) {
   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";
+import fs8 from "fs";
+import path11 from "path";
 function parseValue(raw) {
   let value = raw.trim();
   if (!value) return "";
@@ -1599,11 +2153,11 @@ function loadEnv(mode = "development", rootDir = process.cwd()) {
   ];
   const merged = {};
   for (const name of candidates) {
-    const filePath = path8.resolve(rootDir, name);
-    if (!fs6.existsSync(filePath) || !fs6.statSync(filePath).isFile()) {
+    const filePath = path11.resolve(rootDir, name);
+    if (!fs8.existsSync(filePath) || !fs8.statSync(filePath).isFile()) {
       continue;
     }
-    const contents = fs6.readFileSync(filePath, "utf8");
+    const contents = fs8.readFileSync(filePath, "utf8");
     const parsed = parseEnvFile(contents);
     Object.assign(merged, parsed);
   }
@@ -1689,11 +2243,6 @@ function resolveTreeshake(input, options = {}) {
   }
   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 = {
@@ -1756,12 +2305,6 @@ function resolveScopeHoist(configValue, options = {}) {
   }
   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/cli/utils/parser.ts
 function normalize2(mode) {
@@ -1783,20 +2326,95 @@ function applyParserEnv(mode) {
   process.env.IONIFY_PARSER = mode;
 }
 
+// src/core/utils/define.ts
+function applyDefineReplacements(code, definitions) {
+  if (!definitions || Object.keys(definitions).length === 0) {
+    return code;
+  }
+  let result = code;
+  const sortedKeys = Object.keys(definitions).sort((a, b) => b.length - a.length);
+  for (const key of sortedKeys) {
+    const value = definitions[key];
+    let replacement;
+    if (typeof value === "string") {
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        replacement = value;
+      } else {
+        replacement = JSON.stringify(value);
+      }
+    } else if (typeof value === "number" || typeof value === "boolean") {
+      replacement = String(value);
+    } else if (value === null || value === void 0) {
+      replacement = "null";
+    } else {
+      replacement = JSON.stringify(value);
+    }
+    if (key.includes(".")) {
+      result = replaceMemberExpression(result, key, replacement);
+    } else {
+      result = replaceIdentifier(result, key, replacement);
+    }
+  }
+  return result;
+}
+function replaceIdentifier(code, identifier, replacement) {
+  const regex = new RegExp(
+    `(?<![\\w.$])${escapeRegExp(identifier)}(?![\\w])`,
+    "g"
+  );
+  return code.replace(regex, replacement);
+}
+function replaceMemberExpression(code, expression, replacement) {
+  const parts = expression.split(".");
+  const pattern = parts.map(escapeRegExp).join("\\s*\\.\\s*");
+  const regex = new RegExp(
+    `(?<![\\w.$])${pattern}(?![\\w.])`,
+    "g"
+  );
+  return code.replace(regex, replacement);
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildDefineConfig(userDefine, envValues, envPrefix = ["VITE_", "IONIFY_"]) {
+  const define = { ...userDefine || {} };
+  const prefixes = Array.isArray(envPrefix) ? envPrefix : [envPrefix];
+  for (const [key, value] of Object.entries(envValues)) {
+    const hasPrefix = prefixes.some((prefix) => key.startsWith(prefix));
+    if (hasPrefix || key === "NODE_ENV" || key === "MODE") {
+      const importMetaKey = `import.meta.env.${key}`;
+      if (!(importMetaKey in define)) {
+        define[importMetaKey] = value;
+      }
+    }
+  }
+  if (!("import.meta.env.DEV" in define)) {
+    define["import.meta.env.DEV"] = envValues.MODE !== "production";
+  }
+  if (!("import.meta.env.PROD" in define)) {
+    define["import.meta.env.PROD"] = envValues.MODE === "production";
+  }
+  return define;
+}
+
 // src/cli/commands/dev.ts
-import crypto2 from "crypto";
+import crypto3 from "crypto";
+import zlib from "zlib";
+var IONIFY_CSS_JS_MARKER = "// ionify:css";
+var IONIFY_VENDOR_PACK_MARKER = "// ionify:vendor-pack";
 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");
+var __dirname2 = path12.dirname(__filename2);
+var CLIENT_DIR = path12.resolve(__dirname2, "../client");
+var CLIENT_FALLBACK_DIR = path12.resolve(process.cwd(), "src/client");
+var DEPS_PREFIX = "/@deps/";
 function readClientAssetFile(fileName) {
-  const primary = path9.join(CLIENT_DIR, fileName);
-  if (fs7.existsSync(primary)) {
-    return { filePath: primary, code: fs7.readFileSync(primary, "utf8") };
+  const primary = path12.join(CLIENT_DIR, fileName);
+  if (fs9.existsSync(primary)) {
+    return { filePath: primary, code: fs9.readFileSync(primary, "utf8") };
   }
-  const fallback = path9.join(CLIENT_FALLBACK_DIR, fileName);
-  if (fs7.existsSync(fallback)) {
-    return { filePath: fallback, code: fs7.readFileSync(fallback, "utf8") };
+  const fallback = path12.join(CLIENT_FALLBACK_DIR, fileName);
+  if (fs9.existsSync(fallback)) {
+    return { filePath: fallback, code: fs9.readFileSync(fallback, "utf8") };
   }
   throw new Error(`Missing Ionify client asset: ${fileName}`);
 }
@@ -1804,7 +2422,7 @@ function readClientAsset(fileName) {
   return readClientAssetFile(fileName).code;
 }
 function guessContentType(filePath) {
-  const ext = path9.extname(filePath);
+  const ext = path12.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";
@@ -1816,16 +2434,289 @@ function guessContentType(filePath) {
     return "application/json; charset=utf-8";
   return "text/plain; charset=utf-8";
 }
+function mergeVaryHeader(existing, next) {
+  const parts = /* @__PURE__ */ new Set();
+  const add = (value) => {
+    value.split(",").map((v) => v.trim()).filter(Boolean).forEach((v) => parts.add(v));
+  };
+  if (typeof existing === "string") add(existing);
+  else if (Array.isArray(existing)) existing.forEach(add);
+  add(next);
+  return Array.from(parts).join(", ");
+}
+function normalizeEtag(tag) {
+  return tag.trim().replace(/^W\//, "");
+}
+function isNotModified(req, etag) {
+  const header = req.headers["if-none-match"];
+  const value = Array.isArray(header) ? header.join(",") : header;
+  if (!value) return false;
+  if (value.trim() === "*") return true;
+  const expected = normalizeEtag(etag);
+  return value.split(",").map((t) => t.trim()).filter(Boolean).some((t) => normalizeEtag(t) === expected);
+}
+function weakEtagFromStat(prefix, stat) {
+  const mtime = Math.floor(stat.mtimeMs);
+  return `W/"${prefix}-${stat.size}-${mtime}"`;
+}
+function shouldCompressContentType(contentType) {
+  const ct = contentType.toLowerCase();
+  return ct.startsWith("text/") || ct.includes("javascript") || ct.includes("json") || ct.includes("xml") || ct.includes("svg");
+}
+function selectCompressionEncoding(req) {
+  const header = req.headers["accept-encoding"];
+  const value = Array.isArray(header) ? header.join(",") : header;
+  if (!value) return null;
+  const enc = value.toLowerCase();
+  if (enc.includes("gzip")) return "gzip";
+  return null;
+}
+function looksLikeIonifyCssJsModule(body) {
+  const head = body.subarray(0, 96).toString("utf8");
+  return head.trimStart().startsWith(IONIFY_CSS_JS_MARKER);
+}
+function computeDepsStampHash(depsAbs) {
+  if (!depsAbs.length) return "0";
+  const entries = [];
+  for (const dep of depsAbs) {
+    const abs = path12.resolve(dep);
+    try {
+      const stat = fs9.statSync(abs);
+      entries.push(`${abs}:${stat.size}:${Math.floor(stat.mtimeMs)}`);
+    } catch {
+      entries.push(`${abs}:missing`);
+    }
+  }
+  entries.sort();
+  return getCacheKey(entries.join("|"));
+}
+function sendBuffer(req, res, status, contentType, body, opts) {
+  res.setHeader("Content-Type", contentType);
+  res.setHeader("Cache-Control", opts?.cacheControl ?? "no-cache");
+  const etag = opts?.etag;
+  if (etag) {
+    res.setHeader("ETag", etag);
+    if (isNotModified(req, etag)) {
+      res.statusCode = 304;
+      res.end();
+      return;
+    }
+  }
+  const encoding = body.length >= 1024 && shouldCompressContentType(contentType) ? selectCompressionEncoding(req) : null;
+  if (encoding === "gzip") {
+    res.setHeader("Vary", mergeVaryHeader(res.getHeader("Vary"), "Accept-Encoding"));
+    res.setHeader("Content-Encoding", "gzip");
+    res.statusCode = status;
+    res.end(zlib.gzipSync(body, { level: 1 }));
+    return;
+  }
+  res.statusCode = status;
+  res.end(body);
+}
+var LOCKFILE_ORDER = [
+  "pnpm-lock.yaml",
+  "package-lock.json",
+  "yarn.lock",
+  "bun.lockb"
+];
+function readLockfile(rootDir) {
+  for (const name of LOCKFILE_ORDER) {
+    const filePath = path12.join(rootDir, name);
+    if (!fs9.existsSync(filePath)) continue;
+    const contents = fs9.readFileSync(filePath);
+    const packageCount = estimateLockfilePackageCount(name, contents);
+    return { name, path: filePath, contents, packageCount };
+  }
+  return null;
+}
+function estimateLockfilePackageCount(name, contents) {
+  if (name === "package-lock.json") {
+    try {
+      const parsed = JSON.parse(contents.toString("utf8"));
+      if (parsed?.packages && typeof parsed.packages === "object") {
+        return Object.keys(parsed.packages).length;
+      }
+    } catch {
+      return null;
+    }
+  }
+  if (name === "pnpm-lock.yaml") {
+    const text = contents.toString("utf8");
+    return text.split("\n").filter((line) => line.trimStart().startsWith("/")).length;
+  }
+  if (name === "yarn.lock") {
+    const text = contents.toString("utf8");
+    return text.split("\n").filter((line) => line && !line.startsWith(" ") && line.endsWith(":")).length;
+  }
+  return null;
+}
+function computeDepsHash(configHash, lockfile, opts) {
+  const hash = crypto3.createHash("sha256");
+  hash.update(configHash);
+  if (lockfile) {
+    hash.update(lockfile.contents);
+  }
+  hash.update(`NODE_ENV=${opts.nodeEnv}`);
+  hash.update(`optimizeDeps.sourcemap=${opts.sourcemap ? "1" : "0"}`);
+  hash.update(`optimizeDeps.bundleEsm=${opts.bundleEsm ? "1" : "0"}`);
+  return hash.digest("hex").slice(0, 16);
+}
+function readProjectPackageJson(rootDir) {
+  const pkgPath = path12.join(rootDir, "package.json");
+  if (!fs9.existsSync(pkgPath)) return null;
+  try {
+    return JSON.parse(fs9.readFileSync(pkgPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function detectVendorSpecifiers(pkgJson) {
+  if (!pkgJson || typeof pkgJson !== "object") return [];
+  const deps = {
+    ...pkgJson.dependencies || {},
+    ...pkgJson.devDependencies || {},
+    ...pkgJson.peerDependencies || {}
+  };
+  const has = (name) => Object.prototype.hasOwnProperty.call(deps, name);
+  if (has("react") || has("react-dom")) {
+    return [
+      "react",
+      "react-dom",
+      "react-dom/client",
+      "scheduler",
+      "react/jsx-runtime",
+      "react/jsx-dev-runtime",
+      "react-refresh"
+    ];
+  }
+  if (has("vue")) {
+    return ["vue", "@vue/runtime-dom", "@vue/runtime-core"];
+  }
+  if (has("svelte")) {
+    return ["svelte", "svelte/internal"];
+  }
+  return [];
+}
+function computeSubpathForDep2(fsPath, pkg) {
+  const computed = computeSubpathFromEntryPath(fsPath);
+  if (computed) return computed;
+  if (fs9.existsSync(fsPath)) return null;
+  const raw = pkg?.subpath;
+  if (typeof raw === "string") {
+    const cleaned = raw.replace(/^\.\//, "").replace(/^\/+/, "");
+    if (cleaned && cleaned !== "." && cleaned !== "index") {
+      return cleaned;
+    }
+  }
+  return null;
+}
+function resolveVendorDeps(rootDir, specifiers) {
+  if (!native?.resolveModule) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const spec of specifiers) {
+    try {
+      const r = native.resolveModule(spec, rootDir);
+      const fsPath = r?.fsPath ?? r?.fs_path ?? null;
+      if (!fsPath || typeof fsPath !== "string") continue;
+      const pkg = r?.pkg ?? null;
+      const packageName = typeof pkg?.name === "string" ? pkg.name : spec;
+      const packageVersion = typeof pkg?.version === "string" ? pkg.version : "0.0.0";
+      const subpath = computeSubpathForDep2(fsPath, pkg);
+      const entry = registerDepEntry({
+        entryPath: fsPath,
+        packageName,
+        packageVersion,
+        subpath
+      });
+      if (seen.has(entry.fileName)) continue;
+      seen.add(entry.fileName);
+      resolved.push({
+        specifier: spec,
+        entryPath: fsPath,
+        fileName: entry.fileName,
+        packageLabel: formatDepLabel(packageName, subpath)
+      });
+    } catch {
+    }
+  }
+  return resolved;
+}
+function injectModulePreload(html, href) {
+  const tag = `<link rel="modulepreload" href="${href}">`;
+  if (html.includes(tag)) return html;
+  const headCloseMatch = html.match(/<\/head>/i);
+  if (headCloseMatch?.index !== void 0) {
+    const idx = headCloseMatch.index;
+    return `${html.slice(0, idx)}${tag}
+${html.slice(idx)}`;
+  }
+  const headOpenMatch = html.match(/<head[^>]*>/i);
+  if (headOpenMatch?.index !== void 0) {
+    const idx = headOpenMatch.index + headOpenMatch[0].length;
+    return `${html.slice(0, idx)}
+${tag}${html.slice(idx)}`;
+  }
+  return `${tag}
+${html}`;
+}
+function pruneDepsCache(rootDir, depsHash) {
+  const depsRoot = path12.join(rootDir, ".ionify", "deps");
+  if (!fs9.existsSync(depsRoot)) return;
+  const entries = fs9.readdirSync(depsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => {
+    const fullPath = path12.join(depsRoot, entry.name);
+    const stat = fs9.statSync(fullPath);
+    return { name: entry.name, path: fullPath, mtimeMs: stat.mtimeMs };
+  }).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const keep = /* @__PURE__ */ new Set();
+  keep.add(depsHash);
+  for (const entry of entries.slice(0, 2)) {
+    keep.add(entry.name);
+  }
+  for (const entry of entries) {
+    if (!keep.has(entry.name)) {
+      fs9.rmSync(entry.path, { recursive: true, force: true });
+    }
+  }
+}
+function loadDepsManifestIndex(depsRoot) {
+  const manifestPath = path12.join(depsRoot, "manifest.json");
+  if (!fs9.existsSync(manifestPath)) return /* @__PURE__ */ new Map();
+  try {
+    const raw = fs9.readFileSync(manifestPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const entries = parsed?.entries ?? {};
+    const map = /* @__PURE__ */ new Map();
+    for (const [entryPath, entry] of Object.entries(entries)) {
+      if (!entry?.outFile) continue;
+      map.set(entry.outFile, {
+        entryPath,
+        packageLabel: entry.package || "unknown",
+        hasSourcemap: entry.hasSourcemap === true
+      });
+    }
+    return map;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function formatDepLabel(name, subpath) {
+  if (!subpath) return name;
+  const cleaned = subpath.replace(/^\.\//, "").replace(/^\/+/, "");
+  if (!cleaned || cleaned === ".") return name;
+  return `${name}/${cleaned}`;
+}
 async function startDevServer({
   port = 5173,
+  host = process.env.IONIFY_HOST || "127.0.0.1",
   enableSignalHandlers = true
 } = {}) {
-  const rootDir = process.cwd();
+  const bootStartMs = Date.now();
+  const userConfig = await loadIonifyConfig();
+  const rootDir = userConfig?.root || 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, {
@@ -1833,15 +2724,15 @@ async function startDevServer({
     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 resolvedEntries = userConfig?.entry ? (Array.isArray(userConfig.entry) ? userConfig.entry : [userConfig.entry]).map(
+    (entry) => entry.startsWith("/") ? path12.join(rootDir, entry) : path12.resolve(rootDir, 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,
@@ -1849,14 +2740,64 @@ async function startDevServer({
     treeshake,
     scopeHoist,
     plugins: pluginNames,
-    entry: resolvedEntry ? [resolvedEntry] : null,
+    entry: resolvedEntries ?? 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 casRoot = path12.join(rootDir, ".ionify", "cas");
+  const lockfile = readLockfile(rootDir);
+  if (lockfile) {
+    const countLabel = lockfile.packageCount === null ? "unknown" : lockfile.packageCount;
+    logInfo(`[deps] SCAN lockfile: ${lockfile.name} (${countLabel} packages)`);
+  }
+  const depsSourcemapEnabled = userConfig?.optimizeDeps?.sourcemap === true;
+  const depsBundleEsmEnabled = userConfig?.optimizeDeps?.bundleEsm !== false;
+  const depsNodeEnv = process.env.NODE_ENV ?? "development";
+  const depsHash = computeDepsHash(configHash, lockfile, {
+    nodeEnv: depsNodeEnv,
+    sourcemap: depsSourcemapEnabled,
+    bundleEsm: depsBundleEsmEnabled
+  });
+  logInfo(`[deps] depsHash: ${depsHash} from ${lockfile?.name ?? "config"}`);
+  const depsRoot = path12.join(rootDir, ".ionify", "deps", depsHash);
+  fs9.mkdirSync(depsRoot, { recursive: true });
+  pruneDepsCache(rootDir, depsHash);
+  const depsManifestIndex = loadDepsManifestIndex(depsRoot);
+  const optimizeVendorMode = userConfig?.optimizeDeps?.vendor ?? "auto";
+  const optimizeExclude = Array.isArray(userConfig?.optimizeDeps?.exclude) ? new Set(userConfig.optimizeDeps.exclude) : null;
+  const autoVendor = optimizeVendorMode === "auto";
+  const vendorSpecifiersRaw = optimizeVendorMode === false ? [] : Array.isArray(optimizeVendorMode) ? optimizeVendorMode : autoVendor ? detectVendorSpecifiers(readProjectPackageJson(rootDir)) : [];
+  const vendorSpecifiers = vendorSpecifiersRaw.map((s) => String(s).trim()).filter(Boolean).filter((s) => !optimizeExclude?.has(s));
+  const vendorDeps = resolveVendorDeps(rootDir, vendorSpecifiers);
+  const vendorPackFileName = vendorDeps.length > 0 ? `vendor.${depsHash}.js` : null;
+  const vendorPackUrl = vendorPackFileName ? `${DEPS_PREFIX}${vendorPackFileName}` : null;
+  const ensureVendorPackFile = () => {
+    if (!vendorPackFileName || !vendorPackUrl || vendorDeps.length === 0) return;
+    const vendorKey = getCacheKey(
+      `vendor:v1:${vendorDeps.map((d) => `${d.specifier}:${d.fileName}`).sort().join("|")}`
+    );
+    const filePath = path12.join(depsRoot, vendorPackFileName);
+    if (fs9.existsSync(filePath)) {
+      try {
+        const head = fs9.readFileSync(filePath, "utf8").slice(0, 256);
+        if (head.includes(`${IONIFY_VENDOR_PACK_MARKER} ${vendorKey}`)) return;
+      } catch {
+      }
+    }
+    const imports = vendorDeps.slice().sort((a, b) => a.specifier.localeCompare(b.specifier)).map((d) => `import "${DEPS_PREFIX}${d.fileName}";`).join("\n");
+    const body = `${IONIFY_VENDOR_PACK_MARKER} ${vendorKey}
+// depsHash: ${depsHash}
+// vendor: ${vendorDeps.map((d) => d.specifier).join(", ")}
+${imports}
+`;
+    try {
+      fs9.writeFileSync(filePath, body, "utf8");
+    } catch {
+    }
+  };
   const transformer = new TransformEngine({ casRoot, versionHash: configHash });
   const graph = new Graph(rawVersionInputs);
   if (native?.initAstCache) {
@@ -1867,7 +2808,7 @@ async function startDevServer({
       try {
         native.astCacheWarmup();
       } catch (err) {
-        logWarn(`AST cache warmup skipped: ${err}`);
+        logWarn2(`AST cache warmup skipped: ${err}`);
       }
     }
     if (native?.astCacheStats) {
@@ -1898,6 +2839,9 @@ async function startDevServer({
     NODE_ENV: process.env.NODE_ENV,
     MODE: process.env.MODE
   };
+  const envPrefix = userConfig?.envPrefix || ["VITE_", "IONIFY_"];
+  const defineConfig = buildDefineConfig(userConfig?.define, envValues, envPrefix);
+  logInfo(`[define] ${Object.keys(defineConfig).length} replacements configured`);
   const envPlaceholderPattern = /%([A-Z0-9_]+)%/g;
   const envEnabledExts = /* @__PURE__ */ new Set([
     ".html",
@@ -1941,7 +2885,7 @@ async function startDevServer({
   const buildUpdatePayload = async (modules) => {
     const updates = [];
     for (const mod of modules) {
-      const exists = fs7.existsSync(mod.absPath);
+      const exists = fs9.existsSync(mod.absPath);
       if (mod.reason === "deleted" || !exists) {
         graph.removeFile(mod.absPath);
         watcher.unwatchFile(mod.absPath);
@@ -1955,9 +2899,53 @@ async function startDevServer({
         continue;
       }
       watcher.watchFile(mod.absPath);
+      const ext = path12.extname(mod.absPath).toLowerCase();
+      if (ext === ".css") {
+        let hash2 = mod.hash;
+        if (!hash2) {
+          try {
+            hash2 = getCacheKey(fs9.readFileSync(mod.absPath, "utf8"));
+          } catch {
+            hash2 = graph.getNode(mod.absPath)?.hash ?? getCacheKey(mod.absPath);
+          }
+        }
+        const depsAbs2 = graph.getNode(mod.absPath)?.deps ?? [];
+        const kind = /\.module\.css$/i.test(mod.absPath) ? "css-module" : "css";
+        graph.recordFile(mod.absPath, hash2, depsAbs2, [], kind);
+        updates.push({
+          url: mod.url,
+          hash: hash2,
+          deps: depsAbs2.map((dep) => normalizeUrlFromFs(rootDir, dep)),
+          reason: mod.reason,
+          status: "updated",
+          code: ""
+        });
+        continue;
+      }
+      if (isAssetExt(ext)) {
+        let hash2 = mod.hash;
+        if (!hash2) {
+          try {
+            const buf = fs9.readFileSync(mod.absPath);
+            hash2 = crypto3.createHash("sha256").update(buf).digest("hex");
+          } catch {
+            hash2 = graph.getNode(mod.absPath)?.hash ?? getCacheKey(mod.absPath);
+          }
+        }
+        graph.recordFile(mod.absPath, hash2, [], [], "asset");
+        updates.push({
+          url: mod.url,
+          hash: hash2,
+          deps: [],
+          reason: mod.reason,
+          status: "updated",
+          code: ""
+        });
+        continue;
+      }
       let code;
       try {
-        code = fs7.readFileSync(mod.absPath, "utf8");
+        code = fs9.readFileSync(mod.absPath, "utf8");
       } catch (err) {
         logError("Failed to read module during HMR apply", err);
         throw err;
@@ -1985,13 +2973,14 @@ async function startDevServer({
       const result = await transformer.run({
         path: mod.absPath,
         code,
-        ext: path9.extname(mod.absPath),
-        moduleHash: hash
+        ext: path12.extname(mod.absPath),
+        moduleHash: hash,
+        config: userConfig ?? null
       });
       const transformed = result.code;
       const envApplied = applyEnvPlaceholders(
         transformed,
-        path9.extname(mod.absPath)
+        path12.extname(mod.absPath)
       );
       updates.push({
         url: mod.url,
@@ -2032,7 +3021,7 @@ async function startDevServer({
           const asset = readClientAssetFile("react-refresh-runtime.js");
           let reactRefreshPath;
           try {
-            const projectRequire = createRequire2(path9.join(rootDir, "package.json"));
+            const projectRequire = createRequire2(path12.join(rootDir, "package.json"));
             reactRefreshPath = projectRequire.resolve("react-refresh/runtime");
           } catch (err) {
             logError("Failed to resolve react-refresh/runtime", err);
@@ -2115,6 +3104,108 @@ async function startDevServer({
         sendJson(res, 200, { ok: true });
         return;
       }
+      if (reqPath.startsWith(DEPS_PREFIX)) {
+        const fileName = reqPath.slice(DEPS_PREFIX.length);
+        if (vendorPackFileName && fileName === vendorPackFileName) {
+          ensureVendorPackFile();
+        }
+        if (fileName.endsWith(".js.map")) {
+          const mapPath = path12.join(depsRoot, fileName);
+          if (fs9.existsSync(mapPath)) {
+            const stat = fs9.statSync(mapPath);
+            const etag = weakEtagFromStat(`deps-map-${depsHash}`, stat);
+            if (isNotModified(req, etag)) {
+              res.setHeader("ETag", etag);
+              res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+              res.statusCode = 304;
+              res.end();
+              return;
+            }
+            sendBuffer(
+              req,
+              res,
+              200,
+              "application/json; charset=utf-8",
+              fs9.readFileSync(mapPath),
+              { etag, cacheControl: "public, max-age=31536000, immutable" }
+            );
+            return;
+          }
+        }
+        const depsFilePath = path12.join(depsRoot, fileName);
+        const entryFromManifest = depsManifestIndex.get(fileName);
+        const entryFromRegistry = getDepEntry(fileName);
+        const entryPath = entryFromManifest?.entryPath ?? entryFromRegistry?.entryPath;
+        const packageLabel = entryFromRegistry?.packageName ? formatDepLabel(entryFromRegistry.packageName, entryFromRegistry.subpath) : entryFromManifest?.packageLabel ?? fileName;
+        if (fs9.existsSync(depsFilePath)) {
+          const stat = fs9.statSync(depsFilePath);
+          const etag = weakEtagFromStat(`deps-${depsHash}`, stat);
+          if (isNotModified(req, etag)) {
+            res.setHeader("ETag", etag);
+            res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+            res.statusCode = 304;
+            res.end();
+            logInfo(`[deps] OPTIMIZE ${packageLabel}: HIT from cache (304)`);
+            return;
+          }
+          sendBuffer(
+            req,
+            res,
+            200,
+            "application/javascript; charset=utf-8",
+            fs9.readFileSync(depsFilePath),
+            { etag, cacheControl: "public, max-age=31536000, immutable" }
+          );
+          logInfo(`[deps] OPTIMIZE ${packageLabel}: HIT from cache`);
+          return;
+        }
+        if (!entryPath || !native?.optimizeDependency) {
+          res.statusCode = 404;
+          res.end("Dependency not found");
+          return;
+        }
+        try {
+          const start = Date.now();
+          const rawSize = fs9.existsSync(entryPath) ? fs9.statSync(entryPath).size : 0;
+          const result2 = native.optimizeDependency(entryPath, depsHash, depsSourcemapEnabled, depsBundleEsmEnabled);
+          const outPath = result2?.out_path ?? result2?.outPath ?? depsFilePath;
+          const mapPath = result2?.map_path ?? result2?.mapPath ?? null;
+          const resolvedOutPath = path12.isAbsolute(outPath) ? outPath : path12.join(depsRoot, outPath);
+          if (!fs9.existsSync(resolvedOutPath)) {
+            throw new Error("Optimizer did not produce output");
+          }
+          const outBuffer = fs9.readFileSync(resolvedOutPath);
+          const optimizedSize = outBuffer.length;
+          const stat = fs9.statSync(resolvedOutPath);
+          const etag = weakEtagFromStat(`deps-${depsHash}`, stat);
+          sendBuffer(req, res, 200, "application/javascript; charset=utf-8", outBuffer, {
+            etag,
+            cacheControl: "public, max-age=31536000, immutable"
+          });
+          const elapsed = Date.now() - start;
+          const rawKb = (rawSize / 1024).toFixed(1);
+          const optKb = (optimizedSize / 1024).toFixed(1);
+          const mapSuffix = mapPath ? ` map=${path12.basename(mapPath)}` : "";
+          logInfo(`[deps] OPTIMIZE ${packageLabel}: MISS \u2192 BUILD (${elapsed}ms, ${rawKb}KB \u2192 ${optKb}KB)${mapSuffix}`);
+          const refreshed = loadDepsManifestIndex(depsRoot);
+          refreshed.forEach((value, key) => depsManifestIndex.set(key, value));
+          return;
+        } catch (err) {
+          logWarn2(
+            `[deps] WARN: Optimization failed for ${packageLabel}, serving raw (fallback): ${String(err)}`
+          );
+          try {
+            const raw = fs9.readFileSync(entryPath);
+            res.writeHead(200, { "Content-Type": "application/javascript; charset=utf-8" });
+            res.end(raw);
+          } catch (readErr) {
+            logError("Failed to read raw dependency", readErr);
+            res.statusCode = 500;
+            res.end("Dependency optimization failed");
+          }
+          return;
+        }
+      }
       const fsPath = decodePublicPath(rootDir, reqPath);
       if (!fsPath) {
         res.statusCode = 404;
@@ -2123,12 +3214,12 @@ async function startDevServer({
       }
       let effectiveFsPath = fsPath;
       let effectiveUrlPath = reqPath;
-      if (fs7.existsSync(effectiveFsPath) && fs7.statSync(effectiveFsPath).isDirectory()) {
+      if (fs9.existsSync(effectiveFsPath) && fs9.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)) {
+          const indexFile = path12.join(effectiveFsPath, `index${ext2}`);
+          if (fs9.existsSync(indexFile)) {
             effectiveFsPath = indexFile;
             effectiveUrlPath = effectiveUrlPath.endsWith("/") ? `${effectiveUrlPath}index${ext2}` : `${effectiveUrlPath}/index${ext2}`;
             found = true;
@@ -2136,13 +3227,13 @@ async function startDevServer({
           }
         }
         if (!found) {
-          const packageJson = path9.join(effectiveFsPath, "package.json");
-          if (fs7.existsSync(packageJson)) {
+          const packageJson = path12.join(effectiveFsPath, "package.json");
+          if (fs9.existsSync(packageJson)) {
             try {
-              const pkg = JSON.parse(fs7.readFileSync(packageJson, "utf8"));
+              const pkg = JSON.parse(fs9.readFileSync(packageJson, "utf8"));
               if (pkg.main) {
-                const mainFile = path9.join(effectiveFsPath, pkg.main);
-                if (fs7.existsSync(mainFile)) {
+                const mainFile = path12.join(effectiveFsPath, pkg.main);
+                if (fs9.existsSync(mainFile)) {
                   effectiveFsPath = mainFile;
                   found = true;
                 }
@@ -2153,8 +3244,8 @@ async function startDevServer({
         }
         if (!found) {
           for (const ext2 of indexExtensions) {
-            const moduleFile = path9.join(effectiveFsPath, `module${ext2}`);
-            if (fs7.existsSync(moduleFile)) {
+            const moduleFile = path12.join(effectiveFsPath, `module${ext2}`);
+            if (fs9.existsSync(moduleFile)) {
               effectiveFsPath = moduleFile;
               found = true;
               break;
@@ -2167,16 +3258,16 @@ async function startDevServer({
           return;
         }
       }
-      if (!fs7.existsSync(effectiveFsPath)) {
+      if (!fs9.existsSync(effectiveFsPath)) {
         res.statusCode = 404;
         res.end("Not found");
         return;
       }
-      const ext = path9.extname(effectiveFsPath);
+      const ext = path12.extname(effectiveFsPath);
       if (isAssetExt(ext)) {
         try {
-          const data = fs7.readFileSync(effectiveFsPath);
-          const assetHash = crypto2.createHash("sha256").update(data).digest("hex");
+          const data = fs9.readFileSync(effectiveFsPath);
+          const assetHash = crypto3.createHash("sha256").update(data).digest("hex");
           const kind = "asset";
           const changed2 = graph.recordFile(effectiveFsPath, assetHash, [], [], kind);
           watcher.watchFile(effectiveFsPath);
@@ -2192,67 +3283,115 @@ async function startDevServer({
           return;
         } else {
           res.writeHead(200, { "Content-Type": contentTypeForAsset(ext) });
-          fs7.createReadStream(effectiveFsPath).pipe(res);
+          fs9.createReadStream(effectiveFsPath).pipe(res);
           return;
         }
       }
       if (ext === ".css") {
         try {
-          const cssSource = fs7.readFileSync(effectiveFsPath, "utf8");
+          const cssSource = fs9.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 mode = "raw" in q ? "css:raw-string" : "url" in q ? "css:url" : isModule ? "css:module" : "inline" in q ? "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");
+          const prevDeps = graph.getNode(effectiveFsPath)?.deps ?? [];
+          for (const dep of prevDeps) {
+            watcher.watchFile(dep);
+          }
+          const depsStampHash = computeDepsStampHash(prevDeps);
+          let artifactHash = getCacheKey(
+            `css:v2:${effectiveFsPath}:${contentHash}:${mode}:${depsStampHash}`
+          );
+          let casDir = getCasArtifactPath(casRoot, configHash, artifactHash);
+          const jsMode = mode !== "css:raw";
+          let casFile = path12.join(casDir, jsMode ? "transformed.js" : "transformed.css");
           let finalBuffer = null;
-          if (fs7.existsSync(casFile)) {
+          if (fs9.existsSync(casFile)) {
             try {
-              finalBuffer = fs7.readFileSync(casFile);
-              res.setHeader("X-Ionify-Cache", "HIT");
+              finalBuffer = fs9.readFileSync(casFile);
+              const ok = jsMode ? looksLikeIonifyCssJsModule(finalBuffer) : !looksLikeIonifyCssJsModule(finalBuffer);
+              if (ok) {
+                res.setHeader("X-Ionify-Cache", "HIT");
+              } else {
+                finalBuffer = null;
+                res.setHeader("X-Ionify-Cache", "MISMATCH");
+              }
             } 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;
+            let body;
+            if (mode === "css:url") {
+              const rawUrl = `${effectiveUrlPath}?v=${contentHash}-${depsStampHash.slice(0, 8)}`;
+              body = renderCssUrlModule(rawUrl);
+            } else {
+              const { css: compiledCss, tokens, deps } = await compileCss({
+                code: cssSource,
+                filePath: effectiveFsPath,
+                rootDir,
+                modules: isModule
+              });
+              const depsAbs2 = deps.map((d) => d.filePath).filter(Boolean);
+              const nextDepsStampHash = computeDepsStampHash(depsAbs2);
+              artifactHash = getCacheKey(
+                `css:v2:${effectiveFsPath}:${contentHash}:${mode}:${nextDepsStampHash}`
+              );
+              casDir = getCasArtifactPath(casRoot, configHash, artifactHash);
+              casFile = path12.join(casDir, jsMode ? "transformed.js" : "transformed.css");
+              const changed2 = graph.recordFile(effectiveFsPath, contentHash, depsAbs2, [], kind);
+              if (changed2) {
+                logInfo(`[Graph] CSS updated: ${effectiveFsPath}`);
+              }
+              for (const dep of depsAbs2) {
+                watcher.watchFile(dep);
+              }
+              if (mode === "css:raw") {
+                body = compiledCss;
+              } else if (mode === "css:raw-string") {
+                body = renderCssRawStringModule(compiledCss);
+              } else {
+                body = renderCssModule({
+                  css: compiledCss,
+                  filePath: effectiveFsPath,
+                  tokens: isModule ? tokens ?? {} : void 0
+                });
+              }
+            }
             finalBuffer = Buffer.from(body, "utf8");
             res.setHeader("X-Ionify-Cache", "MISS");
             try {
-              fs7.mkdirSync(casDir, { recursive: true });
-              fs7.writeFileSync(casFile, finalBuffer);
+              fs9.mkdirSync(casDir, { recursive: true });
+              fs9.writeFileSync(casFile, finalBuffer);
             } catch {
             }
           }
-          if (isModule || isInline) {
-            res.writeHead(200, { "Content-Type": "application/javascript; charset=utf-8" });
+          const etag = `W/"css-${configHash}-${artifactHash}-${mode}"`;
+          if (jsMode) {
+            sendBuffer(req, res, 200, "application/javascript; charset=utf-8", finalBuffer, {
+              etag,
+              cacheControl: "no-cache"
+            });
           } else {
-            res.writeHead(200, { "Content-Type": "text/css; charset=utf-8" });
+            sendBuffer(req, res, 200, "text/css; charset=utf-8", finalBuffer, {
+              etag,
+              cacheControl: "no-cache"
+            });
           }
-          res.end(finalBuffer);
-          logInfo(`Served: ${effectiveUrlPath} deps:0 ${changed2 ? "(updated)" : "(cached)"}`);
+          logInfo(`Served: ${effectiveUrlPath} ${mode}`);
           return;
         } catch (err) {
           logError("Failed to process CSS", err);
+          hmr.broadcastError({
+            message: err instanceof Error ? `Failed to process CSS: ${err.stack || err.message}` : `Failed to process CSS: ${String(err)}`
+          });
           res.statusCode = 500;
           res.end("Failed to process CSS");
           return;
         }
       }
-      const code = fs7.readFileSync(effectiveFsPath, "utf8");
+      const code = fs9.readFileSync(effectiveFsPath, "utf8");
       let hash;
       let specs;
       if (native?.parseModuleIr) {
@@ -2274,23 +3413,40 @@ async function startDevServer({
       for (const dep of depsAbs) {
         watcher.watchFile(dep);
       }
-      const result = await transformer.run({
-        path: effectiveFsPath,
-        code,
-        ext,
-        moduleHash: hash
-      });
+      let result;
+      try {
+        result = await transformer.run({
+          path: effectiveFsPath,
+          code,
+          ext,
+          moduleHash: hash,
+          config: userConfig ?? null
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.stack || err.message : String(err);
+        hmr.broadcastError({ message: `Failed to transform ${effectiveUrlPath}: ${message}` });
+        throw err;
+      }
       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);
+      const withDefine = applyDefineReplacements(transformedCode, defineConfig);
+      const envApplied = applyEnvPlaceholders(withDefine, ext);
+      if (path12.extname(effectiveFsPath) === ".html") {
+        ensureVendorPackFile();
+        const withVendor = vendorPackUrl ? injectModulePreload(envApplied, vendorPackUrl) : envApplied;
+        const injected = injectHMRClient(withVendor);
+        const etag = `W/"html-${configHash}-${hash}"`;
+        sendBuffer(req, res, 200, "text/html; charset=utf-8", Buffer.from(injected, "utf8"), {
+          etag,
+          cacheControl: "no-cache"
+        });
       } else {
         const finalBuffer = Buffer.from(envApplied);
-        res.setHeader("Content-Type", guessContentType(effectiveFsPath));
-        res.end(finalBuffer);
+        const etag = `W/"mod-${configHash}-${hash}"`;
+        sendBuffer(req, res, 200, guessContentType(effectiveFsPath), finalBuffer, {
+          etag,
+          cacheControl: "no-cache"
+        });
       }
       logInfo(`Served: ${effectiveUrlPath} deps:${depsAbs.length} ${changed ? "(updated)" : "(cached)"}`);
       if (cacheDebug) {
@@ -2305,7 +3461,16 @@ async function startDevServer({
   });
   watcher.on("change", (file, status) => {
     logInfo(`[Watcher] ${status}: ${file}`);
-    const affected = graph.collectAffected([file]);
+    const ext = path12.extname(file).toLowerCase();
+    const isReactFastRefreshBoundary = status !== "deleted" && (ext === ".tsx" || ext === ".jsx");
+    const isCssBoundary = status !== "deleted" && ext === ".css";
+    const collected = graph.collectAffected([file]);
+    const affected = isReactFastRefreshBoundary || isCssBoundary ? [
+      file,
+      ...collected.filter(
+        (absPath) => absPath !== file && path12.extname(absPath).toLowerCase() === ".css"
+      )
+    ] : collected;
     if (!affected.includes(file)) {
       affected.unshift(file);
     }
@@ -2316,7 +3481,7 @@ async function startDevServer({
       if (reason !== "deleted") {
         if (absPath === file) {
           try {
-            const code = fs7.readFileSync(absPath, "utf8");
+            const code = fs9.readFileSync(absPath, "utf8");
             hash = getCacheKey(code);
           } catch {
             hash = graph.getNode(absPath)?.hash ?? null;
@@ -2327,7 +3492,7 @@ async function startDevServer({
       }
       modules.push({
         absPath,
-        url: normalizeUrlFromFs(rootDir, absPath),
+        url: path12.extname(absPath).toLowerCase() === ".css" ? `${normalizeUrlFromFs(rootDir, absPath)}?inline` : isAssetExt(path12.extname(absPath).toLowerCase()) ? `${normalizeUrlFromFs(rootDir, absPath)}?import` : normalizeUrlFromFs(rootDir, absPath),
         hash,
         reason
       });
@@ -2415,13 +3580,98 @@ async function startDevServer({
     signalHandlers.push({ event: "SIGINT", handler: onSignal });
     signalHandlers.push({ event: "SIGTERM", handler: onSignal });
   }
-  await new Promise((resolve) => {
-    server.listen(port, () => resolve());
+  await new Promise((resolve, reject) => {
+    const onError = (err) => reject(err);
+    server.once("error", onError);
+    server.listen(port, host, () => {
+      server.off("error", onError);
+      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(`Ready in ${Date.now() - bootStartMs}ms`);
   logInfo(`HMR listening at /__ionify_hmr (SSE)`);
+  if (vendorDeps.length > 0) {
+    const vendorLabels = vendorDeps.map((d) => d.packageLabel).join(", ");
+    logInfo(`[deps] Vendor pack detected (${vendorDeps.length}): ${vendorLabels}`);
+    ensureVendorPackFile();
+    const missing = vendorDeps.filter((d) => !fs9.existsSync(path12.join(depsRoot, d.fileName)));
+    if (missing.length > 0) {
+      const entryCount = missing.length;
+      logInfo(`[deps] Pre-warming vendor deps (${entryCount}) in parallel...`);
+      Promise.resolve().then(() => {
+        if (native?.optimizeDependenciesBatch && !depsSourcemapEnabled && depsBundleEsmEnabled) {
+          const results = native.optimizeDependenciesBatch(
+            missing.map((d) => ({ entryPath: d.entryPath, depsHash }))
+          );
+          results.forEach((r, idx) => {
+            const dep = missing[idx];
+            if (r?.error) {
+              logWarn2(`[deps] Vendor prewarm failed ${dep.packageLabel}: ${r.error}`);
+            } else if (r?.out_path || r?.outPath) {
+              const outPath = r.out_path ?? r.outPath;
+              logInfo(
+                `[deps] \u2713 Vendor prewarmed ${dep.packageLabel} \u2192 ${path12.basename(outPath)}`
+              );
+            }
+          });
+          return;
+        }
+        if (!native?.optimizeDependency) return;
+        for (const dep of missing) {
+          try {
+            const result = native.optimizeDependency(
+              dep.entryPath,
+              depsHash,
+              depsSourcemapEnabled,
+              depsBundleEsmEnabled
+            );
+            const outPath = result?.out_path ?? result?.outPath ?? null;
+            if (outPath) {
+              logInfo(`[deps] \u2713 Vendor prewarmed ${dep.packageLabel} \u2192 ${path12.basename(outPath)}`);
+            }
+          } catch (err) {
+            logWarn2(`[deps] Vendor prewarm failed ${dep.packageLabel}: ${String(err)}`);
+          }
+        }
+      }).catch((err) => {
+        logWarn2(`[deps] Vendor prewarm error: ${err}`);
+      });
+    }
+  }
+  if (userConfig?.optimizeDeps?.include && Array.isArray(userConfig.optimizeDeps.include)) {
+    const includes = userConfig.optimizeDeps.include;
+    if (includes.length > 0) {
+      logInfo(`[deps] Pre-warming ${includes.length} dependencies: ${includes.join(", ")}`);
+      Promise.all(
+        includes.map(async (pkgName) => {
+          try {
+            if (!native?.resolveModule || !native?.optimizeDependency) {
+              logWarn2(`[deps] Cannot pre-warm ${pkgName}: native functions not available`);
+              return;
+            }
+            const resolved = native.resolveModule(pkgName, rootDir);
+            if (!resolved || !resolved.fsPath && !resolved.fs_path) {
+              logWarn2(`[deps] Cannot pre-warm ${pkgName}: resolution failed`);
+              return;
+            }
+            const entryPath = resolved.fsPath || resolved.fs_path;
+            const result = native.optimizeDependency(entryPath, depsHash, depsSourcemapEnabled, depsBundleEsmEnabled);
+            if (result?.out_path) {
+              const fileName = path12.basename(result.out_path);
+              logInfo(`[deps] \u2713 Pre-warmed ${pkgName} \u2192 ${fileName}`);
+            }
+          } catch (err) {
+            logWarn2(`[deps] Failed to pre-warm ${pkgName}: ${err}`);
+          }
+        })
+      ).catch((err) => {
+        logWarn2(`[deps] Pre-warming error: ${err}`);
+      });
+    }
+  }
   return {
     server,
     port: actualPort,
@@ -2432,13 +3682,13 @@ async function startDevServer({
 }
 
 // src/cli/commands/analyze.ts
-import fs8 from "fs";
-import path10 from "path";
+import fs10 from "fs";
+import path13 from "path";
 function readGraphFromDisk(root) {
-  const file = path10.join(root, ".ionify", "graph.json");
-  if (!fs8.existsSync(file)) return null;
+  const file = path13.join(root, ".ionify", "graph.json");
+  if (!fs10.existsSync(file)) return null;
   try {
-    const raw = fs8.readFileSync(file, "utf8");
+    const raw = fs10.readFileSync(file, "utf8");
     const snapshot = JSON.parse(raw);
     if (snapshot?.version !== 1 || !snapshot?.nodes) return null;
     return Object.entries(snapshot.nodes).map(([id, node]) => ({
@@ -2534,8 +3784,8 @@ async function runAnalyzeCommand(options = {}) {
 }
 
 // src/cli/commands/build.ts
-import fs10 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path15 from "path";
 
 // src/cli/utils/optimization-level.ts
 function getOptimizationPreset(level) {
@@ -2624,9 +3874,9 @@ function resolveOptimizationLevel(configLevel, options = {}) {
 }
 
 // src/core/bundler.ts
-import fs9 from "fs";
-import path11 from "path";
-import crypto3 from "crypto";
+import fs11 from "fs";
+import path14 from "path";
+import crypto4 from "crypto";
 function readGraphSnapshot() {
   if (native?.graphLoadMap) {
     try {
@@ -2641,13 +3891,13 @@ function readGraphSnapshot() {
         }));
       }
     } catch (err) {
-      logWarn(`Failed to load native graph: ${String(err)}`);
+      logWarn2(`Failed to load native graph: ${String(err)}`);
     }
   }
-  const file = path11.join(process.cwd(), ".ionify", "graph.json");
-  if (!fs9.existsSync(file)) return [];
+  const file = path14.join(process.cwd(), ".ionify", "graph.json");
+  if (!fs11.existsSync(file)) return [];
   try {
-    const raw = fs9.readFileSync(file, "utf8");
+    const raw = fs11.readFileSync(file, "utf8");
     const snapshot = JSON.parse(raw);
     if (snapshot?.version !== 1 || !snapshot?.nodes) return [];
     return Object.entries(snapshot.nodes).map(([id, node]) => ({
@@ -2656,20 +3906,20 @@ function readGraphSnapshot() {
       deps: Array.isArray(node.deps) ? node.deps : []
     }));
   } catch (err) {
-    logWarn(`Failed to read graph snapshot: ${String(err)}`);
+    logWarn2(`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();
+  const ext = path14.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("/");
+var toPosix = (p) => p.split(path14.sep).join("/");
 function minifyCss(input) {
   return input.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/\s*([{};:,])\s*/g, "$1").trim();
 }
@@ -2804,7 +4054,7 @@ function fallbackPlan(entries) {
 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");
+  const graphDbPath = path14.join(process.cwd(), ".ionify", "graph.db");
   ensureNativeGraph(graphDbPath, version);
   let moduleCount = 0;
   if (native?.graphLoadMap) {
@@ -2817,19 +4067,19 @@ async function generateBuildPlan(entries, versionInputs) {
         logInfo(`Loaded persisted graph with ${graphSize} modules`);
       }
     } catch (err) {
-      logWarn(`Failed to load persisted graph: ${String(err)}`);
+      logWarn2(`Failed to load persisted graph: ${String(err)}`);
     }
   } else {
-    logWarn(`graphLoadMap not available, native binding: ${!!native}`);
+    logWarn2(`graphLoadMap not available, native binding: ${!!native}`);
   }
   if (moduleCount === 0 && entries?.length && native) {
-    logWarn(`[Build] Graph is empty \u2014 rebuilding dependency graph from entries...`);
+    logWarn2(`[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");
+      if (!fs11.existsSync(file)) continue;
+      const code = fs11.readFileSync(file, "utf8");
       let hash = getCacheKey(code);
       let specs = [];
       if (native.parseModuleIr) {
@@ -2875,7 +4125,7 @@ async function generateBuildPlan(entries, versionInputs) {
       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)}`);
+      logWarn2(`plannerPlanBuild failed, falling back to JS planner: ${String(err)}`);
     }
   }
   return fallbackPlan(entries);
@@ -2901,14 +4151,14 @@ async function writeBuildManifest(outputDir, plan, artifacts) {
       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");
+  const dir = path14.resolve(outputDir);
+  await fs11.promises.mkdir(dir, { recursive: true });
+  const file = path14.join(dir, "manifest.json");
+  await fs11.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.");
+    logWarn2("Native buildChunks binding is not available; using JS fallback emitter.");
     const rawArtifacts2 = buildJsFallbackArtifacts(plan, moduleOutputs);
     return emitChunksFromArtifacts(outputDir, plan, moduleOutputs, rawArtifacts2);
   }
@@ -2931,7 +4181,7 @@ ${output.code}`);
     }
     for (const assetPath of chunk.assets) {
       try {
-        const data = fs9.readFileSync(assetPath);
+        const data = fs11.readFileSync(assetPath);
         if (data.length < 4096) {
           const mime = "application/octet-stream";
           const inline = `data:${mime};base64,${data.toString("base64")}`;
@@ -2939,15 +4189,15 @@ ${output.code}`);
 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 hash = crypto4.createHash("sha256").update(data).digest("hex").slice(0, 16);
+        const ext = path14.extname(assetPath) || ".bin";
         const fileName = `assets/${hash}${ext}`;
         assets.push({
           source: assetPath,
           file_name: fileName
         });
       } catch {
-        const fileName = path11.basename(assetPath) || "asset";
+        const fileName = path14.basename(assetPath) || "asset";
         assets.push({
           source: assetPath,
           file_name: fileName
@@ -2980,15 +4230,15 @@ function normalizeNativeArtifact(raw) {
   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")
+    file_name: asset.file_name ?? asset.fileName ?? path14.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 chunkDir = path14.join(outputDir, "chunks");
+  await fs11.promises.mkdir(chunkDir, { recursive: true });
+  const assetsDir = path14.join(outputDir, "assets");
+  await fs11.promises.mkdir(assetsDir, { recursive: true });
   const enableSourceMaps = process.env.IONIFY_SOURCEMAPS === "true";
   const grouped = /* @__PURE__ */ new Map();
   for (const raw of rawArtifacts) {
@@ -3005,8 +4255,8 @@ async function emitChunksFromArtifacts(outputDir, plan, moduleOutputs, rawArtifa
     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 });
+    const chunkOutDir = path14.join(chunkDir, chunk.id);
+    await fs11.promises.mkdir(chunkOutDir, { recursive: true });
     artifacts.sort((a, b) => {
       if (a.id === chunk.id) return -1;
       if (b.id === chunk.id) return 1;
@@ -3019,14 +4269,14 @@ async function emitChunksFromArtifacts(outputDir, plan, moduleOutputs, rawArtifa
     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);
+        const relName = asset.file_name ?? path14.basename(asset.source);
+        const assetFile = path14.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));
+          const data = await fs11.promises.readFile(asset.source);
+          await fs11.promises.mkdir(path14.dirname(assetFile), { recursive: true });
+          await fs11.promises.writeFile(assetFile, data);
+          const rel = toPosix(path14.relative(outputDir, assetFile));
           buildStats[rel] = {
             bytes: data.length,
             emitter: "native",
@@ -3035,7 +4285,7 @@ async function emitChunksFromArtifacts(outputDir, plan, moduleOutputs, rawArtifa
           assetFiles.push(rel);
           assetWritten.add(assetFile);
         } catch (err) {
-          logWarn(`Failed to emit asset ${asset.source}: ${String(err)}`);
+          logWarn2(`Failed to emit asset ${asset.source}: ${String(err)}`);
         }
       }
     };
@@ -3046,11 +4296,11 @@ async function emitChunksFromArtifacts(outputDir, plan, moduleOutputs, rawArtifa
       const cssPieces = [];
       for (const cssPath of cssOrder) {
         let cssSource = moduleOutputs.get(cssPath)?.code;
-        if (!cssSource && fs9.existsSync(cssPath)) {
+        if (!cssSource && fs11.existsSync(cssPath)) {
           try {
-            cssSource = await fs9.promises.readFile(cssPath, "utf8");
+            cssSource = await fs11.promises.readFile(cssPath, "utf8");
           } catch (err) {
-            logWarn(`Failed to read CSS source ${cssPath}: ${String(err)}`);
+            logWarn2(`Failed to read CSS source ${cssPath}: ${String(err)}`);
           }
         }
         if (!cssSource) continue;
@@ -3065,9 +4315,9 @@ async function emitChunksFromArtifacts(outputDir, plan, moduleOutputs, rawArtifa
         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));
+        const cssFilePath = path14.join(outputDir, cssFileName);
+        await fs11.promises.writeFile(cssFilePath, combinedCss, "utf8");
+        cssFileRel = toPosix(path14.relative(outputDir, cssFilePath));
         buildStats[cssFileRel] = {
           bytes: Buffer.byteLength(combinedCss),
           emitter: "native",
@@ -3077,11 +4327,11 @@ async function emitChunksFromArtifacts(outputDir, plan, moduleOutputs, rawArtifa
       }
     }
     for (const artifact of artifacts) {
-      const nativeFile = path11.join(chunkOutDir, artifact.file_name);
+      const nativeFile = path14.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 absCss = path14.join(outputDir, cssFileRel);
+        const relCss = toPosix(path14.relative(path14.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);}})();`;
@@ -3090,10 +4340,10 @@ ${nativeCode}`;
       }
       if (enableSourceMaps && artifact.map) {
         const mapFile = `${nativeFile}.map`;
-        await fs9.promises.writeFile(mapFile, artifact.map, "utf8");
+        await fs11.promises.writeFile(mapFile, artifact.map, "utf8");
         nativeCode = `${nativeCode}
-//# sourceMappingURL=${path11.basename(mapFile)}`;
-        const relMap = toPosix(path11.relative(outputDir, mapFile));
+//# sourceMappingURL=${path14.basename(mapFile)}`;
+        const relMap = toPosix(path14.relative(outputDir, mapFile));
         buildStats[relMap] = {
           bytes: artifact.map_bytes,
           emitter: "native",
@@ -3101,8 +4351,8 @@ ${nativeCode}`;
         };
         jsFiles.push(relMap);
       }
-      await fs9.promises.writeFile(nativeFile, nativeCode, "utf8");
-      const relNative = toPosix(path11.relative(outputDir, nativeFile));
+      await fs11.promises.writeFile(nativeFile, nativeCode, "utf8");
+      const relNative = toPosix(path14.relative(outputDir, nativeFile));
       buildStats[relNative] = {
         bytes: artifact.code_bytes,
         emitter: "native",
@@ -3119,21 +4369,21 @@ ${nativeCode}`;
         const output = moduleOutputs.get(cssPath);
         if (output?.type === "css") {
           cssSources.push(output.code);
-        } else if (fs9.existsSync(cssPath)) {
+        } else if (fs11.existsSync(cssPath)) {
           try {
-            cssSources.push(await fs9.promises.readFile(cssPath, "utf8"));
+            cssSources.push(await fs11.promises.readFile(cssPath, "utf8"));
           } catch (err) {
-            logWarn(`Failed to read CSS source ${cssPath}: ${String(err)}`);
+            logWarn2(`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 cssHash = crypto4.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);
+        const cssFilePath = path14.join(chunkOutDir, cssFileName);
+        await fs11.promises.writeFile(cssFilePath, combinedCss, "utf8");
+        const relCss = path14.relative(outputDir, cssFilePath);
         buildStats[relCss] = {
           bytes: Buffer.byteLength(combinedCss),
           emitter: "native",
@@ -3154,14 +4404,14 @@ ${nativeCode}`;
   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 dir = path14.resolve(outputDir);
+  await fs11.promises.mkdir(dir, { recursive: true });
+  const file = path14.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");
+  await fs11.promises.writeFile(file, JSON.stringify(payload, null, 2), "utf8");
 }
 
 // src/core/worker/pool.ts
@@ -3203,7 +4453,7 @@ var TransformWorkerPool = class {
       this.dequeue(worker);
     });
     worker.on("error", (err) => {
-      logWarn(`Transform worker error: ${String(err)}`);
+      logWarn2(`Transform worker error: ${String(err)}`);
       const item = this.active.get(id);
       if (item) {
         this.active.delete(id);
@@ -3218,7 +4468,7 @@ var TransformWorkerPool = class {
         this.queue.unshift(item);
       }
       if (!this.closed && code !== 0) {
-        logWarn(`Transform worker exited unexpectedly (${code}), respawning`);
+        logWarn2(`Transform worker exited unexpectedly (${code}), respawning`);
         this.spawnWorker();
       }
     });
@@ -3293,6 +4543,7 @@ var TransformWorkerPool = class {
 async function runBuildCommand(options = {}) {
   try {
     const config = await loadIonifyConfig();
+    const rootDir = config?.root || process.cwd();
     const optLevel = resolveOptimizationLevel(config?.optimizationLevel, {
       cliLevel: options.level,
       envLevel: process.env.IONIFY_OPTIMIZATION_LEVEL
@@ -3321,11 +4572,10 @@ async function runBuildCommand(options = {}) {
         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;
+    const entries = config?.entry ? (Array.isArray(config.entry) ? config.entry : [config.entry]).map(
+      (entry) => entry.startsWith("/") ? path15.join(rootDir, entry) : path15.resolve(rootDir, entry)
+    ) : void 0;
     if (entries) {
       logInfo(`Build entries: ${entries.join(", ")}`);
     } else {
@@ -3367,11 +4617,11 @@ async function runBuildCommand(options = {}) {
     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 jobs = Array.from(uniqueModules).filter((filePath) => fs12.existsSync(filePath)).map((filePath) => {
+        const code = fs12.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 cacheKey = getCacheKey(`build-worker:v1:${path15.extname(filePath)}:${moduleHash}:${filePath}`);
         const cached = readCache(cacheKey);
         if (cached) {
           try {
@@ -3379,13 +4629,13 @@ async function runBuildCommand(options = {}) {
             if (parsed?.code) {
               const transformedHash = getCacheKey(parsed.code);
               moduleHashes.set(filePath, transformedHash);
-              const casRoot2 = path12.join(process.cwd(), ".ionify", "cas");
+              const casRoot2 = path15.join(rootDir, ".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 (!fs12.existsSync(path15.join(cacheDir, "transformed.js"))) {
+                fs12.mkdirSync(cacheDir, { recursive: true });
+                fs12.writeFileSync(path15.join(cacheDir, "transformed.js"), parsed.code, "utf8");
                 if (parsed.map) {
-                  fs10.writeFileSync(path12.join(cacheDir, "transformed.js.map"), parsed.map, "utf8");
+                  fs12.writeFileSync(path15.join(cacheDir, "transformed.js.map"), parsed.map, "utf8");
                 }
               }
               moduleOutputs.set(filePath, { code: parsed.code, type: parsed.type ?? "js" });
@@ -3397,7 +4647,7 @@ async function runBuildCommand(options = {}) {
         return {
           id: filePath,
           filePath,
-          ext: path12.extname(filePath),
+          ext: path15.extname(filePath),
           code,
           cacheKey
         };
@@ -3420,13 +4670,13 @@ async function runBuildCommand(options = {}) {
         writeCache(job.cacheKey, Buffer.from(payload));
         const transformedHash = getCacheKey(result.code);
         const moduleHash = transformedHash;
-        const casRoot2 = path12.join(process.cwd(), ".ionify", "cas");
+        const casRoot2 = path15.join(rootDir, ".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");
+        fs12.mkdirSync(cacheDir, { recursive: true });
+        fs12.writeFileSync(path15.join(cacheDir, "transformed.js"), result.code, "utf8");
         if (result.map) {
-          fs10.writeFileSync(path12.join(cacheDir, "transformed.js.map"), result.map, "utf8");
+          fs12.writeFileSync(path15.join(cacheDir, "transformed.js.map"), result.map, "utf8");
         }
         moduleHashes.set(job.filePath, moduleHash);
         for (const chunk of plan.chunks) {
@@ -3449,20 +4699,20 @@ async function runBuildCommand(options = {}) {
         }
       }
     }
-    const absOutDir = path12.resolve(outDir);
-    const casRoot = path12.join(process.cwd(), ".ionify", "cas");
+    const absOutDir = path15.resolve(outDir);
+    const casRoot = path15.join(rootDir, ".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"),
+    await fs12.promises.writeFile(
+      path15.join(absOutDir, "build.stats.json"),
       JSON.stringify(stats, null, 2),
       "utf8"
     );
-    logInfo(`Build plan generated \u2192 ${path12.join(absOutDir, "manifest.json")}`);
+    logInfo(`Build plan generated \u2192 ${path15.join(absOutDir, "manifest.json")}`);
     logInfo(`Entries: ${plan.entries.length}, Chunks: ${plan.chunks.length}`);
     logInfo(`Modules transformed: ${moduleOutputs.size}`);
   } catch (err) {