vitral 0.1.0 → 0.2.0

package/dist/iframe.js

@@ -0,0 +1,236 @@
+import {
+  splitName
+} from "./chunk-HP6QWU6K.js";
+import {
+  verifyIntegrity
+} from "./chunk-S5MZT5IT.js";
+import {
+  events,
+  navigate,
+  setFrameMounter,
+  track
+} from "./chunk-NCONW6WS.js";
+import {
+  resolveEntry
+} from "./chunk-2XF5BKV3.js";
+import "./chunk-SFL6LTP3.js";
+import {
+  RemoteError,
+  fetchBytes,
+  withRetry,
+  withTimeout
+} from "./chunk-PX7PBCCT.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/iframe-frame.ts
+var FRAME_RUNTIME = `function (w, load) {
+  var parent = w.parent, doc = w.document, handlers = {}, last = {}, channel = {}, mounted = null, stage = 'LOAD_FAILED'
+  function post(type, data) { parent.postMessage({ vitral: 1, type: type, data: data }, '*') }
+  function call(fn, arg) { try { fn(arg) } catch (e) { w.console.error(e) } }
+  var events = {
+    emit: function (type, payload) { post('emit', { type: type, payload: payload }) },
+    on: function (type, fn) {
+      if (!handlers[type]) { handlers[type] = []; post('on', { type: type }) }
+      handlers[type].push(fn)
+      return function () { handlers[type] = handlers[type].filter(function (h) { return h !== fn }) }
+    },
+    last: function (type) { return last[type] }
+  }
+  function start(d) {
+    var root = doc.createElement('div')
+    root.setAttribute('data-vitral-root', d.name)
+    if (d.scope) root.setAttribute('data-vitral-scope', d.scope)
+    doc.body.appendChild(root)
+    // Ponto de extens\xE3o: uma ponte nova registra handlers em channel[tipo] e
+    // acrescenta campos aqui (a Fase 2 acrescenta ctx.shared).
+    var ctx = {
+      name: d.name, baseUrl: d.baseUrl, events: events, shadowRoot: null, protocol: 1,
+      reportError: function (e) { post('report', { message: String((e && e.message) || e) }) },
+      navigate: function (url, o) { post('navigate', { url: String(url), replace: !!(o && o.replace) }) }
+    }
+    Promise.all(d.css.map(function (href) {
+      return new Promise(function (done) {
+        var link = doc.createElement('link')
+        link.rel = 'stylesheet'; link.href = href; link.crossOrigin = 'anonymous'
+        link.onload = link.onerror = done
+        doc.head.appendChild(link)
+      })
+    })).then(function () {
+      return load(d.code ? w.URL.createObjectURL(new w.Blob([d.code], { type: 'text/javascript' })) : d.url)
+    }).then(function (ns) {
+      if (!d.key) return ns
+      var table = ns.exposes, part = table && table[d.key]
+      if (!part) { stage = 'NOT_EXPOSED'; throw new Error(d.name + ' n\xE3o exp\xF5e ' + d.key) }
+      return typeof part === 'function' ? part() : part
+    }).then(function (ns) {
+      var mod = (ns && ns.default) || ns
+      if (!mod || typeof mod.mount !== 'function') { stage = 'INVALID_MODULE'; throw new Error('o m\xF3dulo n\xE3o exporta mount()') }
+      stage = 'MOUNT_FAILED'
+      return mod.mount(root, d.props, ctx)
+    }).then(function (handle) {
+      mounted = handle
+      post('mounted')
+      var size = function () { post('size', { height: Math.ceil(doc.body.getBoundingClientRect().height) }) }
+      size()
+      if (w.ResizeObserver) new w.ResizeObserver(size).observe(doc.body)
+    }, function (e) {
+      post('error', { code: stage, message: String((e && e.message) || e) })
+    })
+  }
+  w.addEventListener('message', function (e) {
+    var m = e.data
+    if (e.source !== parent || !m || m.vitral !== 1) return
+    var d = m.data
+    if (m.type === 'mount') start(d)
+    else if (m.type === 'update') { if (mounted && mounted.update) mounted.update(d) }
+    else if (m.type === 'unmount') { if (mounted) mounted.unmount(); mounted = null }
+    else if (m.type === 'last') last[d.type] = d.payload
+    else if (m.type === 'event') {
+      last[d.type] = d.payload
+      ;(handlers[d.type] || []).slice().forEach(function (h) { call(h, d.payload) })
+    } else (channel[m.type] || []).forEach(function (h) { call(h, d) })
+  })
+  post('ready')
+}`;
+var FRAME_SCRIPT = `(${FRAME_RUNTIME})(window, function (u) { return import(u) })`;
+var FRAME_HTML = `<!doctype html><html><head><meta charset="utf-8"><style>html,body{margin:0}body{display:flow-root}</style></head><body><script>${FRAME_SCRIPT}</script></body></html>`;
+
+// src/iframe.ts
+var CODES = ["LOAD_FAILED", "NOT_EXPOSED", "INVALID_MODULE", "MOUNT_FAILED"];
+function enableIframe(options = {}) {
+  const sandbox = options.sandbox ?? "allow-scripts";
+  if (/\ballow-same-origin\b/.test(sandbox) && /\ballow-scripts\b/.test(sandbox)) {
+    console.warn("[vitral] sandbox com allow-scripts e allow-same-origin n\xE3o isola o remote da p\xE1gina.");
+  }
+  setFrameMounter((target, name, props, mountOptions) => mountFrame(target, name, props, mountOptions, sandbox, options.bridges ?? []));
+}
+async function mountFrame(target, name, props, options, sandbox, bridges) {
+  const p = protocol();
+  const { timeout, retries } = p.settings();
+  const [remote, key] = splitName(name);
+  const entry = p.entry(remote);
+  if (!entry) throw new RemoteError("NOT_REGISTERED", name, "remote n\xE3o registrado. Use configure({ remotes }).");
+  if (!entry.url) throw new RemoteError("MOUNT_FAILED", name, "remote local (module) n\xE3o roda em iframe: registre a URL dele");
+  const { integrity, ...resolved } = await resolveEntry(remote, entry);
+  const code = integrity ? await withRetry(retries, async () => {
+    const bytes = await fetchBytes(resolved.entry, timeout, name);
+    await verifyIntegrity(name, bytes, integrity);
+    return bytes;
+  }) : void 0;
+  track(name, resolved.entry);
+  const baseUrl = /^https?:/.test(resolved.entry) ? new URL(".", resolved.entry).href : resolved.entry;
+  const frame = document.createElement("iframe");
+  frame.setAttribute("sandbox", sandbox);
+  frame.setAttribute("data-vitral-root", name);
+  frame.title = name;
+  frame.style.cssText = "display:block;width:100%;height:0;border:0";
+  frame.srcdoc = FRAME_HTML;
+  let warned = false;
+  const post = (type, data) => {
+    const win = frame.contentWindow;
+    if (!win) return;
+    try {
+      win.postMessage({ vitral: 1, type, data }, "*");
+    } catch {
+      if (!warned) console.warn(`[vitral] ${name}: props e eventos no modo iframe precisam ser serializ\xE1veis; o que n\xE3o \xE9 foi descartado.`);
+      warned = true;
+      win.postMessage({ vitral: 1, type, data: JSON.parse(JSON.stringify(data ?? null)) }, "*");
+    }
+  };
+  const subs = /* @__PURE__ */ new Map();
+  const channel = /* @__PURE__ */ new Map();
+  const port = {
+    post,
+    on(type, handler) {
+      if (!channel.has(type)) channel.set(type, /* @__PURE__ */ new Set());
+      channel.get(type).add(handler);
+      return () => channel.get(type)?.delete(handler);
+    }
+  };
+  let settle = null;
+  const ready = new Promise((ok, fail) => settle = { ok, fail });
+  const onMessage = (e) => {
+    const m = e.data;
+    if (e.source !== frame.contentWindow || !m || m.vitral !== 1) return;
+    const d = m.data;
+    switch (m.type) {
+      case "ready":
+        if (settle) post("mount", { name, key, code, url: resolved.entry, css: resolved.css, scope: resolved.scope, baseUrl, props });
+        break;
+      case "mounted":
+        settle?.ok();
+        settle = null;
+        break;
+      case "error":
+        settle?.fail(new RemoteError(CODES.includes(d?.code) ? d.code : "MOUNT_FAILED", name, String(d?.message)));
+        settle = null;
+        break;
+      case "size":
+        frame.style.height = `${Math.max(0, Number(d?.height) || 0)}px`;
+        break;
+      case "emit":
+        events.emit(String(d?.type), d?.payload);
+        break;
+      case "on": {
+        const type = String(d?.type);
+        if (subs.has(type)) break;
+        subs.set(type, events.on(type, (payload) => post("event", { type, payload })));
+        const value = events.last(type);
+        if (value !== void 0) post("last", { type, payload: value });
+        break;
+      }
+      case "navigate": {
+        const url = new URL(String(d?.url), location.href);
+        if (url.origin === location.origin) navigate(url.href, { replace: !!d?.replace });
+        else console.warn(`[vitral] ${name}: navega\xE7\xE3o para outra origem bloqueada (${url.origin})`);
+        break;
+      }
+      case "report": {
+        const err = new RemoteError("RENDER_FAILED", name, String(d?.message));
+        if (options.onError) options.onError(err);
+        else console.error(err);
+        break;
+      }
+      default:
+        for (const h of [...channel.get(m.type) ?? []]) h(d);
+    }
+  };
+  const disposers = [];
+  const cleanup = () => {
+    removeEventListener("message", onMessage);
+    for (const off of subs.values()) off();
+    for (const off of disposers) off();
+    subs.clear();
+    frame.remove();
+  };
+  addEventListener("message", onMessage);
+  for (const bridge of bridges) {
+    const off = bridge(port, { name });
+    if (off) disposers.push(off);
+  }
+  target.appendChild(frame);
+  try {
+    await withTimeout(timeout, name, ready);
+  } catch (e) {
+    cleanup();
+    throw e;
+  }
+  let alive = true;
+  return {
+    update(next) {
+      if (alive) post("update", next);
+    },
+    unmount() {
+      if (!alive) return;
+      alive = false;
+      post("unmount");
+      cleanup();
+    }
+  };
+}
+export {
+  FRAME_SCRIPT,
+  enableIframe
+};

