vitral 0.2.0 → 0.4.0

package/dist/single-spa.js

@@ -0,0 +1,52 @@
+// src/single-spa.ts
+async function run(fns, props) {
+  for (const fn of [fns ?? []].flat()) await fn(props);
+}
+function singleSpaRemote(lifecycles) {
+  const l = "mount" in lifecycles ? lifecycles : lifecycles.default;
+  if (typeof l?.mount == "undefined" || typeof l.unmount == "undefined") throw new Error("[vitral] singleSpaRemote: faltam os lifecycles mount e unmount");
+  let booted;
+  let queue = Promise.resolve();
+  const used = /* @__PURE__ */ new Set();
+  const step = (fn) => queue = queue.then(fn, fn);
+  const boot = (props) => booted ??= run(l.bootstrap, props).catch((e) => {
+    booted = void 0;
+    throw e;
+  });
+  return {
+    async mount(el, props, ctx) {
+      let name = ctx.name;
+      for (let i = 2; used.has(name); i++) name = `${ctx.name}-${i}`;
+      used.add(name);
+      let current = { ...props, name, domElement: el };
+      try {
+        await step(async () => {
+          await boot(current);
+          await run(l.mount, current);
+        });
+      } catch (e) {
+        used.delete(name);
+        throw e;
+      }
+      const report = (e) => ctx.reportError(e);
+      return {
+        update(next) {
+          const before = current;
+          current = { ...next, name, domElement: el };
+          const job = l.update ? step(() => run(l.update, current)) : step(async () => {
+            await run(l.unmount, before);
+            await run(l.mount, current);
+          });
+          job.catch(report);
+        },
+        unmount() {
+          used.delete(name);
+          step(() => run(l.unmount, current)).catch(report);
+        }
+      };
+    }
+  };
+}
+export {
+  singleSpaRemote
+};

package/dist/{slot-pB276oPt.d.ts → slot-UPg6ob9v.d.ts}

@@ -1,5 +1,5 @@
-import { R as RemoteError } from './errors-KKB8FGCz.js';
-import { P as Props, I as Isolation, b as StyleOptions } from './types-BV-hUrms.js';
+import { R as RemoteError } from './errors-kjBv6IH_.js';
+import { P as Props, I as Isolation, d as StyleOptions } from './types-CA2p9KHC.js';
 
 type SlotStatus = 'loading' | 'ready' | 'error';
 interface SlotOptions<P extends Props = Props> {

package/dist/solid.d.ts

@@ -1,8 +1,8 @@
 import { JSX, Component, Accessor } from 'solid-js';
-import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared } from './types-BV-hUrms.js';
-export { R as RemoteContext } from './types-BV-hUrms.js';
-import { R as RemoteError } from './errors-KKB8FGCz.js';
-export { e as events } from './events-DUdjhfps.js';
+import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared } from './types-CA2p9KHC.js';
+export { R as RemoteContext } from './types-CA2p9KHC.js';
+import { R as RemoteError } from './errors-kjBv6IH_.js';
+export { e as events } from './events-Dkpkw_Sv.js';
 export { n as navigate } from './navigate-BRG1WJUM.js';
 import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 

package/dist/solid.js

@@ -1,6 +1,6 @@
 import {
   hostSlot
-} from "./chunk-UTYAX6MU.js";
+} from "./chunk-W6322KGP.js";
 import {
   defineRemote,
   events,
@@ -8,10 +8,11 @@ import {
   navigate,
   same,
   shared
-} from "./chunk-NCONW6WS.js";
-import "./chunk-2XF5BKV3.js";
-import "./chunk-SFL6LTP3.js";
-import "./chunk-PX7PBCCT.js";
+} from "./chunk-WD4CDGDZ.js";
+import "./chunk-EMSB2NVX.js";
+import "./chunk-6EX5KYT5.js";
+import "./chunk-TW7KYJQ6.js";
+import "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";
 
 // src/solid.ts

package/dist/{sri-BVKZNX5Q.js → sri-M7ZRU57G.js}

