vitral 0.1.0 → 0.3.0

package/dist/vite.js

@@ -1,7 +1,273 @@
 // src/vite.ts
+import { createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5, resolve as resolve5 } from "path";
+
+// src/vite-exposes.ts
+import { resolve } from "path";
+var EXPOSES_ENTRY = "__vitral_exposes__.js";
+var ID = "\0vitral-exposes";
+function exposeKeys(exposes) {
+  const out = {};
+  for (const [key, file] of Object.entries(exposes)) {
+    const clean = key.replace(/^\.?\/?/, "");
+    if (!clean) throw new Error(`[vitral] exposes: chave inv\xE1lida "${key}". Use algo como "./MiniCarrinho".`);
+    out["./" + clean] = file;
+  }
+  return out;
+}
+var EXPOSES_IDS = /(^|[\\/])__vitral_exposes__\.js$/;
+function resolveExposesId(id) {
+  return id === EXPOSES_ENTRY || id.endsWith("/" + EXPOSES_ENTRY) || id.endsWith("\\" + EXPOSES_ENTRY) ? ID : null;
+}
+function loadExposes(id, root, entry, exposes, main) {
+  if (id !== ID) return null;
+  const file = (f) => JSON.stringify(resolve(root, f).replace(/\\/g, "/"));
+  const parts = Object.entries(exposeKeys(exposes)).map(([key, f]) => `  ${JSON.stringify(key)}: () => import(${file(f)}),`);
+  return [`export * from ${file(entry)}`, `export { default } from ${main ? JSON.stringify(main) : file(entry)}`, `export const exposes = {`, ...parts, `}`, ""].join("\n");
+}
+
+// src/vite/manifest.ts
 import { createHash } from "crypto";
 import { readFileSync, rmSync, writeFileSync } from "fs";