package/dist/index.d.ts

@@ -1,17 +1,117 @@
+import { V as VitralConfig, c as RemoteEntry, P as Props, a as RemoteModule, I as Isolation, b as StyleOptions, M as MountedRemote, E as EventBus, R as RemoteContext, d as SharedValue } from './types-BV-hUrms.js';
+export { C as CheckedProps, H as Handler, e as PropsOf, f as ProvideOptions, g as ProvidedValue, h as RemoteManifest, i as RemoteMetric, j as Remotes, S as Shared, k as SharedApi, l as SharedModules, m as SharedType, n as batch, p as provide, s as shared } from './types-BV-hUrms.js';
+import { R as RemoteError } from './errors-KKB8FGCz.js';
+export { a as RemoteErrorCode } from './errors-KKB8FGCz.js';
+export { R as RemoteSlot, a as SlotOptions, S as SlotStatus, c as createSlot } from './slot-pB276oPt.js';
+export { e as events } from './events-DUdjhfps.js';
+export { n as navigate } from './navigate-BRG1WJUM.js';
+export { r as __reset } from './state-BDdCwc21.js';
+
+/** Configura a lib. Pode ser chamada mais de uma vez; as opções são mescladas. */
+declare function configure(config: VitralConfig): void;
+/** Registra (ou substitui) um remote. */
+declare function register(name: string, entry: string | RemoteEntry): void;
+/**
+ * Registra a URL de um `src` e devolve o nome para montar. Sem `name`, o nome
+ * é a própria URL (e o nome do manifesto vira um apelido). Com `trusted`, a
+ * origem entra na allowlist mesmo com `allowedOrigins`: vale para URL escrita
+ * no código do host, nunca para URL vinda de dados.
+ */
+declare function registerSrc(src: string, name?: string, trusted?: boolean): string;
+
+/** Uma chave do store vista de fora (devtools, SSR, ponte do iframe). */
+interface SharedEntry {
+    key: string;
+    value: unknown;
+    /** `false` quando só o dono altera. */
+    writable: boolean;
+    /** Quem é o dono (nome do remote; vazio para o host ou sem nome). */
+    owner?: string;
+    /** Quem fez a última mudança. */
+    by?: string;
+    /** Quantas assinaturas ativas a chave tem. */
+    subscribers: number;
+}
+/**
+ * Store guardado no protocolo global (`globalThis[Symbol.for('vitral')].shared()`).
+ * Faz parte do protocolo v1: só cresce com métodos novos.
+ */
+interface SharedStore {
+    /** Valor atual; `undefined` se a chave ainda não tem valor. */
+    get(key: string): unknown;
+    /**
+     * Troca o valor. Passa se `token` é o do dono ou se a chave aceita escrita.
+     * Devolve `false` quando a escrita foi bloqueada (`writable: false`).
+     */
+    set(key: string, value: unknown, token?: object, by?: string): boolean;
+    /** Chama `fn(valor)` a cada mudança (não na hora). Devolve a função que cancela. */
+    subscribe(key: string, fn: (value: unknown) => void): () => void;
+    /**
+     * Torna-se dono de uma chave sem dono e grava `value` (um valor vindo do
+     * SSR ainda não reivindicado é mantido). Devolve o token do dono, ou
+     * `undefined` se a chave já tem dono.
+     */
+    own(key: string, value: unknown, writable: boolean, by?: string): object | undefined;
+    /** O dono larga a chave. O valor fica e a chave volta a aceitar escrita. */
+    release(key: string, token: object): void;
+    /** Roda `fn` e notifica cada chave alterada uma vez só, no fim. */
+    batch<R>(fn: () => R): R;
+    /** Chaves com valor e seus metadados. */
+    list(): SharedEntry[];
+}
+
+/** Baixa (uma vez só) e devolve o módulo de um remote. */
+declare function loadRemote<P extends Props = Props>(name: string): Promise<RemoteModule<P>>;
 /**
- * Remote em JS/TS puro sem escrever mount/update/unmount na mão.
+ * Carrega um módulo sem UI que um remote expõe (funções, stores, constantes),
+ * com a mesma verificação de SRI e de origem dos componentes.
  *
- *   export default component<{ mensagem?: string }>({
- *     state: { cliques: 0 },
- *     render: ({ mensagem }, state, ctx) => html`
- *       <p>${mensagem}</p>
- *       <button onclick=${() => state.cliques++}>ping ${state.cliques}</button>
- *     `,
- *   })
+ *   const api = await loadModule<typeof import('./tipos/carrinho-api')>('carrinho/api')
  *
- * Valores interpolados são escapados (sem XSS). Mudar `state` ou receber
- * props novas renderiza de novo. Funções em `on<evento>=${fn}` viram listeners.
+ * Sem `/`, devolve os exports do arquivo principal do remote.
+ */
+declare function loadModule<T = Record<string, unknown>>(name: string): Promise<T>;
+/** Começa a baixar um remote (JS e CSS) sem montar (ex.: no hover de um link). */
+declare function preload(name: string): void;
+
+interface MountOptions {
+    isolate?: Isolation;
+    /** `'high'` para o remote que aparece logo ao abrir a página: vira `fetchpriority` nos downloads. */
+    priority?: RequestPriority;
+    /** Estilos do host no Shadow DOM (somados aos do `configure`). */
+    styles?: StyleOptions;
+    /** Chamado quando o remote quebra depois de montado (erro de render, handler etc.). */
+    onError?: (error: RemoteError) => void;
+}
+/**
+ * Monta um remote dentro de `target`. Devolve um handle com `update` e
+ * `unmount` que funciona igual para qualquer framework. Com `refresh(nome)`,
+ * o mesmo handle passa a apontar para a versão nova.
+ */
+declare function mountRemote<P extends Props = Props>(target: HTMLElement, name: string, props: P, options?: MountOptions): Promise<MountedRemote<P>>;
+
+/** Declara um remote. É só uma função identidade com tipos. */
+declare function defineRemote<P extends Props = Props>(remote: RemoteModule<P>): RemoteModule<P>;
+
+declare function createEventBus(): EventBus;
+
+/**
+ * Troca as montagens de `name` (e das partes, `name/…`) pela versão que o
+ * manifesto aponta agora, sem recarregar a página. Rejeita se a versão nova
+ * não carregar; nesse caso nada muda na tela.
+ */
+declare function refresh(name: string): Promise<void>;
+/**
+ * Revalida os manifestos dos remotes montados e emite
+ * `vitral:update-available` com `{ name, entry }` para cada deploy novo.
+ * Devolve os nomes com versão nova. Falhas de rede são ignoradas.
  */
