vitral 0.7.2 → 0.8.0

package/dist/vite.js

@@ -1,3 +1,9 @@
+import {
+  BOOT,
+  dedupeHooks,
+  dedupeIds,
+  groups
+} from "./chunk-6AFVJCQG.js";
 import {
   extractProps,
   typesFile
@@ -5,8 +11,9 @@ import {
 
 // src/vite.ts
 import { createHash as createHash3 } from "crypto";
-import { readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4, resolve as resolve4 } from "path";
+import { createRequire as createRequire3 } from "module";
+import { readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5, resolve as resolve4 } from "path";
 
 // src/vite-exposes.ts
 import { resolve } from "path";
@@ -37,9 +44,13 @@ import { createHash } from "crypto";
 import { readFileSync, rmSync, writeFileSync } from "fs";
 import { join, posix } from "path";
 var SPLIT = "split/";
+var PROBES = [
+  [`${SPLIT}vitral-probe.js`, "export{}"],
+  [`${SPLIT}vitral-probe-x.js`, "export{}//"]
+];
 var sri = (file) => "sha384-" + createHash("sha384").update(readFileSync(file)).digest("base64");
 function outputs(rolldown, hints = false) {
-  const banner = hints ? { banner: compileHint } : {};
+  const banner = hints ? { [rolldown ? "postBanner" : "banner"]: compileHint } : {};
   return [
     { format: "es", ...banner, ...rolldown ? { codeSplitting: false } : { inlineDynamicImports: true } },
     // Os assets saem com o mesmo nome nas duas (o Vite só aceita um padrão).
@@ -75,7 +86,15 @@ function collect(outDir, bundle) {
     for (const d of live.get(entry)) if (!Object.values(own).some((o) => o.file === d)) soon.add(d), deps(d, soon);
   }
   soon.delete(entry);
-  return { entry, chunks: [...soon], files: [...used], own };
+  const ownFiles = new Set(Object.values(own).map((o) => o.file));
+  const app = /* @__PURE__ */ new Set();
+  const stack = [entry];
+  while (stack.length) {
+    const n = stack.pop();
+    for (const d of [...byName.get(n)?.imports ?? [], ...live.get(n)]) if (byName.has(d) && !ownFiles.has(d) && !app.has(d)) app.add(d), stack.push(d);
+  }
+  const lazy = [...app].filter((n) => n !== entry && !soon.has(n));
+  return { entry, chunks: [...soon], files: [...used], own, lazy };
 }
 function rewrite(file, c, byName, deps) {
   const targets = c.dynamicImports.filter((d) => byName.has(d));
@@ -109,7 +128,8 @@ function withSplit(m, outDir, s, groups2 = []) {
   const files = {};
   for (const f of [m.entry, ...m.css ?? [], ...m.shadow?.css ?? [], ...m.shadow?.global ?? [], ...s?.files ?? []]) files[f] = sri(join(outDir, f));
   const dedupe = groups2.filter((g) => s?.own[g.name]).map(({ name, range, version }) => ({ name, range, version, ...s.own[name] }));
-  return { ...m, files, ...s && { split: { entry: s.entry, chunks: s.chunks } }, ...dedupe.length && { dedupe } };
+  if (s) for (const [file, code] of PROBES) writeFileSync(join(outDir, file), code);
+  return { ...m, files, ...s && { split: { entry: s.entry, chunks: s.chunks, ...s.lazy.length && { lazy: s.lazy } }, probe: PROBES.map(([f]) => f) }, ...dedupe.length && { dedupe } };
 }
 
 // src/vite/sbom.ts
@@ -252,114 +272,6 @@ function createSbom(input) {
   };
 }
 
-// src/vite/dedupe.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
-import { pathToFileURL } from "url";
-var REACT = ["react", "react-dom", "react-dom/client", "react/jsx-runtime", "react/jsx-dev-runtime", "react/compiler-runtime"];
-var BOOT = "virtual:vitral-boot";
-var DEPS = "\0vitral-deps";
-var OWN = "\0vitral-own:";
-var SHIM = "\0vitral-shim:";
-var pkgOf = (spec) => spec.split("/").slice(0, spec.startsWith("@") ? 2 : 1).join("/");
-var groupOf = (spec) => REACT.includes(spec) || pkgOf(spec) === "scheduler" ? "react" : pkgOf(spec);
-var ident = /^[A-Za-z_$][\w$]*$/;
-function versionOf(file, pkg) {
-  for (let dir = dirname2(file); dir !== dirname2(dir); dir = dirname2(dir)) {
-    const json = join3(dir, "package.json");
-    if (!existsSync2(json)) continue;
-    const data = JSON.parse(readFileSync3(json, "utf8"));
-    if (data.name === pkg) return data.version;
-  }
-  throw new Error(`vitral: vers\xE3o de ${pkg} n\xE3o encontrada`);
-}
-async function groups(list, root, entry, resolveId) {
-  const importer = resolve2(root, entry);
-  const byName = /* @__PURE__ */ new Map();
-  for (const spec of list) {
-    const g = groupOf(spec);
-    byName.set(g, [.../* @__PURE__ */ new Set([...byName.get(g) ?? [], ...g === "react" ? REACT : [spec]])]);
-  }
-  const out = [];
-  for (const [name, specs] of byName) {
-    const group = { name, range: "", version: "", keys: [], names: {}, pkgs: name === "react" ? ["react", "react-dom", "scheduler"] : [name] };
-    for (const spec of specs) {
-      const found = await resolveId(spec, importer);
-      if (!found) {
-        if (spec === name) throw new Error(`vitral: dedupe: ${spec} n\xE3o est\xE1 instalado`);
-        continue;
-      }
-      const mod = await import(pathToFileURL(found.id.split("?")[0]).href);
-      const extra = mod.default && typeof mod.default === "object" ? Object.keys(mod.default) : [];
-      group.names[spec] = [.../* @__PURE__ */ new Set([...Object.keys(mod), ...extra])].filter((n) => n !== "default" && ident.test(n));
-      group.keys.push(spec);
-      if (spec === name) group.version = versionOf(found.id, name);
-    }
-    group.range = name === "svelte" || name.startsWith("@angular/") ? group.version : `^${group.version}`;
-    out.push(group);
-  }
-  return out;
-}
-var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\0/g, "\\x00");
-function dedupeIds(list) {
-  const specs = new Set(list.flatMap((s) => groupOf(s) === "react" ? REACT : [s]));
-  return new RegExp(`${escape(BOOT)}$|^(${[DEPS, ...specs].map(escape).join("|")})$|^(${escape(OWN)}|${escape(SHIM)})`);
-}
-function dedupeHooks(entry, getGroups) {
-  const keyOf = (id) => getGroups().find((g) => g.keys.includes(id));
-  return {
-    resolveId: {
-      order: "pre",
-      handler(id, importer) {
-        if (id.endsWith(BOOT)) return `\0${BOOT}`;
-        if (id === DEPS || id.startsWith(OWN) || id.startsWith(SHIM)) return id;
-        const g = keyOf(id);
-        if (!g || !importer || importer.startsWith(OWN)) return null;
-        const norm = importer.replace(/\\/g, "/");
-        if (g.pkgs.some((p) => norm.includes(`/node_modules/${p}/`))) return null;
-        return SHIM + id;
-      }
-    },
-    load(id) {
-      if (id === `\0${BOOT}`) return boot(entry(), getGroups());
-      if (id === DEPS) return "export const deps = {}";
-      if (id.startsWith(OWN)) {
-        const g = getGroups().find((x) => x.name === id.slice(OWN.length));
-        return g.keys.map((k, i) => `import * as m${i} from ${JSON.stringify(k)}`).join("\n") + `
-export default {${g.keys.map((k, i) => `${JSON.stringify(k)}: m${i}`).join(", ")}}
-`;
-      }
-      if (id.startsWith(SHIM)) {
-        const spec = id.slice(SHIM.length);
-        const names = keyOf(spec).names[spec];
-        return `import { deps } from ${JSON.stringify(DEPS)}
-const m = deps[${JSON.stringify(spec)}]
-export default m.default ?? m
-` + (names.length ? `export const { ${names.join(", ")} } = m
-` : "");
-      }
-      return null;
-    }
-  };
-}
-function boot(entry, groups2) {
-  const calls = groups2.map(
-    (g) => `need(${JSON.stringify(g.name)}, ${JSON.stringify(g.range)}, ${JSON.stringify(g.version)}, ${JSON.stringify(g.keys)}, () => import(${JSON.stringify(OWN + g.name)}).then((m) => m.default))`
-  );
-  return `const { deps } = await import(${JSON.stringify(DEPS)})
-const p = globalThis[Symbol.for("vitral")]
-const shared = !!(p && p.dedupe) && /\\/split\\/[^/]*$/.test(import.meta.url)
-async function need(name, range, version, keys, load) {
-  let m = shared && (await p.dedupe(name, range, { version, load }))
-  if (!m || keys.some((k) => !(k in m))) m = await load()
-  Object.assign(deps, m)
-}
-await Promise.all([${calls.join(", ")}])
-const remote = await import(${JSON.stringify(entry)})
-export default remote.default
-`;
-}
-
 // src/css-build.ts
 import postcss2 from "postcss";
 
@@ -564,8 +476,8 @@ function splitShadowCss(text) {
 }
 
 // src/vite/adapter.ts
-import { existsSync as existsSync3 } from "fs";
-import { resolve as resolve3 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
 var PLUGINS = [
   [/^(preact:|prefresh$)/, "preact"],
   [/^vite:react/, "react"],
@@ -588,14 +500,17 @@ var WRAP = {
 };
 var ENTRY_ID = "__vitral_entry__.js";
 var VIRTUAL_ENTRY = "\0vitral:entry";
-function entryCode(file, adapter, scope) {
+function entryCode(file, adapter, scope, next = false) {
   const head = `import * as m from ${JSON.stringify(file)}
 const c = m.default ?? m
 `;
   if (adapter !== "element") {
     const [from, fn] = WRAP[adapter];
-    return `${head}import { ${fn} as wrap } from '${from}'
-export default typeof c?.mount === 'function' ? c : wrap(c)
+    const inner = next && adapter === "react" ? "nextRemote(c)" : "c";
+    const bridge = inner === "c" ? "" : `import { nextRemote } from 'vitral/next'
+`;
+    return `${head}${bridge}import { ${fn} as wrap } from '${from}'
+export default typeof c?.mount === 'function' ? c : wrap(${inner})
 `;
   }
   return `${head}import { elementRemote } from 'vitral/element'
@@ -622,7 +537,7 @@ var CANDIDATES = ["src/remote", "src/App", "src/app"];
 var EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".vue", ".svelte"];
 function findEntry(root) {
   for (const base of CANDIDATES) {
-    for (const ext of EXTENSIONS) if (existsSync3(resolve3(root, base + ext))) return base + ext;
+    for (const ext of EXTENSIONS) if (existsSync2(resolve2(root, base + ext))) return base + ext;
   }
 }
 
@@ -736,6 +651,209 @@ function mcpAppHtml(page) {
 `;
 }
 
+// src/vite/minify.ts
+var HINT = "//# allFunctionsCalledOnLoad";
+async function minifyWhitespace(code, file, sourcemap) {
+  const vite = await import("vite");
+  const hint = code.startsWith(HINT);
+  if (typeof vite.transformWithEsbuild !== "function") return null;
+  const out = await vite.transformWithEsbuild(code, file, { minifyWhitespace: true, legalComments: "none", format: "esm", loader: "js", sourcemap });
+  if (!hint || out.code.startsWith(HINT)) return { code: out.code, map: out.map };
+  const map = out.map && typeof out.map === "object" ? { ...out.map, mappings: ";" + out.map.mappings } : out.map;
+  return { code: `${HINT}
+${out.code}`, map };
+}
+
+// src/vite/next.ts
+var MODULES = {
+  "next/link": 'export { Link as default } from "vitral/next"',
+  "next/image": 'export { Image as default } from "vitral/next"',
+  "next/head": 'export { Head as default } from "vitral/next"',
+  "next/dynamic": 'export { dynamic as default } from "vitral/next"',
+  "next/router": 'export { useRouter, withRouter, Router as default } from "vitral/next"',
+  "next/navigation": 'export { useAppRouter as useRouter, usePathname, useSearchParams, useParams, redirect, notFound } from "vitral/next"',
+  "next/dist/shared/lib/router-context.shared-runtime": 'export { RouterContext } from "vitral/next"'
+};
+var NEXT_IDS = /^next\/(link|image|head|dynamic|router|navigation|dist\/shared\/lib\/router-context\.shared-runtime)(\.js)?$/;
+var PREFIX = "\0vitral-next:";
+function resolveNextId(id) {
+  const name = id.replace(/\.js$/, "");
+  return MODULES[name] ? PREFIX + name : void 0;
+}
+function loadNext(id, options) {
+  if (!id.startsWith(PREFIX)) return;
+  const code = MODULES[id.slice(PREFIX.length)];
+  return code && `import { setBasePath } from "vitral/next"
+setBasePath(${JSON.stringify(options.basePath ?? "")})
+${code}
+`;
+}
+function nextDefine(env, mode) {
+  const vars = { NODE_ENV: mode === "development" ? "development" : "production" };
+  for (const [k, v] of Object.entries(env)) if (k.startsWith("NEXT_PUBLIC_")) vars[k] = v;
+  return {
+    "process.env": JSON.stringify(vars),
+    ...Object.fromEntries(Object.entries(vars).map(([k, v]) => [`process.env.${k}`, JSON.stringify(v)]))
+  };
+}
+
+// src/vite/tsconfig.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, statSync } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname2, join as join3, resolve as resolve3 } from "path";
+function parseJsonc(text) {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c === '"') {
+      const end = /"(?:[^"\\]|\\.)*"/y;
+      end.lastIndex = i;
+      const m = end.exec(text);
+      const s = m ? m[0] : text.slice(i);
+      out += s;
+      i += s.length - 1;
+    } else if (c === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") i++;
+      out += "\n";
+    } else if (c === "/" && text[i + 1] === "*") {
+      i = text.indexOf("*/", i + 2);
+      if (i < 0) break;
+      i++;
+    } else out += c;
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+function read(file, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(file)) return {};
+  seen.add(file);
+  const json = parseJsonc(readFileSync3(file, "utf8"));
+  const dir = dirname2(file);
+  let inherited = {};
+  for (const ext of [json.extends ?? []].flat()) {
+    try {
+      const from = ext.startsWith(".") ? resolve3(dir, ext) : createRequire(file).resolve(ext);
+      inherited = { ...inherited, ...read(existsSync3(from) ? from : from + ".json", seen) };
+    } catch {
+    }
+  }
+  const o = json.compilerOptions ?? {};
+  const baseUrl = o.baseUrl != null ? resolve3(dir, o.baseUrl) : inherited.baseUrl;
+  return {
+    baseUrl,
+    paths: o.paths ?? inherited.paths,
+    // Sem baseUrl, os alvos de `paths` são relativos ao tsconfig que os declara.
+    pathsBase: o.paths ? o.baseUrl != null ? baseUrl : dir : inherited.pathsBase
+  };
+}
+var cache = /* @__PURE__ */ new Map();
+function pathsFor(file) {
+  const c = tsconfigFor(dirname2(file));
+  const n = (p) => p.replace(/\\/g, "/");
+  return c && n(file).includes("/node_modules/") && !n(c.dir).includes("/node_modules/") ? null : c;
+}
+function tsconfigFor(dir) {
+  if (cache.has(dir)) return cache.get(dir);
+  const file = join3(dir, "tsconfig.json");
+  let found;
+  if (existsSync3(file)) {
+    try {
+      const c = read(file);
+      found = c.paths ? { dir, base: c.pathsBase ?? dir, paths: c.paths } : null;
+    } catch {
+      found = null;
+    }
+  } else found = dirname2(dir) === dir ? null : tsconfigFor(dirname2(dir));
+  cache.set(dir, found);
+  return found;
+}
+function pathCandidates(id, c) {
+  let best;
+  for (const [key, targets] of Object.entries(c.paths)) {
+    const star = key.indexOf("*");
+    if (star < 0 ? id !== key : !(id.startsWith(key.slice(0, star)) && id.endsWith(key.slice(star + 1)) && id.length >= key.length - 1)) continue;
+    const size = star < 0 ? Infinity : star;
+    if (!best || size > best.size) best = { targets, rest: star < 0 ? "" : id.slice(star, id.length - (key.length - star - 1)), size };
+  }
+  if (!best) return;
+  const out = best.targets.map((t) => {
+    const path = resolve3(c.base, t.replace("*", best.rest));
+    return path.replace(/\\/g, "/").endsWith(`/node_modules/${id}`) ? id : path;
+  });
+  return out.every((t) => t === id) ? void 0 : out;
+}
+var EXTENSIONS2 = ["", ".ts", ".tsx", ".mts", ".js", ".jsx", ".mjs", "/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+function fileOf(path) {
+  for (const ext of EXTENSIONS2) {
+    try {
+      if (statSync(path + ext).isFile()) return path + ext;
+    } catch {
+    }
+  }
+}
+function resolvePath(id, importer) {
+  const config = pathsFor(importer);
+  const candidates = config && pathCandidates(id, config);
+  for (const c of candidates ?? []) {
+    if (c === id) return;
+    const file = fileOf(c);
+    if (file) return file;
+  }
+}
+function optimizerPaths(rolldown) {
+  if (rolldown)
+    return {
+      rolldownOptions: {
+        plugins: [{ name: "vitral:paths", resolveId: (id, importer) => importer && !/^[./\0]/.test(id) ? resolvePath(id, importer) : void 0 }]
+      }
+    };
+  return {
+    esbuildOptions: {
+      plugins: [
+        {
+          name: "vitral:paths",
+          setup(build) {
+            build.onResolve({ filter: /^[^./]/ }, (args) => {
+              const file = args.importer && resolvePath(args.path, args.importer);
+              return file ? { path: file } : void 0;
+            });
+          }
+        }
+      ]
+    }
+  };
+}
+
+// src/vite/svg.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { basename, join as join4 } from "path";
+import { pathToFileURL } from "url";
+async function svgComponents(root) {
+  const req = createRequire2(join4(root, "package.json"));
+  const load = async (id) => import(pathToFileURL(req.resolve(id)).href).then((m) => m.default ?? m);
+  let svgr;
+  let plugins;
+  try {
+    svgr = (await load("@svgr/core")).transform;
+    plugins = [await load("@svgr/plugin-jsx")];
+  } catch {
+    return;
+  }
+  try {
+    plugins.unshift(await load("@svgr/plugin-svgo"));
+  } catch {
+  }
+  const vite = await import("vite");
+  return {
+    async transform(file) {
+      const name = basename(file, ".svg").replace(/(^|[^a-zA-Z0-9])([a-zA-Z0-9])/g, (_, _s, c) => c.toUpperCase());
+      const jsx = await svgr(readFileSync4(file, "utf8"), { plugins, jsxRuntime: "automatic" }, { filePath: file, componentName: `Svg${name}` });
+      const out = vite.transformWithOxc ? await vite.transformWithOxc(jsx, file + ".jsx", { lang: "jsx", jsx: { runtime: "automatic" } }) : await vite.transformWithEsbuild(jsx, file + ".jsx", { loader: "jsx", jsx: "automatic" });
+      return { code: out.code, map: null };
+    }
+  };
+}
+
 // src/vite/dev.ts
 var DEV_ENTRY = "@vitral/entry.js";
 var VIRTUAL_DEV_ENTRY = "\0vitral:dev-entry";
@@ -839,19 +957,25 @@ function vitral(options = {}) {
   let framework = "element";
   const entryFile = () => resolve4(root, entry);
   let serve = false;
+  let minify = false;
+  let rolldown = false;
   let shared = [];
+  let svg;
   const dedupe = !!options.dedupe?.length;
   const hooks = dedupeHooks(() => options.exposes ? EXPOSES_ENTRY : options.adapter === false ? entryFile() : ENTRY_ID, () => shared);
   const mcp = options.target === "mcp-app";
+  const next = options.next === true ? {} : options.next || void 0;
+  const paths = !!next && next.tsconfigPaths !== false;
+  const files = !!options.dedupe?.some((d) => d.endsWith("/*"));
   if (mcp && (options.exposes || dedupe || options.shared?.length)) {
     throw new Error("[vitral] target: 'mcp-app' gera um HTML \xFAnico: n\xE3o combina com exposes, dedupe nem shared.");
   }
   const scopeName = () => (options.name ?? pkg.name ?? "remote").replace(/[^a-zA-Z0-9_-]/g, "-");
-  const mcpApp = (files, js) => {
-    const css = files.filter((f) => f.type === "asset" && f.fileName.endsWith(".css")).map((f) => f.fileName);
-    const read = (file) => {
-      const text = readFileSync4(join4(outDir, file), "utf8");
-      rmSync2(join4(outDir, file));
+  const mcpApp = (files2, js) => {
+    const css = files2.filter((f) => f.type === "asset" && f.fileName.endsWith(".css")).map((f) => f.fileName);
+    const read2 = (file) => {
+      const text = readFileSync5(join5(outDir, file), "utf8");
+      rmSync2(join5(outDir, file));
       return text;
     };
     const scope = options.scopeCss === false ? void 0 : scopeName();
@@ -859,27 +983,28 @@ function vitral(options = {}) {
       name: options.name ?? pkg.name ?? "remote",
       version: options.version ?? pkg.version,
       scope,
-      code: read(js),
-      css: css.map((f) => transformCss(read(f), options, scopeName()))
+      code: read2(js),
+      css: css.map((f) => transformCss(read2(f), options, scopeName()))
     });
-    writeFileSync2(join4(outDir, "mcp-app.html"), html);
+    writeFileSync2(join5(outDir, "mcp-app.html"), html);
   };
   return {
     name: "vitral",
-    config(user, { mode, command }) {
+    async config(user, { mode, command }) {
       entry ??= findEntry(resolve4(user.root ?? process.cwd()));
       if (!entry) throw new Error("[vitral] n\xE3o achei a entrada do remote (src/remote.* ou src/App.*). Use vitral({ entry }).");
-      const rolldown = "rolldownVersion" in this.meta;
+      rolldown = "rolldownVersion" in (this?.meta ?? {});
+      if (next && command === "build" && mode !== "development" && process.env.VITE_USER_NODE_ENV === void 0) process.env.VITE_USER_NODE_ENV = "";
+      const whitespace = rolldown && user.build?.minify !== false ? { minify: { codegen: { removeWhitespace: true } } } : {};
       const dir = options.versionDir ? versionDir(user.root ?? process.cwd(), user.build?.outDir, options.version) : void 0;
       return {
         // Código de biblioteca não tem process.env; React e Vue precisam disso.
-        define: { "process.env.NODE_ENV": JSON.stringify(mode === "development" ? "development" : "production") },
+        define: next ? nextDefine({ ...process.env, ...(await import("vite")).loadEnv(mode, user.root ?? process.cwd(), "NEXT_PUBLIC_") }, mode) : { "process.env.NODE_ENV": JSON.stringify(mode === "development" ? "development" : "production") },
         server: { cors: true },
-        ...command === "serve" && { optimizeDeps: devOptimizeDeps(user.plugins, entry, options.adapter) },
         preview: { cors: true },
         // O remote não tem index.html: sem isso o Vite só descobre as
         // dependências no primeiro request e recarrega a página do host.
-        optimizeDeps: user.optimizeDeps?.entries ? void 0 : { entries: [entry] },
+        optimizeDeps: optimizeDeps(command === "serve", user, entry, options.adapter, next && { rolldown, paths }),
         build: mcp ? {
           // Um IIFE só, sem chunks: o HTML do MCP App não pode buscar arquivos.
           lib: { entry: options.adapter === false ? entry : ENTRY_ID, formats: ["iife"], name: MCP_APP_GLOBAL, fileName: () => "mcp-app.js", cssFileName: "remote" },
@@ -889,8 +1014,14 @@ function vitral(options = {}) {
           // Nomes com hash: cache eterno no CDN. Só o vitral.json muda a cada deploy.
           lib: { entry: dedupe ? BOOT : options.exposes ? EXPOSES_ENTRY : options.adapter === false ? entry : ENTRY_ID, fileName: () => "remote-[hash].js", cssFileName: "remote" },
           // Arquivo único (hosts antigos e caminho com blob:) e build dividido (manifesto v2).
-          rollupOptions: { external: options.shared ?? [], output: outputs(rolldown, !!options.compileHints) },
+          rollupOptions: {
+            external: options.shared ?? [],
+            output: outputs(rolldown, !!options.compileHints).map((o) => ({ ...o, ...whitespace })),
+            ...options.sideEffectFree?.length && { treeshake: { moduleSideEffects: pureExcept(options.sideEffectFree) } }
+          },
           cssCodeSplit: false,
+          // A entrada do dedupe usa top-level await, fora do target padrão do Vite 5 e 6.
+          ...dedupe && !user.build?.target && { target: "es2022" },
           ...dir && { outDir: dir }
         }
       };
@@ -900,14 +1031,21 @@ function vitral(options = {}) {
       framework = detectAdapter(c.plugins);
       adapter = options.adapter || framework;
       serve = c.command === "serve";
+      minify = !serve && c.build.minify !== false;
+      if (!serve && c.mode !== "development" && process.env.NODE_ENV === "development") {
+        throw new Error("[vitral] NODE_ENV=development (de um .env?) num build de produ\xE7\xE3o: o JSX sai com jsxDEV e o remote quebra. Rode com NODE_ENV=production.");
+      }
       outDir = resolve4(c.root, c.build.outDir);
       try {
-        pkg = JSON.parse(readFileSync4(join4(root, "package.json"), "utf8"));
+        pkg = JSON.parse(readFileSync5(join5(root, "package.json"), "utf8"));
       } catch {
       }
     },
     async buildStart() {
-      if (dedupe && !serve) shared = await groups(options.dedupe, root, entry, (id, importer) => this.resolve(id, importer, { skipSelf: true }));
+      if (dedupe && !serve) {
+        hooks.reset();
+        shared = await groups(options.dedupe, root, entry, nodeResolve);
+      }
     },
     // Modo dev: /vitral.json aponta para um módulo com o cliente HMR.
     configureServer(server) {
@@ -918,28 +1056,67 @@ function vitral(options = {}) {
     // nem chegam ao JS. As checagens nos handlers continuam para Vite 5 e 6.0-6.2.
     resolveId: {
       order: "pre",
-      filter: { id: [...dedupe ? [dedupeIds(options.dedupe)] : [], ...options.exposes ? [EXPOSES_IDS] : [], /__vitral_entry__\.js$/, DEV_IDS] },
-      handler(id, importer) {
+      filter: {
+        id: [
+          ...dedupe ? [dedupeIds(options.dedupe)] : [],
+          ...options.exposes ? [EXPOSES_IDS] : [],
+          ...next ? [NEXT_IDS] : [],
+          // `paths` do tsconfig e dedupe de `pacote/*`: qualquer import que não é relativo.
+          ...paths || files ? [/^[^.\0]/] : [],
+          /__vitral_entry__\.js$/,
+          DEV_IDS
+        ]
+      },
+      async handler(id, importer, opts) {
+        const shim = next && resolveNextId(id);
+        if (shim) return shim;
         const own = dedupe && !serve ? hooks.resolveId.handler(id, importer) : null;
         if (own) return own;
         if (options.exposes && resolveExposesId(id)) return resolveExposesId(id);
         if (id.endsWith(ENTRY_ID)) return VIRTUAL_ENTRY;
-        return resolveDevId(id);
+        const dev = resolveDevId(id);
+        if (dev) return dev;
+        if (!importer || importer.startsWith("\0") || id.startsWith("\0") || /^(\.|\/|[a-zA-Z]:|virtual:)/.test(id)) return null;
+        const byShared = files && !serve && hooks.files();
+        const config = paths ? pathsFor(importer.split("?")[0]) : null;
+        const candidates = config ? pathCandidates(id, config) : void 0;
+        if (!candidates && !byShared) return null;
+        for (const c of candidates ?? [id]) {
+          const r = await this.resolve(c, importer, { ...opts, skipSelf: true });
+          if (!r || r.external) continue;
+          return byShared && await hooks.resolved(this, r.id, importer) || r;
+        }
+        return null;
       }
     },
     load: {
+      // Antes do vite:asset, que faria do .svg uma URL.
+      order: "pre",
       // Todos os módulos virtuais do vitral: \0vitral... e \0virtual:vitral...
-      filter: { id: /^\x00(virtual:)?vitral/ },
-      handler(id) {
-        const own = dedupe && !serve ? hooks.load(id) : null;
+      filter: { id: [/^\x00(virtual:)?vitral/, ...next?.svgr !== false && next ? [/\.svg$/] : []] },
+      async handler(id) {
+        if (next && next.svgr !== false && id.endsWith(".svg") && !id.startsWith("\0")) {
+          const svgr = await (svg ??= svgComponents(root));
+          return svgr ? svgr.transform(id) : null;
+        }
+        const own = dedupe && !serve ? await hooks.load(this, id) : null;
         if (own != null) return own;
         const exposed = options.exposes ? loadExposes(id, root, entry, options.exposes, options.adapter === false ? void 0 : ENTRY_ID) : null;
         if (exposed != null) return exposed;
-        if (id === VIRTUAL_ENTRY) return entryCode(resolve4(root, entry), adapter, scopeName());
+        const shim = next && loadNext(id, next);
+        if (shim) return shim;
+        if (id === VIRTUAL_ENTRY) return entryCode(resolve4(root, entry), adapter, scopeName(), !!next);
         if (id === VIRTUAL_DEV_ENTRY) return devEntryCode(framework, options.adapter === false ? resolve4(root, entry) : void 0);
         return loadPreamble(id);
       }
     },
+    // Vite 5-7: depois do minificador do Vite, que no modo lib deixa os espaços.
+    renderChunk: {
+      order: "post",
+      handler(code, chunk, out) {
+        if (minify && !rolldown && out.format === "es") return minifyWhitespace(code, chunk.fileName, !!out.sourcemap);
+      }
+    },
     transform: {
       filter: { id: DEV_CSS },
       handler(code, id) {
@@ -949,20 +1126,20 @@ function vitral(options = {}) {
     writeBundle(_, bundle) {
       if (options.sbom) bundledFiles(bundle, modules);
       if (isSplit(bundle)) return void (split = collect(outDir, bundle));
-      const files = Object.values(bundle);
-      const entry2 = files.find((f) => f.type === "chunk" && f.isEntry);
+      const files2 = Object.values(bundle);
+      const entry2 = files2.find((f) => f.type === "chunk" && f.isEntry);
       if (!entry2) return;
-      if (mcp) return mcpApp(files, entry2.fileName);
+      if (mcp) return mcpApp(files2, entry2.fileName);
       const emit = (file, text, kind = "") => {
         const hash = createHash3("sha256").update(text).digest("base64url").slice(0, 8);
         const name = file.replace(/\.css$/, `${kind}-${hash}.css`);
-        writeFileSync2(join4(outDir, name), text);
+        writeFileSync2(join5(outDir, name), text);
         return name;
       };
       const shadow = { css: [] };
-      const css = files.filter((f) => f.type === "asset" && f.fileName.endsWith(".css")).map((f) => {
-        const from = join4(outDir, f.fileName);
-        const text = transformCss(readFileSync4(from, "utf8"), options, scopeName());
+      const css = files2.filter((f) => f.type === "asset" && f.fileName.endsWith(".css")).map((f) => {
+        const from = join5(outDir, f.fileName);
+        const text = transformCss(readFileSync5(from, "utf8"), options, scopeName());
         const name = emit(f.fileName, text);
         if (name !== f.fileName) rmSync2(from);
         const split2 = splitShadowCss(text);
@@ -972,7 +1149,7 @@ function vitral(options = {}) {
         if (split2.rebase) shadow.rebase = true;
         return name;
       });
-      const code = readFileSync4(join4(outDir, entry2.fileName));
+      const code = readFileSync5(join5(outDir, entry2.fileName));
       manifest = {
         name: options.name ?? pkg.name ?? "remote",
         version: options.version ?? pkg.version,
@@ -989,32 +1166,49 @@ function vitral(options = {}) {
       if (!manifest) return;
       const done = withSplit(manifest, outDir, split, shared);
       if (options.sbom) {
-        const bom = createSbom({ root, name: done.name, version: done.version, files: modules, entry: readFileSync4(join4(outDir, done.entry)), tool: ownVersion() });
-        writeFileSync2(join4(outDir, SBOM_FILE), JSON.stringify(bom, null, 2) + "\n");
-        done.sbom = { file: SBOM_FILE, integrity: sri(join4(outDir, SBOM_FILE)) };
+        const bom = createSbom({ root, name: done.name, version: done.version, files: modules, entry: readFileSync5(join5(outDir, done.entry)), tool: ownVersion() });
+        writeFileSync2(join5(outDir, SBOM_FILE), JSON.stringify(bom, null, 2) + "\n");
+        done.sbom = { file: SBOM_FILE, integrity: sri(join5(outDir, SBOM_FILE)) };
       }
       manifest = split = void 0;
       modules = /* @__PURE__ */ new Set();
-      writeFileSync2(join4(outDir, "vitral.json"), JSON.stringify(done, null, 2) + "\n");
+      writeFileSync2(join5(outDir, "vitral.json"), JSON.stringify(done, null, 2) + "\n");
       const props = options.types === false ? null : await extractProps(root, entryFile());
-      if (props) writeFileSync2(join4(outDir, "vitral.d.ts"), typesFile(done.name, props));
+      if (props) writeFileSync2(join5(outDir, "vitral.d.ts"), typesFile(done.name, props));
     }
   };
 }
+function optimizeDeps(serve, user, entry, adapter, next) {
+  const own = user.optimizeDeps?.entries ? {} : { entries: [entry] };
+  if (!serve) return own;
+  const include = [...devOptimizeDeps(user.plugins, entry, adapter).include, ...next ? ["vitral/next"] : []];
+  return { ...own, include, ...next && next.paths && optimizerPaths(next.rolldown) };
+}
+function pureExcept(pkgs) {
+  const dirs = pkgs.map((p) => `/node_modules/${p}/`);
+  return (id) => /\.(css|scss|sass|less|styl)($|\?)/.test(id) || !dirs.some((d) => id.replace(/\\/g, "/").includes(d));
+}
+async function nodeResolve(id, importer) {
+  try {
+    return { id: createRequire3(importer).resolve(id) };
+  } catch {
+    return null;
+  }
+}
 function ownVersion() {
   try {
-    return JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf8")).version;
+    return JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf8")).version;
   } catch {
     return void 0;
   }
 }
 function versionDir(root, outDir = "dist", version) {
   try {
-    version ??= JSON.parse(readFileSync4(join4(resolve4(root), "package.json"), "utf8")).version;
+    version ??= JSON.parse(readFileSync5(join5(resolve4(root), "package.json"), "utf8")).version;
   } catch {
   }
   if (!version) throw new Error('[vitral] versionDir precisa de uma vers\xE3o: use vitral({ version }) ou "version" no package.json.');
-  return join4(outDir, version);
+  return join5(outDir, version);
 }
 function contractOf(version, groups2) {
   const contract = {
@@ -1025,5 +1219,6 @@ function contractOf(version, groups2) {
 }
 export {
   vitral as default,
+  pureExcept,
   vitral
 };