vitral 0.1.0 → 0.2.0

package/dist/slot-pB276oPt.d.ts

@@ -0,0 +1,36 @@
+import { R as RemoteError } from './errors-KKB8FGCz.js';
+import { P as Props, I as Isolation, b as StyleOptions } from './types-BV-hUrms.js';
+
+type SlotStatus = 'loading' | 'ready' | 'error';
+interface SlotOptions<P extends Props = Props> {
+    /** Nome registrado. Com `src`, é o nome sob o qual a URL é registrada (opcional). */
+    name?: string;
+    /** URL do `vitral.json` (ou do JS). Registra o remote sem `configure()`. */
+    src?: string;
+    props?: P;
+    isolate?: Isolation;
+    /** `'high'` para o remote que aparece logo ao abrir a página. */
+    priority?: RequestPriority;
+    /** Estilos do host no Shadow DOM (somados aos do `configure`). */
+    styles?: StyleOptions;
+    /** Chamado a cada mudança de estado (para mostrar fallback / erro). */
+    onStatus?: (status: SlotStatus, error: RemoteError | null) => void;
+}
+interface RemoteSlot<P extends Props = Props> {
+    /** Atualiza as props sem remontar. */
+    update(props: P): void;
+    /** Troca de remote ou de isolamento (remonta). */
+    set(options: Partial<Pick<SlotOptions<P>, 'name' | 'src' | 'isolate'>>): void;
+    /** Remonta do zero (botão "tentar de novo"). */
+    retry(): void;
+    destroy(): void;
+    readonly status: SlotStatus;
+}
+/**
+ * Cuida do ciclo de vida de um remote dentro de `target`: monta, atualiza,
+ * remonta ao trocar de nome, ignora respostas atrasadas e limpa tudo no fim.
+ * Os adaptadores de host (Web Component, Svelte, Solid, Preact…) usam isto.
+ */
+declare function createSlot<P extends Props = Props>(target: HTMLElement, options: SlotOptions<P>): RemoteSlot<P>;
+
+export { type RemoteSlot as R, type SlotStatus as S, type SlotOptions as a, createSlot as c };

package/dist/solid.d.ts

@@ -1,6 +1,10 @@
-import { JSX, Component } from 'solid-js';
-import { Props, Isolation, RemoteError, RemoteModule } from './index.js';
-export { RemoteContext, events, navigate } from './index.js';
+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';
+export { n as navigate } from './navigate-BRG1WJUM.js';
+import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 
 /**
  * Adaptador Solid (e SolidStart).
@@ -12,13 +16,32 @@ export { RemoteContext, events, navigate } from './index.js';
 /** Transforma um componente Solid em um remote. O contexto chega na prop `vitral`. */
 declare function solidRemote<P extends Props>(Comp: Component<any>): RemoteModule<P>;
 interface RemoteProps<P extends Props = Props> {
-    name: string;
+    name?: string;
+    /** URL do `vitral.json`. Dispensa `configure()`. */
+    src?: string;
     props?: P;
     isolate?: Isolation;
     fallback?: JSX.Element;
     error?: (error: RemoteError, retry: () => void) => JSX.Element;
     class?: string;
+    /** `'lazy'`: monta perto de aparecer na tela; `'idle'`: com o navegador ocioso. */
+    loading?: Loading;
+    /** Baixa antes de montar: `'hover'`, `'visible'` ou `'idle'`. */
+    prefetch?: Prefetch;
+    /** `'high'` para o remote que aparece logo ao abrir a página. */
+    priority?: RequestPriority;
+    /** Ao sair da página, guarda o remote montado (LRU, padrão 5) e na volta só atualiza as props. */
+    keepAlive?: boolean | number;
 }
