vitral 0.7.1 → 0.8.0

package/README.md

@@ -22,7 +22,16 @@
 
 Junte micro-frontends de qualquer framework numa página só, sem configuração de build no host.
 
-Cada equipe publica o próprio pedaço da página (um remote) com `vite build`. O host recebe a URL de cada remote e monta tudo no navegador. Não há plugin no host, não há versão de React para combinar entre equipes e um remote fora do ar não derruba a página.
+Cada equipe publica o próprio pedaço da página (um remote) com `vite build`. O host recebe a URL de cada remote e monta tudo no navegador.
+
+**Por que usar:**
+
+- **Zero configuração no host.** Sem plugin de build: só `configure({ remotes })` com a URL de cada remote.
+- **Qualquer framework.** React, Next, Vue, Nuxt, Angular, Svelte, Solid, Preact, Lit e JS puro na mesma página. Sem combinar versão de React entre equipes.
+- **Deploy independente.** Cada equipe publica quando quiser. O host vê a versão nova sem novo build.
+- **CSS e erros isolados.** O CSS de um remote não muda o resto da página. Um remote fora do ar mostra o próprio erro, e o resto continua funcionando.
+- **Seguro.** O JS só roda se vier de uma origem permitida e se o hash SHA-384 bater.
+- **Leve e rápido.** 3,4 kB de host. Primeira visita 57% mais rápida que o Module Federation e troca de área 4,6 vezes mais rápida que o Next.js Multi-Zones.
 
 ```bash
 npm install vitral
@@ -35,25 +44,25 @@ npm install vitral
   </picture>
 </p>
 
-## Por que o vitral
+## Comparação
 
-| | Module Federation / single-spa | vitral |
-|---|---|---|
-| Build do host | Config combinada com cada remote | Nenhuma. Só `configure()` |
-| Versões de React/Vue | `shared` e singletons, conflitos de versão | Cada remote leva a sua. Compartilhar é opcional |
-| Remote fora do ar | Pode derrubar a página | Só aquele remote mostra erro |
-| CSS | Vaza entre apps | Escopo automático ou Shadow DOM |
-| Deploy novo | `ChunkLoadError` com cache velho | Arquivos com hash; só o `vitral.json` revalida |
-| Conceitos | Containers, exposes, lifecycles, root config | `mount(el, props, ctx)` → `{ update, unmount }` |
+| | Module Federation | single-spa | Next.js Multi-Zones | vitral |
+|---|---|---|---|---|
+| Configuração no host | Plugin no build, combinado com cada remote | Root config e import map | Um app Next por zona e rewrites | Nenhuma. Só `configure()` |
+| Frameworks | Combinar versões em `shared` | Um adaptador e um ciclo de vida por framework | Só Next | Qualquer um, sem combinar versão |
+| Divide a página em | Pedaços | Apps por rota | Rotas (cada zona é uma página) | Pedaços ou rotas |
+| Trocar de área | Sem recarregar | Sem recarregar | Recarrega a página e baixa Next e React de novo | Sem recarregar |
+| Isolamento de CSS | Nenhum | Nenhum | Por página | Escopo automático ou Shadow DOM |
+| Remote fora do ar | Erro sem tratamento derruba a página | A tela de erro é com você | A zona inteira fica fora | Só aquele remote mostra erro, com `retry` |
+| Código de host (brotli) | 19,4 kB | 5,8 kB | Runtime do Next em cada zona | 3,4 kB |
 
 Medido no [benchmark público](https://joaogabriel15.github.io/vitral/aprender/benchmark) (Chromium, rede Slow 4G, mediana de 7 visitas):
 
-- **3,4 kB** de código de host mínimo, com brotli. O host do Module Federation tem 19,4 kB.
 - **57% menos tempo** na primeira visita que o Module Federation com React compartilhado (1157 ms contra 2673 ms, 1 remote).
-- **4,6 vezes mais rápido** para trocar de área que o Next.js Multi-Zones (184 ms contra 850 ms).
+- **4,6 vezes mais rápido** para trocar de área que o Next.js Multi-Zones (184 ms contra 850 ms), com 63% menos bytes para abrir duas áreas.
 - **10 frameworks** cobertos por testes de ponta a ponta no CI, com host e remote de frameworks diferentes, em Chromium, Firefox, WebKit e mobile.
 
-A página do benchmark também lista onde o vitral perde.
+O método e as versões usadas estão na página do benchmark.
 
 ## Começo rápido
 
@@ -111,6 +120,55 @@ Sem build no host, numa página HTML qualquer:
 
 Todos os componentes de host aceitam `src` no lugar de `name`.
 
+## Rodar local
+
+Cada remote roda no próprio `vite dev`, numa porta. O host aponta para essas portas:
+
+```bash
+cd carrinho && npm run dev   # vite --port 5174
+cd busca && npm run dev      # vite --port 5175
+cd loja && npm run dev       # vite --port 3000
+```
+
+```json
+// loja/public/remotes.json
+{
+  "carrinho": "http://localhost:5174/vitral.json",
+  "busca": "http://localhost:5175/vitral.json"
+}
+```
+
+```js
+// loja/src/main.jsx
+configure({ remotes: '/remotes.json' })
+```
+
+Editar o remote atualiza o host sem recarregar a página (HMR). Para rodar só um remote local e pegar os outros de homologação, abra o host com `?vitral=carrinho@http://localhost:5174`.
+
+## Docker e Kubernetes
+
+Cada remote vira uma imagem nginx com o `dist`. O host lê a lista de remotes de uma variável de ambiente quando o contêiner sobe, então a mesma imagem serve em qualquer ambiente.
+
+```yaml
+# compose.yaml
+services:
+  loja:                # host: http://localhost:8080
+    build: ./loja
+    ports: ["8080:80"]
+    environment:
+      VITRAL_REMOTES: '{"carrinho":"/mf/carrinho/vitral.json","busca":"/mf/busca/vitral.json"}'
+  carrinho:            # remote React
+    build: ./carrinho
+  busca:               # remote Vue
+    build: ./busca
+```
+
+O nginx do host repassa `/mf/carrinho/` para o contêiner `carrinho`. Tudo fica na mesma origem: sem CORS e com uma porta só. Parar o contêiner `carrinho` mostra o erro só no lugar do carrinho.
+
+No Kubernetes, as mesmas imagens funcionam com um Service por remote; o Ingress pode fazer o papel do nginx do host. Se os remotes ficam num CDN, troque `VITRAL_REMOTES` pelas URLs do CDN.
+
+Exemplo completo, com Dockerfiles e configuração do nginx: [`examples/docker`](https://github.com/joaogabriel15/vitral/tree/main/examples/docker).
+
 ## Frameworks
 
 | Framework | Remote | Host | Import |
@@ -128,6 +186,8 @@ Todos os componentes de host aceitam `src` no lugar de `name`.
 
 No Next e no Nuxt o componente renderiza o `fallback` no servidor e monta o remote no cliente.
 
+Uma zona do Multi-Zones vira remote sem reescrever o código Next (`vitral({ next: true })`), e o app Next principal vira host com `withVitral` e `<NextRemote>`, trocando de área sem recarregar. Veja [Next.js](https://joaogabriel15.github.io/vitral/frameworks/next).
+
 ### Host em Vue
 
 ```vue
@@ -378,4 +438,4 @@ failingRemote('recomendacoes') // testa a tela de erro
 
 - [Exemplos](https://github.com/joaogabriel15/vitral/tree/main/examples): o mesmo remote em 8 frameworks e 9 hosts.
 - [Como contribuir](https://github.com/joaogabriel15/vitral/blob/main/CONTRIBUTING.md)
-- Licença [MIT](https://github.com/joaogabriel15/vitral/blob/main/LICENSE)
+- Licença [MIT](https://github.com/joaogabriel15/vitral/blob/main/LICENSE). Feito por [Pacheco Codes](https://pacheco.dev.br/).

package/dist/angular.d.ts

@@ -1,6 +1,6 @@
 import { InjectionToken, Type, ApplicationConfig, Signal, Provider, EnvironmentProviders } from '@angular/core';
-import { R as RemoteContext, P as Props, a as RemoteModule, S as Shared, V as VitralConfig } from './types-EOz1rOHs.js';
-export { e as events } from './events-DLdbFqBM.js';
+import { R as RemoteContext, P as Props, a as RemoteModule, S as Shared, V as VitralConfig } from './types-wsKR1gfx.js';
+export { e as events } from './events-Cieg_far.js';
 export { n as navigate } from './navigate-BRG1WJUM.js';
 import './errors-kjBv6IH_.js';
 

package/dist/angular.js

@@ -1,18 +1,20 @@
 import {
   defineVitralElement
-} from "./chunk-V24ZNHUF.js";
-import "./chunk-TXSHK3SK.js";
+} from "./chunk-ZRAGLT3I.js";
+import "./chunk-ZJ4IM2PZ.js";
 import {
   defineRemote,
-  events,
   memoSelect,
-  navigate,
   same,
   shared
-} from "./chunk-O7DV3EVB.js";
+} from "./chunk-NTXMEZIZ.js";
+import {
+  events,
+  navigate
+} from "./chunk-EQZOJU3B.js";
 import {
   configure
-} from "./chunk-72H4FXMD.js";
+} from "./chunk-6T25WKNK.js";
 import "./chunk-KU6HF2EW.js";
 import "./chunk-TW7KYJQ6.js";
 import "./chunk-463H6B56.js";

package/dist/auto.js

@@ -1,9 +1,10 @@
 import {
   defineVitralElement
-} from "./chunk-V24ZNHUF.js";
-import "./chunk-TXSHK3SK.js";
-import "./chunk-O7DV3EVB.js";
-import "./chunk-72H4FXMD.js";
+} from "./chunk-ZRAGLT3I.js";
+import "./chunk-ZJ4IM2PZ.js";
+import "./chunk-NTXMEZIZ.js";
+import "./chunk-EQZOJU3B.js";
+import "./chunk-6T25WKNK.js";
 import "./chunk-KU6HF2EW.js";
 import "./chunk-TW7KYJQ6.js";
 import "./chunk-463H6B56.js";

package/dist/chunk-4IWZIFAL.js

@@ -0,0 +1,165 @@
+import {
+  RemoteTree,
+  VitralContext
+} from "./chunk-B2MPYF4M.js";
+import {
+  hostSlot
+} from "./chunk-ZJ4IM2PZ.js";
+import {
+  defineRemote,
+  memoSelect,
+  same,
+  shared
+} from "./chunk-NTXMEZIZ.js";
+import {
+  events
+} from "./chunk-EQZOJU3B.js";
+import {
+  preload
+} from "./chunk-6T25WKNK.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/react.tsx
+import {
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  useSyncExternalStore
+} from "react";
+import { createRoot, hydrateRoot } from "react-dom/client";
+import * as ReactAll from "react";
+import * as ReactDOM from "react-dom";
+import * as ReactDOMClient from "react-dom/client";
+import * as JSXRuntime from "react/jsx-runtime";
+import * as JSXDevRuntime from "react/jsx-dev-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
+function reactRemote(Component) {
+  const start = (el, props, ctx, hydrate) => {
+    const tree = (p) => /* @__PURE__ */ jsx(RemoteTree, { Component, props: p, ctx });
+    const options = { onUncaughtError: (e) => ctx.reportError(e) };
+    const root = hydrate ? hydrateRoot(el, tree(props), options) : createRoot(el, options);
+    const render = (p) => root.render(tree(p));
+    if (!hydrate) render(props);
+    return { update: render, unmount: () => root.unmount() };
+  };
+  return defineRemote({
+    mount: (el, props, ctx) => start(el, props, ctx, false),
+    hydrate: (el, props, ctx) => start(el, props, ctx, true)
+  });
+}
+function useVitral() {
+  return useContext(VitralContext);
+}
+function usePortalContainer() {
+  return useVitral()?.portalContainer;
+}
+function useEvent(type, handler) {
+  const ref = useRef(handler);
+  ref.current = handler;
+  useEffect(() => events.on(type, (p) => ref.current(p)), [type]);
+}
+function useEventValue(type) {
+  const [value, setValue] = useState(() => events.last(type));
+  useEvent(type, setValue);
+  return value;
+}
+function useShared(key, select = same) {
+  const handle = useMemo(() => shared(key), [key]);
+  const [pick] = useState(memoSelect);
+  return useSyncExternalStore(
+    handle.subscribe,
+    () => pick(handle.get(), select),
+    () => pick(void 0, select)
+  );
+}
+var offeredTo;
+function offerReact() {
+  const p = protocol();
+  if (offeredTo === p) return;
+  offeredTo = p;
+  const compiler = ReactAll.__COMPILER_RUNTIME;
+  const modules = {
+    react: ReactAll,
+    "react-dom": ReactDOM,
+    "react-dom/client": ReactDOMClient,
+    "react/jsx-runtime": JSXRuntime,
+    "react/jsx-dev-runtime": JSXDevRuntime,
+    // O React 19 expõe o react/compiler-runtime pelo próprio react.
+    ...compiler && { "react/compiler-runtime": compiler }
+  };
+  p.pending(import("./dedupe-PZCSKL3L.js").then((m) => m.offer(p, { react: { version: ReactAll.version, modules } })).catch(() => {
+  }));
+}
+function preload2(name, options) {
+  offerReact();
+  preload(name, options);
+}
+function Remote({
+  name,
+  src,
+  props,
+  isolate,
+  fallback = null,
+  error,
+  onError,
+  className,
+  loading,
+  prefetch,
+  priority,
+  keepAlive
+}) {
+  const target = useRef(null);
+  const slot = useRef(null);
+  const [state, setState] = useState({ status: "loading", error: null });
+  const onErrorRef = useRef(onError);
+  onErrorRef.current = onError;
+  useEffect(() => {
+    offerReact();
+    const s = hostSlot(target.current, {
+      name,
+      src,
+      props: props ?? {},
+      isolate,
+      loading,
+      prefetch,
+      priority,
+      keepAlive,
+      onStatus(status2, e) {
+        setState({ status: status2, error: e });
+        if (e) {
+          if (onErrorRef.current) onErrorRef.current(e);
+          else console.error(e);
+        }
+      }
+    });
+    slot.current = s;
+    return () => {
+      slot.current = null;
+      queueMicrotask(() => s.destroy());
+    };
+  }, []);
+  useEffect(() => slot.current?.set({ name, src, isolate }), [name, src, isolate]);
+  useEffect(() => slot.current?.update(props ?? {}), [props]);
+  const retry = () => slot.current?.retry();
+  const { status, error: err } = state;
+  return /* @__PURE__ */ jsxs("div", { className, "data-vitral": name ?? src, "data-vitral-status": status, children: [
+    status === "loading" && fallback,
+    status === "error" && err && (typeof error === "function" ? error(err, retry) : error ?? null),
+    /* @__PURE__ */ jsx("div", { ref: target })
+  ] });
+}
+
+export {
+  reactRemote,
+  useVitral,
+  usePortalContainer,
+  useEvent,
+  useEventValue,
+  useShared,
+  preload2 as preload,
+  Remote
+};

package/dist/chunk-6AFVJCQG.js

@@ -0,0 +1,311 @@
+// src/vite/dedupe.ts
+import { existsSync, readFileSync, realpathSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { pathToFileURL } from "url";
+
+// src/vite/exports.ts
+var nameOf = (n) => n.type === "Identifier" ? n.name : String(n.value);
+function bindings(node, out = []) {
+  if (!node) return out;
+  if (node.type === "Identifier") out.push(node.name);
+  else if (node.type === "ObjectPattern") for (const p of node.properties) bindings(p.type === "RestElement" ? p.argument : p.value, out);
+  else if (node.type === "ArrayPattern") for (const e of node.elements) bindings(e?.type === "RestElement" ? e.argument : e, out);
+  else if (node.type === "AssignmentPattern") bindings(node.left, out);
+  else if (node.type === "RestElement") bindings(node.argument, out);
+  return out;
+}
+async function exportOrigins(ctx, file, cache) {
+  const parsed = /* @__PURE__ */ new Map();
+  const queue = [file];
+  while (queue.length) {
+    const f = queue.shift();
+    if (parsed.has(f)) continue;
+    let p = cache.get(f);
+    if (!p) cache.set(f, p = read(ctx, f));
+    const done = await p;
+    parsed.set(f, done);
+    queue.push(...done.star, ...done.named.flatMap((n) => n.source ? [n.source] : []));
+  }
+  return origins(file, parsed, /* @__PURE__ */ new Map(), []);
+}
+function origins(file, parsed, memo, stack) {
+  if (stack.includes(file)) return /* @__PURE__ */ new Map();
+  const known = memo.get(file);
+  if (known) return known;
+  const p = parsed.get(file);
+  const next = [...stack, file];
+  const out = new Map(p.local);
+  for (const n of p.named) out.set(n.exported, n.source && origins(n.source, parsed, memo, next).get(n.name) || n.fallback);
+  for (const s of p.star) for (const [name, origin] of origins(s, parsed, memo, next)) if (name !== "default" && !out.has(name)) out.set(name, origin);
+  memo.set(file, out);
+  return out;
+}
+async function read(ctx, file) {
+  const out = { local: /* @__PURE__ */ new Map(), named: [], star: [] };
+  const info = await ctx.load({ id: file });
+  if (!info.code) return out;
+  const body = ctx.parse(info.code).body ?? [];
+  const target = async (source) => {
+    const r = await ctx.resolve(source, file, { skipSelf: false });
+    return r && !r.external ? r.id : void 0;
+  };
+  const imports = /* @__PURE__ */ new Map();
+  for (const n of body)
+    if (n.type === "ImportDeclaration") {
+      for (const s of n.specifiers)
+        if (s.type !== "ImportNamespaceSpecifier")
+          imports.set(s.local.name, { source: n.source.value, name: s.type === "ImportDefaultSpecifier" ? "default" : nameOf(s.imported) });
+    }
+  const fixed = /* @__PURE__ */ new Set();
+  for (const n of body) {
+    const d = n.type === "ExportNamedDeclaration" ? n.declaration : n;
+    if (d?.type === "FunctionDeclaration" || d?.type === "ClassDeclaration") d.id && fixed.add(d.id.name);
+    else if (d?.type === "VariableDeclaration" && d.kind === "const") for (const x of d.declarations) for (const name of bindings(x.id)) fixed.add(name);
+  }
+  for (const n of body) {
+    if (n.type === "ExportDefaultDeclaration") {
+      const id = n.declaration.type === "Identifier" ? n.declaration.name : void 0;
+      const via = id ? imports.get(id) : void 0;
+      if (via) out.named.push({ exported: "default", name: via.name, source: await target(via.source), fallback: `${file}#default` });
+      else out.local.set("default", id && fixed.has(id) ? `${file}#${id}` : `${file}#default`);
+    } else if (n.type === "ExportAllDeclaration") {
+      if (n.exported) out.local.set(nameOf(n.exported), `${file}#${nameOf(n.exported)}`);
+      else {
+        const t = await target(n.source.value);
+        if (t) out.star.push(t);
+      }
+    } else if (n.type === "ExportNamedDeclaration") {
+      if (n.exportKind === "type") continue;
+      if (n.declaration) {
+        const d = n.declaration;
+        const names = d.type === "VariableDeclaration" ? d.declarations.flatMap((x) => bindings(x.id)) : d.id ? [d.id.name] : [];
+        for (const name of names) out.local.set(name, `${file}#${name}`);
+      }
+      for (const s of n.specifiers ?? []) {
+        if (s.exportKind === "type") continue;
+        const exported = nameOf(s.exported);
+        const local = nameOf(s.local);
+        const via = n.source ? { source: n.source.value, name: local } : imports.get(local);
+        const fallback = `${file}#${n.source ? exported : local}`;
+        out.named.push({ exported, name: via?.name ?? local, source: via ? await target(via.source) : void 0, fallback });
+      }
+    }
+  }
+  return out;
+}
+
+// src/vite/dedupe.ts
+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 DEEP = "\0vitral-deep:";
+var pkgOf = (spec) => spec.split("/").slice(0, spec.startsWith("@") ? 2 : 1).join("/");
+var norm = (p) => p.replace(/\\/g, "/");
+var groupOf = (spec) => REACT.includes(spec) || pkgOf(spec) === "scheduler" ? "react" : pkgOf(spec);
+var ident = /^[A-Za-z_$][\w$]*$/;
+function packageOf(file, pkg) {
+  for (let dir = dirname(file); dir !== dirname(dir); dir = dirname(dir)) {
+    const json = join(dir, "package.json");
+    if (!existsSync(json)) continue;
+    const data = JSON.parse(readFileSync(json, "utf8"));
+    if (data.name === pkg) return { dir, data };
+  }
+  throw new Error(`vitral: vers\xE3o de ${pkg} n\xE3o encontrada`);
+}
+function subpaths(pkg, data) {
+  const exp = data.exports;
+  if (!exp || typeof exp !== "object" || Array.isArray(exp) || !Object.keys(exp).some((k) => k.startsWith("."))) return [pkg];
+  const target = (v) => typeof v === "string" ? v : v && typeof v === "object" ? target(v.import ?? v.default ?? v.require ?? Object.values(v)[0]) : "";
+  return Object.keys(exp).filter((k) => !k.includes("*") && !/\.(json|css|scss)$/.test(target(exp[k]))).map((k) => k === "." ? pkg : pkg + k.slice(1));
+}
+async function groups(list, root, entry, resolveId) {
+  const importer = resolve(root, entry);
+  const byName = /* @__PURE__ */ new Map();
+  const all = /* @__PURE__ */ new Set();
+  for (const spec of list) {
+    const g = groupOf(spec);
+    if (spec.endsWith("/*")) all.add(g);
+    byName.set(g, [.../* @__PURE__ */ new Set([...byName.get(g) ?? [], ...g === "react" ? REACT : [spec.endsWith("/*") ? g : spec]])]);
+  }
+  const out = [];
+  for (const [name, list2] of byName) {
+    const group = { name, range: "", version: "", keys: [], names: {}, pkgs: name === "react" ? ["react", "react-dom", "scheduler"] : [name] };
+    let specs = list2;
+    for (let i = 0; i < specs.length; i++) {
+      const spec = specs[i];
+      const found = await resolveId(spec, importer);
+      if (!found) {
+        if (spec === name) throw new Error(`vitral: dedupe: ${spec} n\xE3o est\xE1 instalado`);
+        continue;
+      }
+      if (spec === name) {
+        const pkg = packageOf(found.id, name);
+        group.version = pkg.data.version;
+        group.dir = norm(realpathSync(pkg.dir));
+        if (all.has(name)) {
+          group.files = true;
+          specs = [.../* @__PURE__ */ new Set([...specs, ...subpaths(name, pkg.data)])];
+        }
+      }
+      try {
+        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));
+      } catch {
+      }
+      group.keys.push(spec);
+    }
+    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.replace(/\/\*$/, "")]));
+  return new RegExp(`${escape(BOOT)}$|^(${[DEPS, ...specs].map(escape).join("|")})$|^(${escape(OWN)}|${escape(SHIM)}|${escape(DEEP)})`);
+}
+function dedupeHooks(entry, getGroups) {
+  const keyOf = (id) => getGroups().find((g) => g.keys.includes(id));
+  const inside = (g, file) => {
+    const f = norm(file);
+    return g.pkgs.some((p) => f.includes(`/node_modules/${p}/`)) || !!g.dir && f.startsWith(g.dir + "/");
+  };
+  let entries;
+  let origins2 = /* @__PURE__ */ new Map();
+  const exports = /* @__PURE__ */ new Map();
+  const entryFiles = (ctx) => entries ??= (async () => {
+    const map = /* @__PURE__ */ new Map();
+    for (const g of getGroups())
+      if (g.files)
+        for (const k of g.keys) {
+          const r = await ctx.resolve(k, void 0, { skipSelf: true });
+          if (r && !r.external) map.set(r.id, k);
+        }
+    return map;
+  })();
+  const originsOf = (ctx, g) => {
+    if (!origins2.has(g.name))
+      origins2.set(g.name, (async () => {
+        const files = await entryFiles(ctx);
+        const index = /* @__PURE__ */ new Map();
+        for (const [file, spec] of files) {
+          if (!g.keys.includes(spec)) continue;
+          for (const [name, origin] of await exportOrigins(ctx, file, exports)) if (!index.has(origin)) index.set(origin, { spec, name });
+        }
+        return index;
+      })());
+    return origins2.get(g.name);
+  };
+  return {
+    /** Nova build: esquece o que foi lido da anterior. */
+    reset() {
+      entries = void 0;
+      origins2 = /* @__PURE__ */ new Map();
+      exports.clear();
+    },
+    /** Algum grupo troca também os imports que chegam a arquivos do pacote? */
+    files: () => getGroups().some((g) => g.files),
+    resolveId: {
+      order: "pre",
+      handler(id, importer) {
+        if (id.endsWith(BOOT)) return `\0${BOOT}`;
+        if (id === DEPS || id.startsWith(OWN) || id.startsWith(SHIM) || id.startsWith(DEEP)) return id;
+        const g = keyOf(id);
+        if (!g || !importer || importer.startsWith(OWN)) return null;
+        if (inside(g, importer)) return null;
+        return SHIM + id;
+      }
+    },
+    /**
+     * Um import já resolvido que chega a um arquivo de um grupo com `files`
+     * (por alias, `paths` do tsconfig ou caminho direto): vira o shim do
+     * especificador daquele arquivo, ou de um arquivo interno que o pacote reexporta.
+     */
+    async resolved(ctx, file, importer) {
+      if (!importer || importer.startsWith("\0")) return null;
+      const g = getGroups().find((x) => x.files && inside(x, file));
+      if (!g || inside(g, importer)) return null;
+      const spec = (await entryFiles(ctx)).get(file);
+      return spec ? SHIM + spec : DEEP + file;
+    },
+    async load(ctx, 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 g = keyOf(spec);
+        let names = g.names[spec];
+        if (!names) {
+          const file = [...await entryFiles(ctx)].find(([, k]) => k === spec)?.[0];
+          names = file ? [...(await exportOrigins(ctx, file, exports)).keys()].filter((n) => n !== "default" && ident.test(n)) : [];
+        }
+        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
+` : "");
+      }
+      if (id.startsWith(DEEP)) {
+        const file = id.slice(DEEP.length);
+        const g = getGroups().find((x) => x.files && inside(x, file));
+        const index = await originsOf(ctx, g);
+        const own = await exportOrigins(ctx, file, exports);
+        const via = [...own].map(([name, origin]) => [name, index.get(origin)]);
+        const f = JSON.stringify(file);
+        const shared = via.filter(([, v]) => v);
+        const rest = via.filter(([, v]) => !v).map(([name]) => name);
+        if (!shared.length) {
+          ctx.warn?.(`dedupe: ${file.slice(g.dir.length + 1)} n\xE3o sai por nenhum export de ${g.name}: o remote leva uma c\xF3pia pr\xF3pria deste arquivo`);
+          return `export * from ${f}
+` + (own.has("default") ? `export { default } from ${f}
+` : "");
+        }
+        if (rest.length)
+          ctx.warn?.(`dedupe: ${file.slice(g.dir.length + 1)}: ${rest.join(", ")} n\xE3o sai(em) por nenhum export de ${g.name}: esses nomes v\xEAm de uma c\xF3pia pr\xF3pria deste arquivo`);
+        return `import { deps } from ${JSON.stringify(DEPS)}
+` + shared.map(([name, v], i) => `const v${i} = deps[${JSON.stringify(v.spec)}][${JSON.stringify(v.name)}]
+` + (name === "default" ? `export default v${i}
+` : `export { v${i} as ${JSON.stringify(name)} }
+`)).join("") + (rest.length ? `export { ${rest.map((n) => n === "default" ? "default" : JSON.stringify(n)).join(", ")} } from ${f}
+` : "");
+      }
+      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 }))
+  const missing = m ? keys.filter((k) => !(k in m)) : []
+  if (missing.length) console.warn("[vitral] dedupe: a oferta de " + name + " n\xE3o tem " + missing.join(", ") + "; o remote usa a c\xF3pia pr\xF3pria inteira")
+  if (!m || missing.length) m = await load()
+  Object.assign(deps, m)
+}
+await Promise.all([${calls.join(", ")}])
+const remote = await import(${JSON.stringify(entry)})
+export default remote.default
+`;
+}
+
+export {
+  BOOT,
+  subpaths,
+  groups,
+  dedupeIds,
+  dedupeHooks
+};