+declare function checkUpdates(): Promise<string[]>;
+/**
+ * Revalida os manifestos a cada navegação (`popstate`, que `navigate()` também
+ * dispara, e a Navigation API onde existe). Devolve a função que desliga.
+ */
+declare function watchUpdates(): () => void;
 
 declare const TEMPLATE: unique symbol;
 interface Template {
@@ -41,151 +141,46 @@ interface ComponentOptions<P extends Props, S extends object> {
 declare function component<P extends Props = Props, S extends object = Record<string, never>>(options: RenderFn<P, S> | ComponentOptions<P, S>): RemoteModule<P>;
 
 /**
- * vitral: micro-frontends com um único contrato.
- *
- * Um remote é um módulo ES que exporta `mount(el, props, ctx)` e devolve
- * `{ update?, unmount }`. O host só precisa saber a URL. Nada de config
- * compartilhada em tempo de build, nada de container global de dependências.
+ * Extras opcionais do contexto compartilhado: guardar no storage, espelhar
+ * entre abas e levar os valores do SSR para o cliente. Ficam fora do store
+ * para só entrar no bundle de quem usa.
  */
-type Props = Record<string, unknown>;
-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;
-}
-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;
-}
-type Isolation = 'shadow' | 'none';
-interface VitralConfig {
-    /** Mapa nome → URL (ou entrada completa), ou a URL de um JSON com esse mapa. */
-    remotes?: Record<string, string | RemoteEntry> | string;
+
+interface PersistOptions {
+    /** `'local'` (padrão) ou `'session'`. */
+    storage?: 'local' | 'session';
     /**
-     * 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.
+     * Versão do formato do valor. Faz parte da chave do storage
+     * (`vitral:<chave>:<versão>`): ao mudar o formato, suba a versão e o valor
+     * antigo é ignorado. Padrão `1`.
      */
-    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;
-}
-type RemoteErrorCode = 'NOT_REGISTERED' | 'ORIGIN_BLOCKED' | 'TIMEOUT' | 'INTEGRITY' | 'INVALID_MODULE' | 'LOAD_FAILED' | 'MOUNT_FAILED' | 'RENDER_FAILED';
-declare class RemoteError extends Error {
-    code: RemoteErrorCode;
-    remote: string;
-    cause?: unknown | undefined;
-    constructor(code: RemoteErrorCode, remote: string, message: string, cause?: unknown | undefined);
-}
-/** 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;
-}
-/** Configura a lib. Pode ser chamada mais de uma vez; as opções são mescladas. */
-declare function configure(config: VitralConfig): void;
-/** Registra (ou substitui) um remote. */
-declare function register(name: string, entry: string | RemoteEntry): void;
-/** Baixa (uma vez só) e devolve o módulo de um remote. */
-declare function loadRemote<P extends Props = Props>(name: string): Promise<RemoteModule<P>>;
-/** Começa a baixar um remote sem montar (ex.: no hover de um link). */
-declare function preload(name: string): void;
-interface MountOptions {
-    isolate?: Isolation;
-    /** Chamado quando o remote quebra depois de montado (erro de render, handler etc.). */
-    onError?: (error: RemoteError) => void;
+    version?: string | number;
 }
 /**
- * Monta um remote dentro de `target`. Devolve um handle com `update` e
- * `unmount` que funciona igual para qualquer framework.
+ * Restaura o valor guardado (se houver) e guarda cada mudança. Valores que
+ * não viram JSON (funções, por exemplo) não são guardados. Sem storage
+ * (servidor, modo privado bloqueado), não faz nada.
+ *
+ *   const carrinho = persist(provide('carrinho', []), { version: 2 })
  */
-declare function mountRemote<P extends Props = Props>(target: HTMLElement, name: string, props: P, options?: MountOptions): Promise<MountedRemote<P>>;
-type SlotStatus = 'loading' | 'ready' | 'error';
-interface SlotOptions<P extends Props = Props> {
-    name: string;
-    props?: P;
-    isolate?: Isolation;
-    /** 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' | 'isolate'>>): void;
-    /** Remonta do zero (botão "tentar de novo"). */
-    retry(): void;
-    destroy(): void;
-    readonly status: SlotStatus;
-}
+declare function persist<V extends SharedValue<any>>(value: V, options?: PersistOptions): V;
 /**
- * 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.
+ * Espelha as mudanças entre abas da mesma origem (`BroadcastChannel`). Chame
+ * nas duas abas, de preferência no dono da chave: assim a mudança que chega
+ * passa mesmo com `writable: false`. Só dados que o `structuredClone` aceita
+ * atravessam. Junto com `persist`, uma aba nova começa com o último valor.
+ *
+ *   const carrinho = syncTabs(persist(provide('carrinho', [])))
  */
-declare function createSlot<P extends Props = Props>(target: HTMLElement, options: SlotOptions<P>): RemoteSlot<P>;
-/** Declara um remote. É só uma função identidade com tipos. */
-declare function defineRemote<P extends Props = Props>(remote: RemoteModule<P>): RemoteModule<P>;
-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;
-}
-declare function createEventBus(): EventBus;
-/** Barramento global. É o mesmo objeto que os remotes recebem em `ctx.events`. */
-declare const events: EventBus;
+declare function syncTabs<V extends SharedValue<any>>(value: V): V;
 /**
- * Navega mantendo todos os roteadores em sincronia (React Router, Vue Router,
- * Next, Nuxt…): atualiza o histórico e dispara `popstate`, que todos escutam.
+ * SSR: transforma os valores de uma requisição no conteúdo do
+ * `<script type="application/json" data-vitral-shared>`, que o store do
+ * cliente lê antes dos remotes montarem. Funções e `undefined` ficam de fora;
+ * `<` é escapado para o JSON não fechar o `<script>`.
+ *
+ *   `<script type="application/json" data-vitral-shared>${serializeShared({ usuario })}</script>`
  */