-declare function Remote<P extends Props = Props>(p: RemoteProps<P>): JSX.Element;
+declare function Remote<P extends Props = Props, N extends string = string>(p: RemoteProps<P> & CheckedProps<N>): JSX.Element;
+/**
+ * Accessor de uma chave compartilhada (`provide`/`shared`). Com seletor, só
+ * muda quando o resultado do seletor muda (`Object.is`). A assinatura acaba
+ * junto com o dono reativo (componente ou `createRoot`).
+ *
+ *   const nome = useShared('usuario', (u) => u?.nome)
+ */
+declare function useShared<K extends keyof Shared, S = Shared[K] | undefined>(key: K, select?: (value: Shared[K] | undefined) => S): Accessor<S>;
+declare function useShared<T = unknown, S = T | undefined>(key: string, select?: (value: T | undefined) => S): Accessor<S>;
 
-export { Remote, type RemoteProps, solidRemote };
+export { Remote, type RemoteProps, solidRemote, useShared };

package/dist/solid.js

@@ -1,12 +1,21 @@
 import {
-  createSlot,
+  hostSlot
+} from "./chunk-UTYAX6MU.js";
+import {
   defineRemote,
   events,
-  navigate
-} from "./chunk-TTL52BF2.js";
+  memoSelect,
+  navigate,
+  same,
+  shared
+} from "./chunk-NCONW6WS.js";
+import "./chunk-2XF5BKV3.js";
+import "./chunk-SFL6LTP3.js";
+import "./chunk-PX7PBCCT.js";
+import "./chunk-GNPFWISJ.js";
 
 // src/solid.ts