@@ -1,12 +1,14 @@
 import {
   verifyIntegrity
-} from "./chunk-S5MZT5IT.js";
+} from "./chunk-UYOPJ4XQ.js";
 import {
-  RemoteError,
   addLink,
   fetchBytes,
   withTimeout
-} from "./chunk-PX7PBCCT.js";
+} from "./chunk-TW7KYJQ6.js";
+import {
+  RemoteError
+} from "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";
 
 // src/core/sri.ts
@@ -39,7 +41,24 @@ var STRICT = /^(sha(256|384|512)-[A-Za-z0-9+/]+={0,2}( +|$))+$/;
 var PROBE = "data:text/javascript,export{}";
 var PROBE_SRI = "sha256-d3bjIZdvLjBurwdLwkSVOnEBPFFly+T1SR9r3VVHBGg=";
 var maps;
+var probing;
 var preloads;
+var KEY = "vitral:sri-map";
+async function useMap(sri) {
+  if (probing) return await probing && addMap(sri, false);
+  let seen = false;
+  try {
+    seen = localStorage[KEY] === navigator.userAgent;
+  } catch {
+  }
+  const ok = await (probing = addMap(sri, !seen));
+  if (ok && !seen)
+    try {
+      localStorage[KEY] = navigator.userAgent;
+    } catch {
+    }
+  return ok;
+}
 var tick = () => new Promise((resolve) => {
   const c = new MessageChannel();
   c.port1.onmessage = () => resolve();
@@ -52,7 +71,7 @@ async function verified(build, run) {
   const p = globalThis[/* @__PURE__ */ Symbol.for("vitral")];
   const share = async (pre) => {
     if (!run || !dedupe.length) return;
-    const { shared } = await import("./dedupe-IWFIXRWG.js");
+    const { shared } = await import("./dedupe-S7BHQMOZ.js");
     for (const d of dedupe)
       shared(p)(d.name, d.range, {
         version: d.version,
@@ -63,7 +82,7 @@ async function verified(build, run) {
         }
       });
   };
-  if (maps !== false && (maps = await addMap(sri))) {
+  if (maps !== false && (maps = await useMap(sri))) {
     await share();
     for (const u of chunks) fetch(u, { priority }).catch(() => {
     });
@@ -76,7 +95,12 @@ async function verified(build, run) {
     return entry;
   }
 }
-async function addMap(integrity) {
+async function addMap(sri, probe) {
+  if (!HTMLScriptElement.supports?.("importmap")) return false;
+  const integrity = {};
+  for (const u in sri) if (!/\.css([?#]|$)/.test(u)) integrity[u] = sri[u];
+  const urls = probe ? ["export{}", "export{}//"].map((c) => URL.createObjectURL(new Blob([c], { type: "text/javascript" }))) : [];
+  for (const u of urls) integrity[u] = PROBE_SRI;
   let ok = true;
   try {
     const s = document.createElement("script");
@@ -86,11 +110,17 @@ async function addMap(integrity) {
     s.addEventListener("securitypolicyviolation", () => ok = false);
     s.textContent = JSON.stringify({ integrity });
     document.head.append(s);
+    await tick();
+    await tick();
+    if (ok && probe) ok = await check((u) => import(
+      /* @vite-ignore */
+      /* webpackIgnore: true */
+      u
+    ), urls[0], urls[1]);
   } catch {
-    return false;
+    ok = false;
   }
-  await tick();
-  await tick();
+  for (const u of urls) URL.revokeObjectURL(u);
   return ok;
 }
 function preload(href, integrity, fetchPriority = "auto") {
@@ -102,9 +132,11 @@ function preload(href, integrity, fetchPriority = "auto") {
 }
 function checkPreloads() {
   if (!document.createElement("link").relList.supports("modulepreload")) return Promise.resolve(false);
-  const run = (href, good) => preload(href, PROBE_SRI).then(() => good, () => !good);
+  return check((href) => preload(href, PROBE_SRI), PROBE, PROBE + "//");
+}
+function check(load, good, bad) {
   return Promise.race([
-    Promise.all([run(PROBE, true), run(PROBE + "//", false)]).then(([a, b]) => a && b),
+    Promise.all([load(good).then(() => true, () => false), load(bad).then(() => false, () => true)]).then(([a, b]) => a && b),
     new Promise((resolve) => setTimeout(resolve, 3e3, false))
   ]);
 }

package/dist/svelte.d.ts

@@ -1,9 +1,9 @@
 import { Component } from 'svelte';
-import { P as Props, I as Isolation, a as RemoteModule } from './types-BV-hUrms.js';
-export { R as RemoteContext } from './types-BV-hUrms.js';
-import { R as RemoteError } from './errors-KKB8FGCz.js';
-import { S as SlotStatus } from './slot-pB276oPt.js';
-export { e as events } from './events-DUdjhfps.js';
+import { P as Props, I as Isolation, a as RemoteModule } from './types-CA2p9KHC.js';
+export { R as RemoteContext } from './types-CA2p9KHC.js';
+import { R as RemoteError } from './errors-kjBv6IH_.js';
+import { S as SlotStatus } from './slot-UPg6ob9v.js';
+export { e as events } from './events-Dkpkw_Sv.js';
 export { n as navigate } from './navigate-BRG1WJUM.js';
 import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 

package/dist/svelte.js

@@ -1,14 +1,15 @@
 import {
   hostSlot
-} from "./chunk-UTYAX6MU.js";
+} from "./chunk-W6322KGP.js";
 import {
   defineRemote,
   events,
   navigate
-} from "./chunk-NCONW6WS.js";
-import "./chunk-2XF5BKV3.js";
-import "./chunk-SFL6LTP3.js";
-import "./chunk-PX7PBCCT.js";
+} from "./chunk-WD4CDGDZ.js";
+import "./chunk-EMSB2NVX.js";
+import "./chunk-6EX5KYT5.js";
+import "./chunk-TW7KYJQ6.js";
+import "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";
 
 // src/svelte.ts

package/dist/testing.d.ts

@@ -1,5 +1,6 @@
-import { P as Props, R as RemoteContext } from './types-BV-hUrms.js';
+import { P as Props, R as RemoteContext } from './types-CA2p9KHC.js';
 export { r as resetVitral } from './state-BDdCwc21.js';
+import './errors-kjBv6IH_.js';
 
 /**
  * Utilidades de teste: monte o host sem subir nenhum remote de verdade.

package/dist/testing.js

@@ -1,9 +1,10 @@
-import "./chunk-NCONW6WS.js";
+import "./chunk-WD4CDGDZ.js";
 import {
   register
-} from "./chunk-2XF5BKV3.js";
-import "./chunk-SFL6LTP3.js";
-import "./chunk-PX7PBCCT.js";
+} from "./chunk-EMSB2NVX.js";
+import "./chunk-6EX5KYT5.js";
+import "./chunk-TW7KYJQ6.js";
+import "./chunk-463H6B56.js";
 import {
   resetProtocol
 } from "./chunk-GNPFWISJ.js";

package/dist/{types-BV-hUrms.d.ts → types-CA2p9KHC.d.ts}

@@ -1,3 +1,5 @@
+import { R as RemoteError } from './errors-kjBv6IH_.js';
+
 /**
  * Tipos das chaves compartilhadas. Declare uma vez no projeto:
  *
@@ -90,6 +92,24 @@ interface RemoteContext {
     events: EventBus;
     /** Shadow root quando o host pediu isolamento, senão `null`. */
     shadowRoot: ShadowRoot | null;
+    /**
+     * Onde popovers, menus e dialogs devem ser renderizados (`container` do
+     * Radix e do MUI, `Teleport` do Vue). No Shadow DOM é um elemento dentro do
+     * shadow root, com os estilos e o tema do remote; senão, `document.body`.
+     * Hosts antigos não mandam este campo.
+     */
+    portalContainer?: HTMLElement;
+    /**
+     * Registro de custom elements do remote. No Shadow DOM, onde o navegador
+     * tem Scoped Custom Element Registries (Chrome 146+, Safari 26+), é um
+     * registro só deste remote, usado pelo shadow root e pelo elemento `el`:
+     * dois remotes podem definir `<ds-button>` de versões diferentes. Sem
+     * suporte, e fora do Shadow DOM, é o `customElements` global. No Shadow
+     * DOM, `define` de uma tag já definida não lança: fica a definição que já
+     * existe, com um aviso em dev quando ela veio de outro remote. Hosts
+     * antigos não mandam este campo: use `ctx.customElements ?? customElements`.
+     */
+    customElements?: CustomElementRegistry;
     /** Avisa o host de um erro em tempo de execução (os adaptadores já chamam). */
     reportError(error: unknown): void;
     /** Navega a página inteira (host e todos os roteadores) para `url`. */
@@ -115,6 +135,21 @@ interface RemoteContext {
      * (`provide`, `shared` ou um hook); senão, importe `shared` de 'vitral'.
      */
     shared?: SharedApi;
+    /**
+     * Só quando o remote roda como MCP App (`vitral({ target: 'mcp-app' })`):
+     * fala JSON-RPC direto com o host MCP, para o que `events` não cobre
+     * (`tools/call`, `resources/read`, `ui/request-display-mode`…).
+     */
+    mcp?: McpAppBridge;
+}
+/** `ctx.mcp` de um remote empacotado como MCP App. */
+interface McpAppBridge {
+    /** Pedido ao host; resolve com `result` ou rejeita com `error.message`. */
+    request<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T>;
+    /** Notificação ao host (sem resposta). */
+    notify(method: string, params?: Record<string, unknown>): void;
+    /** O `hostContext` atual (tema, idioma, tamanho do container…), já com as mudanças. */
+    hostContext(): Record<string, unknown> | undefined;
 }
 interface MountedRemote<P extends Props = Props> {
     update?(props: P): void;
@@ -140,11 +175,70 @@ interface RemoteEntry {
     /** Isolamento padrão para este remote. */
     isolate?: Isolation;
     /**
-     * O `vitral.json` já baixado (ex.: por `vitral registry`), para não buscá-lo
+     * O `vitral.json` já baixado (ex.: no build do host), para não buscá-lo
      * na hora. Os caminhos dele são relativos a `url`, e os hashes ficam fixos
      * no host.
      */
     manifest?: RemoteManifest;
+    /**
+     * Faixa de versão do contrato do remote que o host aceita (ex.: `'^2'`).
+     * Vence a de `configure`. Veja `VitralConfig.contract`.
+     */
+    contract?: string;
+    /**
+     * Com `url` apontando para um canal (`canal.json`): escolhe a versão deste
+     * usuário. Devolve a versão (`'1.5.0'`) ou a URL de um `vitral.json`;
+     * `undefined` usa a regra padrão (`canary.percent`). Veja `Channel`.
+     */
+    resolve?: (channel: Channel, ctx: ChannelContext) => string | undefined | Promise<string | undefined>;
+    /**
+     * Volta para a estável, até o fim da sessão, quando a versão que não é a
+     * estável gera `errors` erros numa janela de `mounts` montagens. Padrão
+     * `{ errors: 3, mounts: 20 }`. `false` desliga.
+     */
+    rollback?: {
+        errors?: number;
+        mounts?: number;
+    } | false;
+}
+/**
+ * Arquivo-ponteiro de um remote (o canal, ex.: `canal.json`): diz que versão
+ * cada usuário recebe. Cada versão fica na própria pasta, ao lado do canal
+ * (`'1.4.0'` → `1.4.0/vitral.json`), ou é a URL de um `vitral.json`.
+ *
+ *   { "stable": "1.4.0", "canary": { "version": "1.5.0", "percent": 10 } }
+ */
+interface Channel {
+    /** Versão de todos os usuários fora da canary. */
+    stable: string;
+    /** Versão nova para `percent`% dos usuários (0 a 100). */
+    canary?: {
+        version: string;
+        percent: number;
+    };
+    /** Campos próprios, para o `resolve` do host ler (ex.: `"beta": "1.6.0"`). */
+    [key: string]: unknown;
+}
+/** O que o `resolve` de um canal recebe além do canal. */
+interface ChannelContext {
+    /** Nome do remote. */
+    name: string;
+    /**
+     * Número de 0 a 99, sempre o mesmo para este navegador (ou para
+     * `canaryKey`) e este remote. A regra padrão dá a canary a quem tem
+     * `bucket < percent`.
+     */
+    bucket: number;
+}
+/** Aviso de rollback automático, para `configure({ onRollback })`. */
+interface RollbackInfo {
+    name: string;
+    /** Versão abandonada (como o canal ou o `resolve` a escreveram). */
+    from: string;
+    /** Versão estável, usada daqui até o fim da sessão. */
+    to: string;
+    errors: number;
+    mounts: number;
 }
 /**
  * `none`: CSS com escopo. `shadow`: Shadow DOM. `iframe`: iframe com
@@ -164,6 +258,15 @@ interface StyleOptions {
      */
     mirrorTheme?: boolean;
 }
+/** Opções de `configure({ devOverrides })`. */
+interface DevOverrides {
+    /**
+     * Modelo da URL de um apelido: `?vitral=checkout@pr-123` com
+     * `'https://{name}-{ref}.preview.empresa.com'` vira
+     * `https://checkout-pr-123.preview.empresa.com/vitral.json`.
+     */
+    preview?: string;
+}
 interface VitralConfig {
     /** Mapa nome → URL (ou entrada completa), ou a URL de um JSON com esse mapa. */
     remotes?: Record<string, string | RemoteEntry> | string;
@@ -182,13 +285,26 @@ interface VitralConfig {
      * Liga os overrides de desenvolvimento (`?vitral=nome@url` e
      * `localStorage['vitral:overrides']`) fora de localhost. Em localhost já
      * valem. Nunca ligue em produção: um link com `?vitral=` executaria código
-     * de qualquer origem.
+     * de qualquer origem. O objeto também liga e aceita `preview`, o modelo de
+     * URL dos apelidos (`?vitral=checkout@pr-123`).
      */
-    devOverrides?: boolean;
+    devOverrides?: boolean | DevOverrides;
     /** Estilos do host no Shadow DOM: `{ inherit: ['/assets/base.css'] }`. */
     styles?: StyleOptions;
     /** Recebe o tempo de cada etapa do carregamento (para RUM). */
     onMetric?: (metric: RemoteMetric) => void;
+    /**
+     * Recebe cada `RemoteError` de qualquer remote (falha de download, de
+     * `mount`, erro de render), uma vez só por erro, além do `onError` de cada
+     * montagem. Use para mandar os erros ao seu monitoramento.
+     */
+    onError?: (error: RemoteError) => void;
+    /**
+     * Atribui a um remote os erros sem tratamento (`error` e
+     * `unhandledrejection` da janela) cujo topo da pilha é um arquivo dele, e
+     * entrega como `RENDER_FAILED` ao `onError`. Padrão `false`.
+     */
+    captureGlobalErrors?: boolean;
     /**
      * Dependências que o host oferece aos remotes com `dedupe`, por grupo:
      * `{ vue: { version: Vue.version, modules: { vue: Vue } } }`. O remote usa
@@ -198,6 +314,24 @@ interface VitralConfig {
         version: string;
         modules: SharedModules;
     }>;
+    /**
+     * Faixa de versão do contrato que o host aceita dos remotes (ex.: `'^2'`).
+     * Antes de executar o remote, o host confere a versão do `contract` do
+     * manifesto e as dependências que ele espera do host; se não servir, o
+     * remote não monta (`CONTRACT_MISMATCH`). Sem contrato no manifesto, nada é
+     * conferido. `'*'` confere só as dependências.
+     */
+    contract?: string;
+    /**
+     * Chave estável do usuário (ex.: o id dele) para sortear quem recebe a
+     * canary de um canal. Padrão: um id aleatório guardado no `localStorage`.
+     */
+    canaryKey?: string;
+    /**
+     * Chamado quando a versão canary de um canal passa do limite de erros e o
+     * host volta para a estável (veja `RemoteEntry.rollback`).
+     */
+    onRollback?: (info: RollbackInfo) => void;
 }
 /** Módulos de um grupo de `dedupe`, por especificador (`'react-dom/client'`). */
 type SharedModules = Record<string, unknown>;
@@ -253,6 +387,42 @@ interface RemoteManifest {
         file: string;
         chunks?: string[];
     }[];
+    /** O que o remote declara para o host conferir antes de montar. */
+    contract?: RemoteContract;
+    /**
+     * CSS já preparado no build para o Shadow DOM. Sem este campo (manifestos
+     * antigos), o runtime faz esse trabalho em cada página.
+     */
+    shadow?: ShadowCss;
+    /**
+     * SBOM CycloneDX do remote (opção `sbom` do plugin): o arquivo, relativo
+     * ao manifesto, e o hash dele. O runtime não usa; é para auditoria.
+     */
+    sbom?: {
+        file: string;
+        integrity: string;
+    };
+}
+/** Contrato do remote no `vitral.json`. */
+interface RemoteContract {
+    /** Versão do contrato (opção `contract.version` do plugin). */
+    version?: string;
+    /** Faixa aceita de cada dependência de `dedupe`, por grupo (`{ react: '^19.0.0' }`). */
+    peers?: Record<string, string>;
+}
+/**
+ * CSS do remote preparado no build para `isolate: 'shadow'`. Os caminhos são
+ * relativos ao primeiro arquivo de `css` (o plugin grava tudo na mesma pasta).
+ */
+interface ShadowCss {
+    /** Cada arquivo de `css`, na mesma ordem, sem `@import`, `@property` e `@font-face`. */
+    css: string[];
+    /** `@property` e `@font-face`, que só valem no documento (vão num `<link>`). */
+    global?: string[];
+    /** `@import` que o build não embutiu (outra origem), adotados antes de `css`. */
+    imports?: string[];
+    /** O CSS ainda tem `url()` relativa, que precisa apontar para o remote. */
+    rebase?: boolean;
 }
 type Handler<T = unknown> = (payload: T) => void;
 interface EventBus {
@@ -262,4 +432,4 @@ interface EventBus {
     last<T = unknown>(type: string): T | undefined;
 }
 
-export { type CheckedProps as C, type EventBus as E, type Handler as H, type Isolation as I, type MountedRemote as M, type Props as P, type RemoteContext as R, type Shared as S, type VitralConfig as V, type RemoteModule as a, type StyleOptions as b, type RemoteEntry as c, type SharedValue as d, type PropsOf as e, type ProvideOptions as f, type ProvidedValue as g, type RemoteManifest as h, type RemoteMetric as i, type Remotes as j, type SharedApi as k, type SharedModules as l, type SharedType as m, batch as n, provide as p, shared as s };
+export { type CheckedProps as C, type DevOverrides as D, type EventBus as E, type Handler as H, type Isolation as I, type MountedRemote as M, type Props as P, type RemoteContext as R, type Shared as S, type VitralConfig as V, type RemoteModule as a, type SharedModules as b, type RemoteEntry as c, type StyleOptions as d, type SharedValue as e, type Channel as f, type ChannelContext as g, type McpAppBridge as h, type PropsOf as i, type ProvideOptions as j, type ProvidedValue as k, type RemoteContract as l, type RemoteManifest as m, type RemoteMetric as n, type Remotes as o, type RollbackInfo as p, type SharedApi as q, type SharedType as r, batch as s, provide as t, shared as u };

package/dist/vite.d.ts

@@ -72,6 +72,32 @@ interface VitralViteOptions extends CssBuildOptions {
      * projeto e de entrada .ts/.tsx/.js/.jsx. Padrão: true.
      */
     types?: boolean;
+    /**
+     * Contrato publicado no `vitral.json`. O host que declara
+     * `contract: '^2'` só monta o remote se `version` estiver na faixa. As
+     * faixas de `dedupe` entram sozinhas, em `peers`. Padrão: sem versão.
+     */
+    contract?: {
+        version?: string;
+    };
+    /**
+     * Gera `sbom.cdx.json` (CycloneDX 1.6) com os pacotes npm que entraram no
+     * bundle, e o `vitral.json` aponta para ele em `sbom`. Padrão: false.
+     */
+    sbom?: boolean;
+    /**
+     * `'mcp-app'`: o build gera só `mcp-app.html`, um HTML único com o JS e o
+     * CSS inline, para um servidor MCP servir como recurso `ui://` (MCP Apps).
+     * As notificações do host viram props e `ctx.events.emit` vira mensagem
+     * para o host. Não combina com `exposes`, `dedupe` nem `shared`.
+     */
+    target?: 'mcp-app';
+    /**
+     * Grava o build em uma pasta por versão (`dist/1.5.0/`), para publicar
+     * cada versão sem apagar as anteriores e escolher qual vale num canal
+     * (`canal.json`). Usa `version` (ou a do package.json). Padrão: false.
+     */
+    versionDir?: boolean;
 }
 declare function vitral(options?: VitralViteOptions): Plugin;