-declare function navigate(url: string, options?: {
-    replace?: boolean;
-}): void;
-/** Só para testes: limpa todo o estado global. */
-declare function __reset(): void;
+declare function serializeShared(values: Record<string, unknown>): string;
 
-export { type ComponentOptions, type EventBus, type Handler, type Isolation, type MountOptions, type MountedRemote, type Props, type RemoteContext, type RemoteEntry, RemoteError, type RemoteErrorCode, type RemoteManifest, type RemoteModule, type RemoteSlot, type RenderFn, type SlotOptions, type SlotStatus, type Template, type View, type VitralConfig, __reset, component, configure, createEventBus, createSlot, defineRemote, events, html, loadRemote, mountRemote, navigate, preload, register, render, unsafeHTML };
+export { type ComponentOptions, EventBus, Isolation, type MountOptions, MountedRemote, type PersistOptions, Props, RemoteContext, RemoteEntry, RemoteError, RemoteModule, type RenderFn, type SharedEntry, type SharedStore, SharedValue, StyleOptions, type Template, type View, VitralConfig, checkUpdates, component, configure, createEventBus, defineRemote, html, loadModule, loadRemote, mountRemote, persist, preload, refresh, register, registerSrc, render, serializeShared, syncTabs, unsafeHTML, watchUpdates };