-import { createComponent, createEffect, createSignal, mergeProps, on, onCleanup, onMount } from "solid-js";
+import { createComponent, createEffect, createSignal, getOwner, mergeProps, on, onCleanup, onMount } from "solid-js";
 import { createStore, reconcile } from "solid-js/store";
 import { isServer, render } from "solid-js/web";
 function solidRemote(Comp) {
@@ -26,15 +35,20 @@ function Remote(p) {
   const [status, setStatus] = createSignal("loading");
   const [error, setError] = createSignal(null);
   const host = document.createElement("div");
-  host.setAttribute("data-vitral", p.name);
+  host.setAttribute("data-vitral", p.name ?? p.src ?? "");
   if (p.class) host.className = p.class;
   const target = document.createElement("div");
   let slot = null;
   onMount(() => {
-    slot = createSlot(target, {
+    slot = hostSlot(target, {
       name: p.name,
+      src: p.src,
       props: p.props ?? {},
       isolate: p.isolate,
+      loading: p.loading,
+      prefetch: p.prefetch,
+      priority: p.priority,
+      keepAlive: p.keepAlive,
       onStatus: (s, e) => {
         host.setAttribute("data-vitral-status", s);
         setError(() => e);
@@ -42,7 +56,7 @@ function Remote(p) {
       }
     });
   });
-  createEffect(on(() => [p.name, p.isolate], ([name, isolate]) => slot?.set({ name, isolate }), { defer: true }));
+  createEffect(on(() => [p.name, p.src, p.isolate], ([name, src, isolate]) => slot?.set({ name, src, isolate }), { defer: true }));
   createEffect(on(() => ({ ...p.props ?? {} }), (props) => slot?.update(props), { defer: true }));
   onCleanup(() => slot?.destroy());
   const retry = () => slot?.retry();
@@ -52,9 +66,18 @@ function Remote(p) {
     (host.appendChild(target), host)
   ];
 }
+function useShared(key, select = same) {
+  const handle = shared(key);
+  const pick = memoSelect();
+  const [value, setValue] = createSignal(pick(handle.get(), select), { equals: Object.is });
+  const off = handle.subscribe((v) => setValue(() => pick(v, select)));
+  if (getOwner()) onCleanup(off);
+  return value;
+}
 export {
   Remote,
   events,
   navigate,
-  solidRemote
+  solidRemote,
+  useShared
 };

package/dist/sri-BVKZNX5Q.js

@@ -0,0 +1,114 @@
+import {
+  verifyIntegrity
+} from "./chunk-S5MZT5IT.js";
+import {
+  RemoteError,
+  addLink,
+  fetchBytes,
+  withTimeout
+} from "./chunk-PX7PBCCT.js";
+import "./chunk-GNPFWISJ.js";
+
+// src/core/sri.ts
+var failed = /* @__PURE__ */ new Set();
+async function importVerified(name, r, run, timeout) {
+  const { entry, integrity, priority } = r;
+  if (!failed.has(entry)) {
+    try {
+      const go = async () => {
+        const url2 = await verified(r.split ?? { entry, chunks: [], sri: { [entry]: integrity }, priority }, run);
+        return url2 && { ns: await run(url2) };
+      };
+      const done = await withTimeout(timeout, name, go());
+      if (done) return done.ns;
+    } catch (e) {
+      failed.add(entry);
+      if (e instanceof RemoteError && e.code === "TIMEOUT") throw e;
+    }
+  }
+  const bytes = await fetchBytes(entry, timeout, name, failed.has(entry) ? { priority, cache: "reload" } : { priority });
+  await verifyIntegrity(name, bytes, integrity);
+  const url = URL.createObjectURL(new Blob([bytes], { type: "text/javascript" }));
+  try {
+    return await run(url);
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+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 preloads;
+var tick = () => new Promise((resolve) => {
+  const c = new MessageChannel();
+  c.port1.onmessage = () => resolve();
+  c.port2.postMessage(0);
+});
+async function verified(build, run) {
+  const { entry, chunks, sri, priority = "auto", dedupe = [] } = build;
+  const own = dedupe.flatMap((d) => [...d.chunks ?? [], d.file]);
+  if (![entry, ...chunks, ...own].every((u) => STRICT.test(sri[u] ?? ""))) return;
+  const p = globalThis[/* @__PURE__ */ Symbol.for("vitral")];
+  const share = async (pre) => {
+    if (!run || !dedupe.length) return;
+    const { shared } = await import("./dedupe-IWFIXRWG.js");
+    for (const d of dedupe)
+      shared(p)(d.name, d.range, {
+        version: d.version,
+        url: d.file,
+        load: async () => {
+          if (pre) await Promise.all([...d.chunks ?? [], d.file].map((u) => preload(u, sri[u], priority)));
+          return (await run(d.file)).default;
+        }
+      });
+  };
+  if (maps !== false && (maps = await addMap(sri))) {
+    await share();
+    for (const u of chunks) fetch(u, { priority }).catch(() => {
+    });
+    return entry;
+  }
+  if (await (preloads ??= checkPreloads())) {
+    p.sri = { ...p.sri, ...sri };
+    await share(true);
+    await Promise.all([...chunks, entry].map((u) => preload(u, sri[u], priority)));
+    return entry;
+  }
+}
+async function addMap(integrity) {
+  let ok = true;
+  try {
+    const s = document.createElement("script");
+    s.type = "importmap";
+    s.nonce = document.querySelector("script[nonce]")?.nonce ?? "";
+    s.onerror = () => ok = false;
+    s.addEventListener("securitypolicyviolation", () => ok = false);
+    s.textContent = JSON.stringify({ integrity });
+    document.head.append(s);
+  } catch {
+    return false;
+  }
+  await tick();
+  await tick();
+  return ok;
+}
+function preload(href, integrity, fetchPriority = "auto") {
+  return new Promise((resolve, reject) => {
+    const link = addLink("modulepreload", href, { integrity, fetchPriority });
+    link.onload = resolve;
+    link.onerror = reject;
+  });
+}
+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 Promise.race([
+    Promise.all([run(PROBE, true), run(PROBE + "//", false)]).then(([a, b]) => a && b),
+    new Promise((resolve) => setTimeout(resolve, 3e3, false))
+  ]);
+}
+export {
+  importVerified,
+  verified
+};

package/dist/state-BDdCwc21.d.ts

@@ -0,0 +1,4 @@
+/** Só para testes: apaga o protocolo global. */
+declare function resetProtocol(): void;
+
+export { resetProtocol as r };

package/dist/svelte.d.ts

@@ -1,22 +1,38 @@
 import { Component } from 'svelte';
-import { Props, Isolation, SlotStatus, RemoteError, RemoteModule } from './index.js';
-export { RemoteContext, events, navigate } from './index.js';
+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';
+export { n as navigate } from './navigate-BRG1WJUM.js';
+import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 
 /**
  * Adaptador Svelte 5 (e SvelteKit).
  *
  * Remote: export default svelteRemote(App)
  * Host:   <div use:remote={{ name: 'carrinho', props: { userId } }}></div>
+ *         <div use:remote={{ src: 'https://cdn.exemplo.com/carrinho/vitral.json' }}></div>
  *         ou o Web Component <vitral-remote> de 'vitral/element'.
  */
 
 /** Transforma um componente Svelte em um remote. O contexto chega na prop `vitral`. */
 declare function svelteRemote<P extends Props>(component: Component<any>): RemoteModule<P>;
 interface RemoteActionParams<P extends Props = Props> {
-    name: string;
+    name?: string;
+    /** URL do `vitral.json`. Dispensa `configure()`. */
+    src?: string;
     props?: P;
     isolate?: Isolation;
     onStatus?: (status: SlotStatus, error: RemoteError | null) => void;
+    /** `'lazy'`: monta perto de aparecer na tela; `'idle'`: com o navegador ocioso. */
+    loading?: Loading;
+    /** Baixa antes de montar: `'hover'`, `'visible'` ou `'idle'`. */
+    prefetch?: Prefetch;
+    /** `'high'` para o remote que aparece logo ao abrir a página. */
+    priority?: RequestPriority;
+    /** Ao sair da página, guarda o remote montado (LRU, padrão 5) e na volta só atualiza as props. */
+    keepAlive?: boolean | number;
 }
 /** Action Svelte: `<div use:remote={{ name, props }}>`. Funciona também em SvelteKit (só roda no cliente). */
 declare function remote<P extends Props = Props>(node: HTMLElement, params: RemoteActionParams<P>): {

package/dist/svelte.js

@@ -1,9 +1,15 @@
 import {
-  createSlot,
+  hostSlot
+} from "./chunk-UTYAX6MU.js";
+import {
   defineRemote,
   events,
   navigate
-} from "./chunk-TTL52BF2.js";
+} from "./chunk-NCONW6WS.js";
+import "./chunk-2XF5BKV3.js";
+import "./chunk-SFL6LTP3.js";
+import "./chunk-PX7PBCCT.js";
+import "./chunk-GNPFWISJ.js";
 
 // src/svelte.ts
 import { createClassComponent } from "svelte/legacy";
@@ -19,10 +25,10 @@ function svelteRemote(component) {
   });
 }
 function remote(node, params) {
-  const slot = createSlot(node, params);
+  const slot = hostSlot(node, params);
   return {
     update(next) {
-      slot.set({ name: next.name, isolate: next.isolate });
+      slot.set({ name: next.name, src: next.src, isolate: next.isolate });
       slot.update(next.props ?? {});
     },
     destroy: () => slot.destroy()

package/dist/testing.d.ts

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

package/dist/testing.js

@@ -1,7 +1,12 @@
+import "./chunk-NCONW6WS.js";
 import {
-  __reset,
   register
-} from "./chunk-TTL52BF2.js";
+} from "./chunk-2XF5BKV3.js";
+import "./chunk-SFL6LTP3.js";
+import "./chunk-PX7PBCCT.js";
+import {
+  resetProtocol
+} from "./chunk-GNPFWISJ.js";
 
 // src/testing.ts
 function mockRemote(name, render = (el) => {
@@ -43,5 +48,5 @@ function failingRemote(name, message = "falha simulada") {
 export {
   failingRemote,
   mockRemote,
-  __reset as resetVitral
+  resetProtocol as resetVitral
 };

package/dist/types-BV-hUrms.d.ts

@@ -0,0 +1,265 @@
+/**
+ * Tipos das chaves compartilhadas. Declare uma vez no projeto:
+ *
+ *   declare module 'vitral' {
+ *     interface Shared { usuario: { id: number; nome: string } | null; tema: 'claro' | 'escuro' }
+ *   }
+ */
+interface Shared {
+}
+/** Tipo do valor de `K`: o declarado em `Shared`, ou `unknown`. */
+type SharedType<K extends string> = K extends keyof Shared ? Shared[K] : unknown;
+/**
+ * Acesso a uma chave. Segue o contrato de store do Svelte (`$tema` funciona).
+ * O valor é tratado como imutável: para mudar, passe um valor novo.
+ */
+interface SharedValue<T> {
+    /** A chave. */
+    readonly key: string;
+    /** Valor atual, ou `undefined` se ninguém deu valor ainda. */
+    get(): T | undefined;
+    /** Troca o valor. Numa chave com `writable: false`, só o dono pode. */
+    set(value: T): void;
+    /** `set(fn(get()))`. */
+    update(fn: (value: T | undefined) => T): void;
+    /** Chama `fn` agora, com o valor atual, e a cada mudança. Devolve a função que cancela. */
+    subscribe(fn: (value: T | undefined) => void): () => void;
+}
+/** O que `provide` devolve. Quando é o dono, `set` sempre passa. */
+interface ProvidedValue<T> extends SharedValue<T> {
+    get(): T;
+    update(fn: (value: T) => T): void;
+    subscribe(fn: (value: T) => void): () => void;
+}
+interface ProvideOptions {
+    /** `false`: só quem chamou `provide` altera. Padrão `true`. */
+    writable?: boolean;
+}
+/** `shared`, com `provide` e `batch`. É também o tipo de `ctx.shared`. */
+interface SharedApi {
+    <K extends keyof Shared>(key: K): SharedValue<Shared[K]>;
+    <T = unknown>(key: string): SharedValue<T>;
+    /**
+     * Cria a chave e vira dono dela. Quem chama primeiro é o dono; depois disso,
+     * `provide` só devolve um acesso comum e não grava o valor.
+     */
+    provide<K extends keyof Shared>(key: K, value: Shared[K], options?: ProvideOptions): ProvidedValue<Shared[K]>;
+    provide<T>(key: string, value: T, options?: ProvideOptions): ProvidedValue<T>;
+    /** Várias mudanças, uma notificação por chave no fim. */
+    batch<R>(fn: () => R): R;
+}
+/** Acesso a uma chave compartilhada: `get()`, `set()`, `update()` e `subscribe()`. */
+declare function shared<K extends keyof Shared>(key: K): SharedValue<Shared[K]>;
+declare function shared<T = unknown>(key: string): SharedValue<T>;
+/**
+ * Cria uma chave compartilhada e vira dono dela. Quem chama primeiro é o
+ * dono; depois disso, `provide` só devolve um acesso comum e não grava o valor.
+ */
+declare function provide<K extends keyof Shared>(key: K, value: Shared[K], options?: ProvideOptions): ProvidedValue<Shared[K]>;
+declare function provide<T>(key: string, value: T, options?: ProvideOptions): ProvidedValue<T>;
+/** Várias mudanças, uma notificação por chave no fim. */
+declare function batch<R>(fn: () => R): R;
+
+type Props = Record<string, unknown>;
+/**
+ * Props de cada remote, por nome. `npx vitral types` gera um
+ * `vitral-env.d.ts` que preenche esta interface:
+ *
+ *   declare module 'vitral' { interface Remotes { carrinho: { userId: number } } }
+ */
+interface Remotes {
+}
+/** Props do remote `N`: as declaradas em `Remotes`, ou qualquer objeto. */
+type PropsOf<N extends string> = N extends keyof Remotes ? Remotes[N] : Props;
+/** Restrição extra nas props de um componente de host quando o nome está em `Remotes`. */
+type CheckedProps<N extends string> = N extends keyof Remotes ? {
+    name?: N;
+    props?: Remotes[N];
+} : {
+    name?: N;
+};
+interface RemoteContext {
+    /** Nome com que o host registrou este remote. */
+    name: string;
+    /** URL base de onde o remote foi carregado (útil para assets). */
+    baseUrl: string;
+    /**
+     * Barramento de eventos compartilhado entre host e todos os remotes. As
+     * assinaturas feitas por aqui são canceladas sozinhas no unmount.
+     */
+    events: EventBus;
+    /** Shadow root quando o host pediu isolamento, senão `null`. */
+    shadowRoot: ShadowRoot | null;
+    /** 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`. */
+    navigate(url: string, options?: {
+        replace?: boolean;
+    }): void;
+    /**
+     * Versão do protocolo entre cópias da lib que o host fala (hoje 1). Use
+     * para detectar recursos; hosts antigos não mandam este campo.
+     */
+    protocol?: number;
+    /**
+     * Com keep-alive: `fn` roda quando o remote volta para a página. Devolve a
+     * função que cancela. Hosts antigos não mandam este campo.
+     */
+    onActivate?(fn: () => void): () => void;
+    /** Com keep-alive: `fn` roda quando o remote sai da página sem desmontar (pause timers e assinaturas). */
+    onDeactivate?(fn: () => void): () => void;
+    /**
+     * O mesmo `shared` de `import { shared } from 'vitral'`, mas as assinaturas
+     * feitas por aqui são canceladas no unmount, e as chaves criadas com
+     * `ctx.shared.provide` perdem o dono. Vem quando o host usa o store
+     * (`provide`, `shared` ou um hook); senão, importe `shared` de 'vitral'.
+     */
+    shared?: SharedApi;
+}
+interface MountedRemote<P extends Props = Props> {
+    update?(props: P): void;
+    unmount(): void;
+}
+interface RemoteModule<P extends Props = Props> {
+    mount(el: HTMLElement, props: P, ctx: RemoteContext): MountedRemote<P> | Promise<MountedRemote<P>>;
+}
+interface RemoteEntry {
+    /** URL do módulo JS do remote, ou do `vitral.json` gerado pelo plugin. */
+    url?: string;
+    /**
+     * Remote local, sem rede: o próprio módulo ou uma função que o importa
+     * (ex.: `() => import('./carrinho')`). Útil em monorepos e testes.
+     */
+    module?: RemoteModule<any> | (() => Promise<RemoteModule<any> | {
+        default: RemoteModule<any>;
+    }>);
+    /** Hash SRI (`sha256-…`, `sha384-…`, `sha512-…`) do JS. Verificado antes de executar. */
+    integrity?: string;
+    /** CSS extra para carregar junto. */
+    css?: string[];
+    /** Isolamento padrão para este remote. */
+    isolate?: Isolation;
+    /**
+     * O `vitral.json` já baixado (ex.: por `vitral registry`), para não buscá-lo
+     * na hora. Os caminhos dele são relativos a `url`, e os hashes ficam fixos
+     * no host.
+     */
+    manifest?: RemoteManifest;
+}
+/**
+ * `none`: CSS com escopo. `shadow`: Shadow DOM. `iframe`: iframe com
+ * `sandbox`, para código de terceiros (precisa de `enableIframe()`).
+ */
+type Isolation = 'shadow' | 'none' | 'iframe';
+/** Estilos do host dentro do Shadow DOM. Sem efeito no modo escopo. */
+interface StyleOptions {
+    /**
+     * CSS do host adotado em cada shadow root antes do CSS do remote (ex.:
+     * `['/assets/base.css']`). Um `CSSStyleSheet` por arquivo, o mesmo em todos.
+     */
+    inherit?: string[];
+    /**
+     * Copia `class` e `data-theme` do `<html>` para a raiz do remote, para
+     * `dark:` e `[data-theme]` funcionarem no Shadow DOM. Padrão `true`.
+     */
+    mirrorTheme?: boolean;
+}
+interface VitralConfig {
+    /** Mapa nome → URL (ou entrada completa), ou a URL de um JSON com esse mapa. */
+    remotes?: Record<string, string | RemoteEntry> | string;
+    /**
+     * Origens de onde é permitido carregar código. Padrão: a própria origem da
+     * página mais as origens das URLs registradas. Use `['*']` para liberar tudo.
+     */
+    allowedOrigins?: string[];
+    /** Tempo máximo para baixar um remote, em ms. Padrão 15000. */
+    timeout?: number;
+    /** Tentativas extras se o download falhar. Padrão 1. */
+    retries?: number;
+    /** Isolamento padrão para todos os remotes. Padrão `'none'`. */
+    isolate?: Isolation;
+    /**
+     * 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.
+     */
+    devOverrides?: boolean;
+    /** 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;
+    /**
+     * Dependências que o host oferece aos remotes com `dedupe`, por grupo:
+     * `{ vue: { version: Vue.version, modules: { vue: Vue } } }`. O remote usa
+     * a do host se a versão estiver na faixa dele; senão, a própria cópia.
+     */
+    dedupe?: Record<string, {
+        version: string;
+        modules: SharedModules;
+    }>;
+}
+/** Módulos de um grupo de `dedupe`, por especificador (`'react-dom/client'`). */
+type SharedModules = Record<string, unknown>;
+/**
+ * Tempo de uma etapa do carregamento de um remote. Cada etapa também vira
+ * `performance.measure('vitral:<nome>:<etapa>')`, visível no painel
+ * Performance do DevTools.
+ */
+interface RemoteMetric {
+    name: string;
+    stage: 'manifest' | 'js' | 'css' | 'mount';
+    /** Início, em ms desde `performance.timeOrigin`. */
+    start: number;
+    duration: number;
+}
+/** Formato do `vitral.json` emitido pelo plugin de build. */
+interface RemoteManifest {
+    name: string;
+    version?: string;
+    entry: string;
+    css?: string[];
+    integrity?: string;
+    /** Escopo usado pelo plugin para prefixar o CSS (`[data-vitral-scope]`). */
+    scope?: string;
+    /**
+     * Componentes e módulos extras do remote (`./MiniCarrinho`, `./api`). Vêm
+     * do mesmo `entry`, no export `exposes`. O host usa `carrinho/MiniCarrinho`.
+     */
+    exposes?: string[];
+    /**
+     * Hash SRI de cada arquivo publicado (CSS e JS do build dividido), pelo
+     * caminho relativo ao manifesto.
+     */
+    files?: Record<string, string>;
+    /**
+     * Build dividido, para navegadores que conferem o hash de cada módulo:
+     * a entrada e os chunks que ela importa logo. `entry` e `integrity`
+     * continuam apontando para o arquivo único, usado por hosts antigos e
+     * quando o navegador não confere o hash por módulo.
+     */
+    split?: {
+        entry: string;
+        chunks?: string[];
+    };
+    /**
+     * Dependências de `dedupe` do build dividido: faixa aceita, versão da
+     * cópia própria e o arquivo dela, para o loader baixar junto com a entrada.
+     */
+    dedupe?: {
+        name: string;
+        range: string;
+        version: string;
+        file: string;
+        chunks?: string[];
+    }[];
+}
+type Handler<T = unknown> = (payload: T) => void;
+interface EventBus {
+    emit<T = unknown>(type: string, payload?: T): void;
+    on<T = unknown>(type: string, handler: Handler<T>): () => void;
+    /** Último valor emitido em `type` (útil para estado como "usuário logado"). */
+    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 };