-import { join, resolve } from "path";
+import { join, posix } from "path";
+var SPLIT = "split/";
+var sri = (file) => "sha384-" + createHash("sha384").update(readFileSync(file)).digest("base64");
+function outputs(rolldown) {
+  return [
+    { format: "es", ...rolldown ? { codeSplitting: false } : { inlineDynamicImports: true } },
+    // Os assets saem com o mesmo nome nas duas (o Vite só aceita um padrão).
+    { format: "es", entryFileNames: `${SPLIT}remote-[hash].js`, chunkFileNames: `${SPLIT}[name]-[hash].js` }
+  ];
+}
+var isSplit = (bundle) => Object.values(bundle).some((f) => f.type === "chunk" && f.isEntry && f.fileName.startsWith(SPLIT));
+var helper = (load = "import", base = "import.meta.url") => `function __vitralImport(u,d){var p=globalThis[Symbol.for("vitral")],s=p&&p.sri,a=d.concat(u).map(function(x){return new URL(x,${base}).href});return Promise.all(s?a.map(function(h){return new Promise(function(ok,no){if(!s[h])return no(new Error("vitral: arquivo sem integrity: "+h));var l=document.createElement("link");l.rel="modulepreload";l.crossOrigin="anonymous";l.integrity=s[h];l.href=h;l.onload=ok;l.onerror=function(){no(new Error("vitral: integrity n\xE3o confere: "+h))};document.head.appendChild(l)})}):[]).then(function(){return ${load}(a[a.length-1])})}`;
+function collect(outDir, bundle) {
+  for (const f of Object.values(bundle)) if (f.fileName.endsWith(".css")) rmSync(join(outDir, f.fileName), { force: true });
+  const chunks = Object.values(bundle).filter((f) => f.type === "chunk");
+  const byName = new Map(chunks.map((c) => [c.fileName, c]));
+  const deps = (name, seen = /* @__PURE__ */ new Set()) => {
+    for (const d of byName.get(name)?.imports ?? []) if (byName.has(d) && !seen.has(d)) seen.add(d), deps(d, seen);
+    return seen;
+  };
+  const live = /* @__PURE__ */ new Map();
+  for (const c of chunks) live.set(c.fileName, rewrite(join(outDir, c.fileName), c, byName, deps));
+  const entry = chunks.find((c) => c.isEntry).fileName;
+  const used = /* @__PURE__ */ new Set([entry]);
+  for (const name of used) for (const d of [...deps(name), ...live.get(name)]) used.add(d);
+  if (![...used].some((n) => live.get(n).length)) {
+    rmSync(join(outDir, SPLIT), { recursive: true, force: true });
+    return;
+  }
+  for (const c of chunks) if (!used.has(c.fileName)) rmSync(join(outDir, c.fileName), { force: true });
+  const own = {};
+  for (const c of chunks) if (used.has(c.fileName) && c.facadeModuleId?.startsWith("\0vitral-own:"))
+    own[c.facadeModuleId.slice("\0vitral-own:".length)] = { file: c.fileName, chunks: [...deps(c.fileName)] };
+  const soon = deps(entry);
+  if (Object.keys(own).length) {
+    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 };
+}
+function rewrite(file, c, byName, deps) {
+  const targets = c.dynamicImports.filter((d) => byName.has(d));
+  if (!targets.length) return [];
+  const dir = posix.dirname(c.fileName);
+  const rel = (to) => {
+    const r = posix.relative(dir, to);
+    return r.startsWith(".") ? r : `./${r}`;
+  };
+  const done = /* @__PURE__ */ new Set();
+  const source = readFileSync(file, "utf8");
+  let rest = source;
+  let code = source.replace(/\bimport\(\s*(["'`])([^"'`]+)\1\s*\)/g, (all, _q, spec) => {
+    const target = posix.join(dir, spec);
+    if (!targets.includes(target)) return all;
+    done.add(target);
+    rest = rest.replace(all, "");
+    return `__vitralImport(${JSON.stringify(spec)},${JSON.stringify([...deps(target)].map(rel))})`;
+  });
+  const missing = targets.filter((t) => !done.has(t) && !c.imports.includes(t) && rest.includes(posix.basename(t)));
+  if (missing.length) throw new Error(`vitral: n\xE3o foi poss\xEDvel preparar o import() de ${missing.join(", ")} em ${c.fileName}`);
+  if (!done.size) return [];
+  const map = /\n\/\/# sourceMappingURL=[^\n]*\n?$/.exec(code);
+  const at = map ? map.index : code.length;
+  code = `${code.slice(0, at)}
+${helper()}${code.slice(at)}`;
+  writeFileSync(file, code);
+  return [...done];
+}
+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 } };
+}
+
+// src/vite/dedupe.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join2, 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 = dirname(file); dir !== dirname(dir); dir = dirname(dir)) {
+    const json = join2(dir, "package.json");
+    if (!existsSync(json)) continue;
+    const data = JSON.parse(readFileSync2(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";
+
+// src/css-layers.ts
+function flattenLayers(root) {
+  flatten(root);
+}
+function flatten(container) {
+  const head = [];
+  const layers = /* @__PURE__ */ new Map();
+  const rest = [];
+  let anonymous = 0;
+  const layer = (name) => {
+    let nodes = layers.get(name);
+    if (!nodes) layers.set(name, nodes = []);
+    return nodes;
+  };
+  for (const node of [...container.nodes]) {
+    const at = node.type === "atrule" ? node : null;
+    if (at?.name.toLowerCase() === "layer") {
+      if (!at.nodes) {
+        for (const name of at.params.split(",")) layer(name.trim());
+      } else {
+        flatten(at);
+        layer(at.params.trim() || `\0${anonymous++}`).push(...at.nodes);
+      }
+    } else if (!layers.size && !rest.length && (node.type === "comment" || /^(?:charset|import)$/i.test(at?.name ?? ""))) {
+      head.push(node);
+    } else {
+      if (at?.nodes) flatten(at);
+      rest.push(node);
+    }
+  }
+  if (!layers.size) return;
+  container.removeAll();
+  container.append(...head, ...[...layers.values()].flat(), ...rest);
+}
+function renameRegisteredProperties(root, scope) {
+  const names = [];
+  root.walkAtRules(/^property$/i, (rule) => {
+    const name = rule.params.trim();
+    if (name.startsWith("--tw-")) names.push(name.slice(5).replace(/[\\^$.*+?()[\]{}|]/g, "\\$&"));
+  });
+  if (!names.length) return;
+  const re = new RegExp(`(?<![\\w-])--tw-(${names.join("|")})(?![\\w-])`, "g");
+  const to = `--tw-${scope}-$1`;
+  root.walk((node) => {
+    if (node.type === "decl") {
+      node.prop = node.prop.replace(re, to);
+      node.value = node.value.replace(re, to);
+    } else if (node.type === "atrule") {
+      node.params = node.params.replace(re, to);
+    }
+  });
+}
 
 // src/css-scope.ts
 import postcss from "postcss";
@@ -16,8 +282,12 @@ function scopeSelector(selector, scope) {
   return `${scope} ${s}`;
 }
 function scopeCss(css, scopeName) {
-  const scope = `[data-vitral-scope="${scopeName}"]`;
   const root = postcss.parse(css);
+  scopeRoot(root, scopeName);
+  return root.toString();
+}
+function scopeRoot(root, scopeName) {
+  const scope = `[data-vitral-scope="${scopeName}"]`;
   root.walkRules((rule) => {
     let p = rule.parent;
     while (p && p.type !== "root") {
@@ -27,69 +297,818 @@ function scopeCss(css, scopeName) {
     }
     rule.selectors = rule.selectors.map((sel) => scopeSelector(sel, scope));
   });
+}
+
+// src/css-theme.ts
+var GLOBAL2 = /^(?::root|:host|html|body)([.:[#][^\s>+~]*)?$/i;
+var CONDITIONAL = /^(?:media|supports|container|scope|starting-style)$/i;
+function hostTheme(root) {
+  const theme = /* @__PURE__ */ new Map();
+  root.walkRules((rule) => {
+    if (!rule.selectors.every((s) => GLOBAL2.test(s.trim()))) return;
+    const base = rule.selectors.every((s) => !GLOBAL2.exec(s.trim())[1]) && !insideConditional(rule);
+    rule.each((node) => {
+      if (node.type !== "decl" || !node.prop.startsWith("--")) return;
+      if (base) theme.set(node.prop, node.value.trim());
+      node.remove();
+    });
+    if (!rule.nodes.length) rule.remove();
+  });
+  if (!theme.size) return;
+  root.walkDecls((decl) => {
+    if (/var\(/i.test(decl.value)) decl.value = withFallbacks(decl.value, theme, /* @__PURE__ */ new Set());
+  });
+}
+function insideConditional(rule) {
+  for (let p = rule.parent; p && p.type !== "root"; p = p.parent) {
+    if (p.type === "atrule" && CONDITIONAL.test(p.name)) return true;
+  }
+  return false;
+}
+function withFallbacks(value, theme, seen) {
+  return mapVars(value, (name, fallback) => {
+    const own = theme.get(name);
+    if (own !== void 0 && !seen.has(name)) {
+      return `var(${name}, ${withFallbacks(own, theme, new Set(seen).add(name))})`;
+    }
+    return fallback === void 0 ? `var(${name})` : `var(${name},${withFallbacks(fallback, theme, seen)})`;
+  });
+}
+function mapVars(value, fn) {
+  let out = "";
+  let i = 0;
+  for (; ; ) {
+    const start = findVar(value, i);
+    if (start < 0) return out + value.slice(i);
+    const open = start + 4;
+    const close = matchParen(value, open);
+    if (close < 0) return out + value.slice(i);
+    const inner = value.slice(open, close);
+    const comma = topLevelComma(inner);
+    const name = (comma < 0 ? inner : inner.slice(0, comma)).trim();
+    out += value.slice(i, start) + fn(name, comma < 0 ? void 0 : inner.slice(comma + 1));
+    i = close + 1;
+  }
+}
+function findVar(value, from) {
+  const re = /var\(/gi;
+  re.lastIndex = from;
+  for (let m = re.exec(value); m; m = re.exec(value)) {
+    if (!/[\w-]/.test(value[m.index - 1] ?? "")) return m.index;
+  }
+  return -1;
+}
+function matchParen(s, open) {
+  let depth = 1;
+  let quote = "";
+  for (let i = open; i < s.length; i++) {
+    const c = s[i];
+    if (c === "\\") i++;
+    else if (quote) quote = c === quote ? "" : quote;
+    else if (c === '"' || c === "'") quote = c;
+    else if (c === "(") depth++;
+    else if (c === ")" && !--depth) return i;
+  }
+  return -1;
+}
+function topLevelComma(s) {
+  let depth = 0;
+  let quote = "";
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === "\\") i++;
+    else if (quote) quote = c === quote ? "" : quote;
+    else if (c === '"' || c === "'") quote = c;
+    else if (c === "(") depth++;
+    else if (c === ")") depth--;
+    else if (c === "," && !depth) return i;
+  }
+  return -1;
+}
+
+// src/css-build.ts
+function transformCss(css, options, scope) {
+  const root = postcss2.parse(css);
+  if (options.theme === "host") hostTheme(root);
+  if (options.layers === "flatten") flattenLayers(root);
+  if (options.renameRegisteredProperties) renameRegisteredProperties(root, scope);
+  if (options.scopeCss !== false) scopeRoot(root, scope);
   return root.toString();
 }
+var RELATIVE_URL = /url\(\s*(['"]?)(?![a-z]+:|\/\/|#)([^'")]+)\1\s*\)/i;
+var IMPORT_URL = /^\s*(?:url\(\s*(['"]?)([^'")]+)\1\s*\)|(['"])(.*?)\3)/i;
+function splitShadowCss(text) {
+  const root = postcss2.parse(text);
+  const global = [];
+  const imports = [];
+  root.walkAtRules((rule) => {
+    const name = rule.name.toLowerCase();
+    if (name === "import" && rule.parent === root) {
+      const m = IMPORT_URL.exec(rule.params);
+      if (m) imports.push(m[2] ?? m[4]);
+      rule.remove();
+    } else if (name === "property" || name === "font-face") {
+      global.push(rule.toString());
+      rule.remove();
+    }
+  });
+  const css = global.length || imports.length ? root.toString() : text;
+  return { css, global: global.join("\n"), imports, rebase: RELATIVE_URL.test(css) };
+}
+
+// src/vite/adapter.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+var PLUGINS = [
+  [/^(preact:|prefresh$)/, "preact"],
+  [/^vite:react/, "react"],
+  [/^vite:vue$/, "vue"],
+  [/^vite-plugin-svelte/, "svelte"],
+  [/^solid$/, "solid"],
+  [/^@analogjs\/vite-plugin-angular$/, "angular"]
+];
+function detectAdapter(plugins) {
+  for (const [re, adapter] of PLUGINS) if (plugins.some((p) => re.test(p.name))) return adapter;
+  return "element";
+}
+var WRAP = {
+  react: ["vitral/react", "reactRemote"],
+  vue: ["vitral/vue", "vueRemote"],
+  svelte: ["vitral/svelte", "svelteRemote"],
+  solid: ["vitral/solid", "solidRemote"],
+  preact: ["vitral/preact", "preactRemote"],
+  angular: ["vitral/angular", "angularRemote"]
+};
+var ENTRY_ID = "__vitral_entry__.js";
+var VIRTUAL_ENTRY = "\0vitral:entry";
+function entryCode(file, adapter, scope) {
+  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)
+`;
+  }
+  return `${head}import { elementRemote } from 'vitral/element'
+import { component } from 'vitral'
+function wrap(c) {
+  if (typeof c === 'function' && typeof HTMLElement !== 'undefined' && c.prototype instanceof HTMLElement) {
+    const base = ${JSON.stringify(`${scope}-remote`.toLowerCase().replace(/^[^a-z]+/, "x-"))}
+    let tag = customElements.getName?.(c) || base
+    // Uma tag n\xE3o aceita outra classe: no HMR, a classe nova ganha tag nova.
+    for (let n = 2; customElements.get(tag) && customElements.get(tag) !== c; n++) tag = base + '-' + n
+    return elementRemote(tag, () => customElements.get(tag) || customElements.define(tag, c))
+  }
+  if (typeof c === 'function') return component(c)
+  throw new Error('[vitral] o export default n\xE3o \xE9 um remote: exporte um componente, uma fun\xE7\xE3o ou um objeto com mount()')
+}
+export default typeof c?.mount === 'function' ? c : wrap(c)
+`;
+}
+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 (existsSync2(resolve3(root, base + ext))) return base + ext;
+  }
+}
+
+// src/vite/types.ts
+import { createRequire as createRequire2 } from "module";
+import { join as join4 } from "path";
+
+// src/vite/oxc.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname2, join as join3, resolve as resolve4 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+async function loadOxc(root) {
+  const req = createRequire(join3(root, "package.json"));
+  const ids = [() => req.resolve("oxc-transform"), () => createRequire(req.resolve("vite/package.json")).resolve("rolldown/experimental")];
+  for (const id of ids) {
+    try {
+      const mod = await import(pathToFileURL2(id()).href);
+      if (typeof mod.isolatedDeclarationSync === "function") return mod;
+    } catch {
+    }
+  }
+  return null;
+}
+var GLOBAL3 = /^(Date|RegExp|Error|Map|Set|WeakMap|WeakSet|Promise|PromiseLike|Record|Partial|Required|Readonly|Pick|Omit|URL|URLSearchParams|Blob|File|FormData|Headers|AbortSignal|EventTarget|Node|Element|Document|DocumentFragment|ShadowRoot|Window|(HTML|SVG)\w*Element|\w*Event)$/;
+var IDENT = /^[A-Za-z_$][\w$]*$/;
+var Unsupported = class extends Error {
+};
+var unsupported = () => {
+  throw new Unsupported();
+};
+function propsFromOxc(ts, oxc, file) {
+  try {
+    const reader = new Reader(ts, oxc);
+    const scope = reader.scope(file);
+    const props = reader.defaultProps(scope);
+    return props ? reader.print(props.node, props.scope, 0, { top: true }) : "Record<string, unknown>";
+  } catch {
+    return null;
+  }
+}
+var Reader = class {
+  constructor(ts, oxc) {
+    this.ts = ts;
+    this.oxc = oxc;
+    this.scopes = /* @__PURE__ */ new Map();
+    this.seen = /* @__PURE__ */ new Set();
+  }
+  /** Declarações de um arquivo: `.d.ts` como está, o resto pelo Oxc. */
+  scope(file) {
+    const cached = this.scopes.get(file);
+    if (cached) return cached;
+    const { ts } = this;
+    let code = readFileSync3(file, "utf8");
+    if (!/\.d\.[cm]?ts$/.test(file)) {
+      const out = this.oxc.isolatedDeclarationSync(file, code, {});
+      if (out.errors.length) unsupported();
+      code = out.code;
+    }
+    const source = ts.createSourceFile(file + ".d.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const scope = { file, types: /* @__PURE__ */ new Map(), values: /* @__PURE__ */ new Map(), imports: /* @__PURE__ */ new Map() };
+    const isDefault = (n) => ts.canHaveModifiers(n) && !!ts.getModifiers(n)?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+    let defaultName;
+    for (const st of source.statements) {
+      if (ts.isInterfaceDeclaration(st) || ts.isTypeAliasDeclaration(st)) {
+        if (scope.types.has(st.name.text)) unsupported();
+        scope.types.set(st.name.text, st);
+      } else if (ts.isImportDeclaration(st) && ts.isStringLiteral(st.moduleSpecifier)) {
+        const from = st.moduleSpecifier.text;
+        const clause = st.importClause;
+        if (clause?.name) scope.imports.set(clause.name.text, { from, name: "default" });
+        const bindings = clause?.namedBindings;
+        if (bindings && ts.isNamespaceImport(bindings)) scope.imports.set(bindings.name.text, { from, name: "*" });
+        if (bindings && ts.isNamedImports(bindings)) for (const el of bindings.elements) scope.imports.set(el.name.text, { from, name: (el.propertyName ?? el.name).text });
+      } else if (ts.isFunctionDeclaration(st) || ts.isClassDeclaration(st)) {
+        if (isDefault(st)) scope.default ??= st;
+        else if (st.name && !scope.values.has(st.name.text)) scope.values.set(st.name.text, st);
+      } else if (ts.isVariableStatement(st)) {
+        for (const d of st.declarationList.declarations) if (ts.isIdentifier(d.name)) scope.values.set(d.name.text, d);
+      } else if (ts.isExportAssignment(st) && !st.isExportEquals) {
+        defaultName = ts.isIdentifier(st.expression) ? st.expression.text : unsupported();
+      } else if (ts.isExportDeclaration(st) && !st.moduleSpecifier && st.exportClause && ts.isNamedExports(st.exportClause)) {
+        const el = st.exportClause.elements.find((e) => e.name.text === "default");
+        if (el) defaultName = (el.propertyName ?? el.name).text;
+      }
+    }
+    if (defaultName) scope.default = scope.values.get(defaultName);
+    this.scopes.set(file, scope);
+    return scope;
+  }
+  /** `mount(el, props)`, componente-função `(props)` ou classe com `props`. `undefined`: sem props. */
+  defaultProps(scope) {
+    const { ts } = this;
+    const node = scope.default ?? unsupported();
+    const param = (params, i) => {
+      const p = params[i];
+      return p && { node: p.type ?? unsupported(), scope };
+    };
+    if (ts.isFunctionDeclaration(node)) return param(node.parameters, 0);
+    if (ts.isClassDeclaration(node)) {
+      if (node.heritageClauses?.length) unsupported();
+      const props = node.members.find((m) => ts.isPropertyDeclaration(m) && m.name.getText() === "props");
+      return props && { node: props.type ?? unsupported(), scope };
+    }
+    if (ts.isVariableDeclaration(node)) return this.propsOfType(node.type ?? unsupported(), scope);
+    return unsupported();
+  }
+  propsOfType(node, scope) {
+    const { ts } = this;
+    const param = (params, i, at2) => {
+      const p = params[i];
+      return p && { node: p.type ?? unsupported(), scope: at2 };
+    };
+    if (ts.isParenthesizedTypeNode(node)) return this.propsOfType(node.type, scope);
+    if (ts.isFunctionTypeNode(node)) return param(node.parameters, 0, scope);
+    let members;
+    let at = scope;
+    if (ts.isTypeLiteralNode(node)) members = node.members;
+    else if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && !node.typeArguments) {
+      const found = this.lookup(node.typeName.text, scope);
+      if (!found || found === "package" || found.decl.typeParameters) return unsupported();
+      if (ts.isTypeAliasDeclaration(found.decl)) return this.propsOfType(found.decl.type, found.scope);
+      if (found.decl.heritageClauses?.length) unsupported();
+      members = found.decl.members;
+      at = found.scope;
+    } else return unsupported();
+    const mount = members.find((m) => m.name?.getText() === "mount");
+    if (mount) {
+      if (ts.isMethodSignature(mount)) return param(mount.parameters, 1, at);
+      if (ts.isPropertySignature(mount) && mount.type) return this.mountProps(mount.type, at);
+      return unsupported();
+    }
+    const call = members.find(ts.isCallSignatureDeclaration);
+    if (call) return param(call.parameters, 0, at);
+    if (members.some(ts.isConstructSignatureDeclaration)) unsupported();
+    return void 0;
+  }
+  mountProps(node, scope) {
+    const { ts } = this;
+    if (ts.isParenthesizedTypeNode(node)) return this.mountProps(node.type, scope);
+    if (!ts.isFunctionTypeNode(node)) return unsupported();
+    const p = node.parameters[1];
+    return p && { node: p.type ?? unsupported(), scope };
+  }
+  /** Acha um tipo pelo nome: no arquivo, num import relativo ou num pacote. */
+  lookup(name, scope) {
+    const decl = scope.types.get(name);
+    if (decl) return { decl, scope };
+    const imp = scope.imports.get(name);
+    if (!imp) return void 0;
+    if (!imp.from.startsWith(".")) return "package";
+    if (imp.name === "default" || imp.name === "*") return unsupported();
+    const found = this.lookup(imp.name, this.scope(resolveFile(scope.file, imp.from)));
+    return found ?? unsupported();
+  }
+  print(node, scope, depth, opts = {}) {
+    const { ts } = this;
+    const K = ts.SyntaxKind;
+    switch (node.kind) {
+      case K.AnyKeyword:
+      case K.UnknownKeyword:
+        return "unknown";
+      case K.StringKeyword:
+      case K.NumberKeyword:
+      case K.BooleanKeyword:
+      case K.BigIntKeyword:
+      case K.SymbolKeyword:
+      case K.UndefinedKeyword:
+      case K.VoidKeyword:
+      case K.NeverKeyword:
+        return node.getText();
+    }
+    if (ts.isLiteralTypeNode(node)) {
+      const lit = node.literal;
+      if (ts.isStringLiteral(lit)) return JSON.stringify(lit.text);
+      if (lit.kind === K.NullKeyword || lit.kind === K.TrueKeyword || lit.kind === K.FalseKeyword || ts.isNumericLiteral(lit) || ts.isPrefixUnaryExpression(lit)) return lit.getText();
+      return unsupported();
+    }
+    if (ts.isParenthesizedTypeNode(node)) return this.print(node.type, scope, depth, opts);
+    if (ts.isUnionTypeNode(node)) {
+      const types = opts.nonNull ? node.types.filter((t) => t.kind !== K.UndefinedKeyword && !(ts.isLiteralTypeNode(t) && t.literal.kind === K.NullKeyword)) : node.types;
+      const parts = [...new Set(types.map((t) => this.print(t, scope, depth)))];
+      if (parts.includes("true") && parts.includes("false")) parts.splice(parts.indexOf("true"), 1, "boolean"), parts.splice(parts.indexOf("false"), 1);
+      return parts.join(" | ");
+    }
+    if (ts.isIntersectionTypeNode(node)) {
+      return node.types.map((t) => {
+        const s = this.print(t, scope, depth);
+        return ts.isUnionTypeNode(t) ? `(${s})` : s;
+      }).join(" & ");
+    }
+    if (depth > 6) return "unknown";
+    if (ts.isArrayTypeNode(node)) return `Array<${this.print(node.elementType, scope, depth + 1)}>`;
+    if (ts.isTypeOperatorNode(node) && node.operator === K.ReadonlyKeyword && (ts.isArrayTypeNode(node.type) || ts.isTupleTypeNode(node.type))) return this.print(node.type, scope, depth);
+    if (ts.isTupleTypeNode(node)) {
+      if (node.elements.some((e) => ts.isNamedTupleMember(e) || ts.isOptionalTypeNode(e) || ts.isRestTypeNode(e))) unsupported();
+      return `[${node.elements.map((e) => this.print(e, scope, depth + 1)).join(", ")}]`;
+    }
+    if (ts.isTypeLiteralNode(node)) return this.object(node.members, scope, depth, !!opts.top);
+    if (ts.isFunctionTypeNode(node)) return this.signature(node, scope, depth);
+    if (ts.isTypeReferenceNode(node)) return this.reference(node, scope, depth, opts);
+    return unsupported();
+  }
+  reference(node, scope, depth, opts) {
+    const { ts } = this;
+    if (!ts.isIdentifier(node.typeName)) return unsupported();
+    const name = node.typeName.text;
+    const args = node.typeArguments ?? [];
+    const found = this.lookup(name, scope);
+    if (found === "package") return "unknown";
+    if (found) {
+      if (args.length || found.decl.typeParameters) unsupported();
+      if (this.seen.has(found.decl)) return "unknown";
+      this.seen.add(found.decl);
+      try {
+        const decl = found.decl;
+        if (ts.isTypeAliasDeclaration(decl)) return this.print(decl.type, found.scope, depth, opts);
+        if (decl.heritageClauses?.length) unsupported();
+        return this.object(decl.members, found.scope, depth, !!opts.top);
+      } finally {
+        this.seen.delete(found.decl);
+      }
+    }
+    if ((name === "Array" || name === "ReadonlyArray") && args.length === 1) return `Array<${this.print(args[0], scope, depth + 1)}>`;
+    if (!GLOBAL3.test(name)) return unsupported();
+    return args.length ? `${name}<${args.map((t) => this.print(t, scope, depth + 1)).join(", ")}>` : name;
+  }
+  object(members, scope, depth, top) {
+    const { ts } = this;
+    const fields = [];
+    const calls = [];
+    let index;
+    for (const m of members) {
+      if (ts.isPropertySignature(m) || ts.isMethodSignature(m)) {
+        const name = ts.isIdentifier(m.name) || ts.isStringLiteral(m.name) || ts.isNumericLiteral(m.name) ? m.name.text : unsupported();
+        if (top && name === "vitral") continue;
+        const optional = m.questionToken ? "?" : "";
+        const key = IDENT.test(name) ? name : JSON.stringify(name);
+        const type = ts.isMethodSignature(m) ? this.signature(m, scope, depth + 1) : m.type ? this.print(m.type, scope, depth + 1, { nonNull: !!optional }) : "unknown";
+        fields.push(`${key}${optional}: ${type}`);
+      } else if (ts.isIndexSignatureDeclaration(m)) {
+        const key = m.parameters[0]?.type;
+        if (!key || key.kind !== ts.SyntaxKind.StringKeyword) unsupported();
+        index = `[key: string]: ${this.print(m.type, scope, depth + 1)}`;
+      } else if (ts.isCallSignatureDeclaration(m)) {
+        calls.push(this.signature(m, scope, depth));
+      } else unsupported();
+    }
+    if (calls.length && !fields.length) return calls[0];
+    if (index) fields.push(index);
+    for (const c of calls) fields.push(c.replace(" =>", ":"));
+    return fields.length ? `{ ${fields.join("; ")} }` : "{}";
+  }
+  signature(sig, scope, depth) {
+    const { ts } = this;
+    if (sig.typeParameters?.length || !sig.type) unsupported();
+    const params = sig.parameters.map((p, i) => {
+      if (p.dotDotDotToken || ts.isIdentifier(p.name) && p.name.text === "this") unsupported();
+      const name = ts.isIdentifier(p.name) && IDENT.test(p.name.text) ? p.name.text : `a${i}`;
+      const type = p.type ? this.print(p.type, scope, depth + 1) : "unknown";
+      return `${name}: ${p.questionToken || p.initializer ? `${type} | undefined` : type}`;
+    });
+    return `(${params.join(", ")}) => ${this.print(sig.type, scope, depth + 1)}`;
+  }
+};
+function resolveFile(from, spec) {
+  const base = resolve4(dirname2(from), spec);
+  const stem = base.replace(/\.[cm]?jsx?$/, "");
+  const candidates = [base, ...[".ts", ".tsx", ".mts", ".cts", ".d.ts"].map((ext) => stem + ext), ...["index.ts", "index.tsx", "index.d.ts"].map((f) => join3(base, f))];
+  const file = candidates.find((f) => /\.[cm]?tsx?$/.test(f) && existsSync3(f));
+  return file ?? unsupported();
+}
+
+// src/vite/types.ts
+function typesFile(name, props) {
+  return `// Props do remote ${JSON.stringify(name)}, geradas pelo vitral. N\xE3o edite.
+export type Props = ${props}
+`;
+}
+async function loadTs(root) {
+  const api = (ts) => typeof ts?.createProgram === "function" ? ts : null;
+  try {
+    const ts = api(createRequire2(join4(root, "package.json"))("typescript"));
+    if (ts) return ts;
+  } catch {
+  }
+  try {
+    return api((await import("typescript")).default);
+  } catch {
+    return null;
+  }
+}
+async function extractProps(root, file) {
+  if (!/\.[cm]?[jt]sx?$/.test(file)) return null;
+  const ts = await loadTs(root);
+  if (!ts) return null;
+  const oxc = /\.[cm]?tsx?$/.test(file) ? await loadOxc(root) : null;
+  const fast = oxc && propsFromOxc(ts, oxc, file);
+  if (fast) return fast;
+  const configPath = ts.findConfigFile(root, ts.sys.fileExists);
+  const base = configPath ? ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, ts.sys.readFile).config, ts.sys, root).options : {};
+  const options = {
+    target: ts.ScriptTarget.ES2022,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    jsx: ts.JsxEmit.Preserve,
+    strict: true,
+    ...base,
+    allowJs: true,
+    skipLibCheck: true,
+    noEmit: true
+  };
+  const program = ts.createProgram([file], options);
+  const checker = program.getTypeChecker();
+  const source = program.getSourceFile(file);
+  const moduleSymbol = source && checker.getSymbolAtLocation(source);
+  let symbol = moduleSymbol && checker.getExportsOfModule(moduleSymbol).find((s) => s.escapedName === "default");
+  if (!source || !symbol) return null;
+  if (symbol.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol);
+  const type = checker.getTypeOfSymbolAtLocation(symbol, source);
+  const props = propsOf(checker, type, source);
+  return props ? new Printer(ts, checker, program).print(props, 0, true) : "Record<string, unknown>";
+}
+function propsOf(checker, type, at) {
+  const param = (t, i) => {
+    const p = t.getCallSignatures()[0]?.parameters[i];
+    return p && checker.getTypeOfSymbolAtLocation(p, at);
+  };
+  const mount = type.getProperty("mount");
+  if (mount) return param(checker.getTypeOfSymbolAtLocation(mount, at), 1);
+  if (type.getCallSignatures().length) return param(type, 0);
+  const ctor = type.getConstructSignatures()[0];
+  const props = ctor?.getReturnType().getProperty("props");
+  return props && checker.getTypeOfSymbolAtLocation(props, at);
+}
+var Printer = class {
+  constructor(ts, checker, program) {
+    this.ts = ts;
+    this.checker = checker;
+    this.program = program;
+    this.seen = /* @__PURE__ */ new Set();
+  }
+  /** Declarado na lib padrão (Date, Map…): vale em qualquer projeto pelo nome. */
+  fromLib(type) {
+    const decl = (type.aliasSymbol ?? type.getSymbol())?.declarations?.[0];
+    return !!decl && this.program.isSourceFileDefaultLibrary(decl.getSourceFile());
+  }
+  fromPackage(type) {
+    const decl = (type.aliasSymbol ?? type.getSymbol())?.declarations?.[0];
+    return !!decl && /[/\\]node_modules[/\\]/.test(decl.getSourceFile().fileName);
+  }
+  print(type, depth, top = false) {
+    const { ts, checker } = this;
+    const f = type.flags;
+    if (f & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return "unknown";
+    if (f & (ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void | ts.TypeFlags.Never | ts.TypeFlags.ESSymbolLike)) {
+      return checker.typeToString(type);
+    }
+    if (type.isUnion()) {
+      const parts = [...new Set(type.types.map((t) => this.print(t, depth)))];
+      if (parts.includes("true") && parts.includes("false")) parts.splice(parts.indexOf("true"), 1, "boolean"), parts.splice(parts.indexOf("false"), 1);
+      return parts.join(" | ");
+    }
+    if (type.isIntersection()) return type.types.map((t) => this.wrap(t, depth)).join(" & ");
+    if (depth > 6 || this.seen.has(type)) return "unknown";
+    if (checker.isArrayType(type)) return `Array<${this.print(checker.getTypeArguments(type)[0], depth + 1)}>`;
+    if (checker.isTupleType(type)) return `[${checker.getTypeArguments(type).map((t) => this.print(t, depth + 1)).join(", ")}]`;
+    if (this.fromLib(type)) {
+      const args = type.aliasTypeArguments ?? (type.objectFlags & ts.ObjectFlags.Reference ? checker.getTypeArguments(type) : []);
+      const name = (type.aliasSymbol ?? type.getSymbol()).name;
+      return args.length ? `${name}<${args.map((t) => this.print(t, depth + 1)).join(", ")}>` : checker.typeToString(type);
+    }
+    if (this.fromPackage(type)) return "unknown";
+    this.seen.add(type);
+    try {
+      const calls = type.getCallSignatures();
+      const props = checker.getPropertiesOfType(type).filter((p) => !(top && p.name === "vitral"));
+      if (calls.length && !props.length) return this.signature(calls[0], depth);
+      const fields = props.map((p) => {
+        const optional = p.flags & ts.SymbolFlags.Optional ? "?" : "";
+        const key = /^[A-Za-z_$][\w$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
+        const t = checker.getTypeOfSymbol(p);
+        return `${key}${optional}: ${this.print(optional ? checker.getNonNullableType(t) : t, depth + 1)}`;
+      });
+      const index = type.getStringIndexType();
+      if (index) fields.push(`[key: string]: ${this.print(index, depth + 1)}`);
+      for (const c of calls) fields.push(this.signature(c, depth).replace(" =>", ":"));
+      return fields.length ? `{ ${fields.join("; ")} }` : "{}";
+    } finally {
+      this.seen.delete(type);
+    }
+  }
+  wrap(type, depth) {
+    const s = this.print(type, depth);
+    return type.isUnion() ? `(${s})` : s;
+  }
+  signature(sig, depth) {
+    const params = sig.parameters.map((p, i) => `${/^[A-Za-z_$][\w$]*$/.test(p.name) ? p.name : `a${i}`}: ${this.print(this.checker.getTypeOfSymbol(p), depth + 1)}`);
+    return `(${params.join(", ")}) => ${this.print(sig.getReturnType(), depth + 1)}`;
+  }
+};
+
+// src/vite/dev.ts
+var DEV_ENTRY = "@vitral/entry.js";
+var VIRTUAL_DEV_ENTRY = "\0vitral:dev-entry";
+var PREAMBLE_ID = "virtual:vitral-react-preamble";
+var REACT_PREAMBLE = `import { injectIntoGlobalHook } from '/@react-refresh'
+injectIntoGlobalHook(window)
+window.$RefreshReg$ ??= () => {}
+window.$RefreshSig$ ??= () => (type) => type
+window.__vite_plugin_react_preamble_installed__ = true
+`;
+function devEntryCode(framework, raw) {
+  const preamble = framework === "react" ? `import '${PREAMBLE_ID}'
+` : "";
+  const from = raw ? JSON.stringify(raw) : `'${ENTRY_ID}'`;
+  return `import '/@vite/client'
+${preamble}import * as first from ${from}
+let mod = first.default ?? first
+const live = new Set()
+export default {
+  async mount(el, props, ctx) {
+    const i = { props, handle: await mod.mount(el, props, ctx) }
+    i.remount = async () => {
+      i.handle.unmount()
+      el.replaceChildren()
+      i.handle = await mod.mount(el, i.props, ctx)
+    }
+    live.add(i)
+    return {
+      update(next) {
+        i.props = next
+        i.handle.update?.(next)
+      },
+      unmount() {
+        live.delete(i)
+        i.handle.unmount()
+      },
+    }
+  },
+}
+if (import.meta.hot) {
+  import.meta.hot.accept(${from}, (next) => {
+    if (!next) return import.meta.hot.invalidate()
+    mod = next.default ?? next
+    for (const i of live) i.remount().catch((e) => console.error('[vitral] falha ao remontar depois da edi\xE7\xE3o', e))
+  })
+}
+`;
+}
+var DEV_IDS = /^virtual:vitral-react-preamble$|\/@vitral\/entry\.js$/;
+function resolveDevId(id) {
+  if (id === PREAMBLE_ID) return "\0" + PREAMBLE_ID;
+  if (id.endsWith("/" + DEV_ENTRY)) return VIRTUAL_DEV_ENTRY;
+}
+function loadPreamble(id) {
+  if (id === "\0" + PREAMBLE_ID) return REACT_PREAMBLE;
+}
+function devManifest(name, scope) {
+  return { name, entry: DEV_ENTRY, css: [], ...scope ? { scope } : {} };
+}
+var DEV_CSS = { include: /\.(css|less|sass|scss|styl|stylus|pcss|postcss|sss)(\?|$)/, exclude: /[?&](raw|url|inline)\b/ };
+function scopeDevCss(code, id, scope) {
+  if (!DEV_CSS.include.test(id) || DEV_CSS.exclude.test(id)) return;
+  return scopeCss(code, scope);
+}
+function serveDevManifest(server, manifest) {
+  const path = `${server.config.base.replace(/\/?$/, "/")}vitral.json`;
+  server.httpServer?.once("listening", () => {
+    const address = server.httpServer.address();
+    if (!server.config.server.origin && address && typeof address === "object") {
+      const protocol = server.config.server.https ? "https" : "http";
+      server.config.server.origin = `${protocol}://localhost:${address.port}`;
+    }
+  });
+  server.middlewares.use((req, res, next) => {
+    if (req.url?.split("?")[0] !== path) return next();
+    res.writeHead(200, {
+      "content-type": "application/json",
+      "cache-control": "no-store",
+      "access-control-allow-origin": "*"
+    });
+    res.end(JSON.stringify(manifest(), null, 2));
+  });
+}
+function devOptimizeDeps(plugins, entry, adapter) {
+  const named = [plugins].flat(Infinity).filter((p) => typeof p?.name === "string");
+  const fw = adapter === false ? null : adapter || detectAdapter(named);
+  const include = fw === null ? [] : fw === "element" ? ["vitral", "vitral/element"] : [`vitral/${fw}`];
+  return { entries: [entry, "**/*.html"], include };
+}
 
 // src/vite.ts
-function vitral(options) {
+function vitral(options = {}) {
   let outDir = "dist";
   let root = process.cwd();
   let pkg = {};
+  let manifest;
+  let split;
+  let entry = options.entry;
+  let adapter = "element";
+  let framework = "element";
+  const entryFile = () => resolve5(root, entry);
+  let serve = false;
+  let shared = [];
+  const dedupe = !!options.dedupe?.length;
+  const hooks = dedupeHooks(() => options.exposes ? EXPOSES_ENTRY : options.adapter === false ? entryFile() : ENTRY_ID, () => shared);
   const scopeName = () => (options.name ?? pkg.name ?? "remote").replace(/[^a-zA-Z0-9_-]/g, "-");
   return {
     name: "vitral",
-    config(_, { mode }) {
+    config(user, { mode, command }) {
+      entry ??= findEntry(resolve5(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;
-      const output = rolldown ? { codeSplitting: false } : { inlineDynamicImports: true };
       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") },
         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] },
         build: {
           // Nomes com hash: cache eterno no CDN. Só o vitral.json muda a cada deploy.
-          lib: { entry: options.entry, formats: ["es"], fileName: () => "remote-[hash].js", cssFileName: "remote" },
-          // Um arquivo só: necessário para verificar o hash SRI no host.
-          rollupOptions: { external: options.shared ?? [], output },
+          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) },
           cssCodeSplit: false
         }
       };
     },
     configResolved(c) {
       root = c.root;
-      outDir = resolve(c.root, c.build.outDir);
+      framework = detectAdapter(c.plugins);
+      adapter = options.adapter || framework;
+      serve = c.command === "serve";
+      outDir = resolve5(c.root, c.build.outDir);
       try {
-        pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+        pkg = JSON.parse(readFileSync4(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 }));
+    },
+    // Modo dev: /vitral.json aponta para um módulo com o cliente HMR.
+    configureServer(server) {
+      const scope = options.scopeCss === false ? void 0 : scopeName();
+      serveDevManifest(server, () => devManifest(options.name ?? pkg.name ?? "remote", scope));
+    },
+    // Filtros de hook (Rolldown, Vite 6.3+): os módulos que não são do vitral
+    // 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) {
+        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);
+      }
+    },
+    load: {
+      // 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;
+        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(resolve5(root, entry), adapter, scopeName());
+        if (id === VIRTUAL_DEV_ENTRY) return devEntryCode(framework, options.adapter === false ? resolve5(root, entry) : void 0);
+        return loadPreamble(id);
+      }
+    },
+    transform: {
+      filter: { id: DEV_CSS },
+      handler(code, id) {
+        if (serve && options.scopeCss !== false) return scopeDevCss(code, id, scopeName());
+      }
+    },
     writeBundle(_, bundle) {
+      if (isSplit(bundle)) return void (split = collect(outDir, bundle));
       const files = Object.values(bundle);
-      const entry = files.find((f) => f.type === "chunk" && f.isEntry);
-      if (!entry) return;
+      const entry2 = files.find((f) => f.type === "chunk" && f.isEntry);
+      if (!entry2) return;
+      const emit = (file, text, kind = "") => {
+        const hash = createHash2("sha256").update(text).digest("base64url").slice(0, 8);
+        const name = file.replace(/\.css$/, `${kind}-${hash}.css`);
+        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 = join(outDir, f.fileName);
-        let text = readFileSync(from, "utf8");
-        if (options.scopeCss !== false) text = scopeCss(text, scopeName());
-        const hash = createHash("sha256").update(text).digest("base64url").slice(0, 8);
-        const name = f.fileName.replace(/\.css$/, `-${hash}.css`);
-        writeFileSync(join(outDir, name), text);
-        if (name !== f.fileName) rmSync(from);
+        const from = join5(outDir, f.fileName);
+        const text = transformCss(readFileSync4(from, "utf8"), options, scopeName());
+        const name = emit(f.fileName, text);
+        if (name !== f.fileName) rmSync2(from);
+        const split2 = splitShadowCss(text);
+        shadow.css.push(split2.css === text ? name : emit(f.fileName, split2.css, "-shadow"));
+        if (split2.global) (shadow.global ??= []).push(emit(f.fileName, split2.global, "-global"));
+        if (split2.imports.length) (shadow.imports ??= []).push(...split2.imports);
+        if (split2.rebase) shadow.rebase = true;
         return name;
       });
-      const code = readFileSync(join(outDir, entry.fileName));
-      const manifest = {
+      const code = readFileSync4(join5(outDir, entry2.fileName));
+      manifest = {
         name: options.name ?? pkg.name ?? "remote",
         version: options.version ?? pkg.version,
-        entry: entry.fileName,
+        entry: entry2.fileName,
         css,
-        integrity: "sha384-" + createHash("sha384").update(code).digest("base64"),
-        ...options.scopeCss === false ? {} : { scope: scopeName() }
+        ...css.length ? { shadow } : {},
+        integrity: "sha384-" + createHash2("sha384").update(code).digest("base64"),
+        ...options.scopeCss === false ? {} : { scope: scopeName() },
+        ...options.exposes ? { exposes: Object.keys(exposeKeys(options.exposes)) } : {},
+        ...contractOf(options.contract?.version, shared)
       };
-      writeFileSync(join(outDir, "vitral.json"), JSON.stringify(manifest, null, 2) + "\n");
+    },
+    async closeBundle() {
+      if (!manifest) return;
+      const done = withSplit(manifest, outDir, split, shared);
+      manifest = split = void 0;
+      writeFileSync2(join5(outDir, "vitral.json"), JSON.stringify(done, null, 2) + "\n");
+      const props = options.types === false ? null : await extractProps(root, entryFile());
+      if (props) writeFileSync2(join5(outDir, "vitral.d.ts"), typesFile(done.name, props));
     }
   };
 }
+function contractOf(version, groups2) {
+  const contract = {
+    ...version && { version },
+    ...groups2.length && { peers: Object.fromEntries(groups2.map((g) => [g.name, g.range])) }
+  };
+  return Object.keys(contract).length ? { contract } : {};
+}
 export {
   vitral as default,
   vitral