package/dist/index.js

@@ -1,24 +1,44 @@
 import {
-  RemoteError,
-  __reset,
+  batch,
+  checkUpdates,
   component,
-  configure,
-  createEventBus,
   createSlot,
   defineRemote,
   events,
   html,
-  loadRemote,
   mountRemote,
   navigate,
+  persist,
+  provide,
+  refresh,
+  render,
+  serializeShared,
+  shared,
+  syncTabs,
+  unsafeHTML,
+  watchUpdates
+} from "./chunk-NCONW6WS.js";
+import {
+  configure,
+  loadModule,
+  loadRemote,
   preload,
   register,
-  render,
-  unsafeHTML
-} from "./chunk-TTL52BF2.js";
+  registerSrc
+} from "./chunk-2XF5BKV3.js";
+import "./chunk-SFL6LTP3.js";
+import {
+  RemoteError
+} from "./chunk-PX7PBCCT.js";
+import {
+  createEventBus,
+  resetProtocol
+} from "./chunk-GNPFWISJ.js";
 export {
   RemoteError,
-  __reset,
+  resetProtocol as __reset,
+  batch,
+  checkUpdates,
   component,
   configure,
   createEventBus,
@@ -26,11 +46,20 @@ export {
   defineRemote,
   events,
   html,
+  loadModule,
   loadRemote,
   mountRemote,
   navigate,
+  persist,
   preload,
+  provide,
+  refresh,
   register,
+  registerSrc,
   render,
-  unsafeHTML
+  serializeShared,
+  shared,
+  syncTabs,
+  unsafeHTML,
+  watchUpdates
 };

package/dist/navigate-BRG1WJUM.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Navega mantendo todos os roteadores em sincronia (React Router, Vue Router,
+ * Next, Nuxt…): atualiza o histórico e dispara `popstate`, que todos escutam.
+ */
+declare function navigate(url: string, options?: {
+    replace?: boolean;
+}): void;
+
+export { navigate as n };

package/dist/overrides-NZAIUGK5.js

@@ -0,0 +1,15 @@
+import {
+  OVERRIDES_KEY,
+  manifestUrl,
+  overrideFor,
+  overridesEnabled,
+  storedOverrides
+} from "./chunk-DXORSF4X.js";
+import "./chunk-GNPFWISJ.js";
+export {
+  OVERRIDES_KEY,
+  manifestUrl,
+  overrideFor,
+  overridesEnabled,
+  storedOverrides
+};