vitral 0.4.0 → 0.6.0

package/dist/routes.js

@@ -1,9 +1,14 @@
+import {
+  matchRoute
+} from "./chunk-OVVGVPIV.js";
 import {
   createSlot,
   navigate
-} from "./chunk-WD4CDGDZ.js";
-import "./chunk-EMSB2NVX.js";
-import "./chunk-6EX5KYT5.js";
+} from "./chunk-HIVMSPGM.js";
+import {
+  warmSsr
+} from "./chunk-S7PIVPBX.js";
+import "./chunk-KU6HF2EW.js";
 import "./chunk-TW7KYJQ6.js";
 import "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";
@@ -11,21 +16,8 @@ import "./chunk-GNPFWISJ.js";
 // src/routes.ts
 var table = {};
 var outlets = /* @__PURE__ */ new Set();
-var compiled = /* @__PURE__ */ new Map();
-function compile(pattern) {
-  let re = compiled.get(pattern);
-  if (!re) {
-    const body = pattern.replace(/\/\*$|^\*$/, "\0").replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/:(\w+)/g, "(?<$1>[^/]+)").replace(/\/$/, "").replace("\0", "(?:/.*)?");
-    compiled.set(pattern, re = new RegExp(`^${body}/?$`));
-  }
-  return re;
-}
-function matchRoute(path, routes2 = table) {
-  for (const [pattern, name] of Object.entries(routes2)) {
-    const m = compile(pattern).exec(path);
-    if (m) return { name, pattern, params: { ...m.groups } };
-  }
-  return null;
+function matchRoute2(path, routes2 = table) {
+  return matchRoute(path, routes2);
 }
 function routes(map, options = {}) {
   table = map;
@@ -44,7 +36,7 @@ function onClick(e) {
   const a = e.composedPath().find((n) => n.localName === "a" && !!n.href);
   if (!a || a.target && a.target !== "_self" || a.hasAttribute("download")) return;
   const url = new URL(a.href);
-  if (url.origin !== location.origin || !matchRoute(url.pathname)) return;
+  if (url.origin !== location.origin || !matchRoute2(url.pathname)) return;
   e.preventDefault();
   navigate(url.href);
 }
@@ -99,7 +91,7 @@ var VitralOutletElement = class extends Base {
   }
   /** Confere a URL atual e troca de remote se a rota mudou. */
   sync() {
-    if (this.isConnected) this.#show(matchRoute(location.pathname)?.name ?? null);
+    if (this.isConnected) this.#show(matchRoute2(location.pathname)?.name ?? null);
   }
   #show(name) {
     if (name === this.#route) return;
@@ -113,12 +105,24 @@ var VitralOutletElement = class extends Base {
     } else if (this.#slot) {
       this.#slot.set({ name });
     } else {
-      this.#slot = createSlot(this, {
+      const options = {
         name,
         props: this.#props,
         isolate: this.getAttribute("isolate") || void 0,
         onStatus: (s, e) => this.#status(s, e)
-      });
+      };
+      const ssr = this.querySelector(":scope>[data-vitral-ssr]");
+      if (ssr?.getAttribute("data-vitral-slot") === name) {
+        this.#status("loading", null);
+        warmSsr(ssr);
+        import("./hydrate-R76V2I36.js").then((m) => {
+          if (this.#route === name && !this.#slot) this.#slot = m.hydrateSlot(this, ssr, { ...options, props: this.#props });
+          else ssr.remove();
+        });
+        return;
+      }
+      ssr?.remove();
+      this.#slot = createSlot(this, options);
     }
   }
   #status(status, error) {
@@ -139,6 +143,6 @@ function defineVitralOutlet(tag = "vitral-outlet") {
 export {
   VitralOutletElement,
   defineVitralOutlet,
-  matchRoute,
+  matchRoute2 as matchRoute,
   routes
 };

package/dist/{shadow-PVSETNMZ.js → shadow-S4SKHTA7.js}

@@ -1,7 +1,7 @@
 import {
   fetchCssText,
   injectCss
-} from "./chunk-6EX5KYT5.js";
+} from "./chunk-KU6HF2EW.js";
 import "./chunk-TW7KYJQ6.js";
 import "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";
@@ -43,7 +43,7 @@ async function attachShadowRoot(target, make, r, global = {}, local = {}) {
       el = make({ customElementRegistry: own });
     } catch {
     }
-  root.appendChild(el);
+  if (!el.isConnected) root.appendChild(el);
   return [...await attachStyles(root, el, r, global, local), root, own, el];
 }
 var registries = /* @__PURE__ */ new Map();

package/dist/single-spa.d.ts

@@ -1,4 +1,4 @@
-import { P as Props, a as RemoteModule } from './types-CA2p9KHC.js';
+import { P as Props, a as RemoteModule } from './types-DUtcF3HO.js';
 import './errors-kjBv6IH_.js';
 
 /**

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

@@ -1,5 +1,5 @@
 import { R as RemoteError } from './errors-kjBv6IH_.js';
-import { P as Props, I as Isolation, d as StyleOptions } from './types-CA2p9KHC.js';
+import { P as Props, I as Isolation, d as StyleOptions } from './types-DUtcF3HO.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-CA2p9KHC.js';
-export { R as RemoteContext } from './types-CA2p9KHC.js';
+import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared } from './types-DUtcF3HO.js';
+export { R as RemoteContext } from './types-DUtcF3HO.js';
 import { R as RemoteError } from './errors-kjBv6IH_.js';
-export { e as events } from './events-Dkpkw_Sv.js';
+export { e as events } from './events-0rxFlWJJ.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-W6322KGP.js";
+} from "./chunk-UXLKRSOM.js";
 import {
   defineRemote,
   events,
@@ -8,9 +8,9 @@ import {
   navigate,
   same,
   shared
-} from "./chunk-WD4CDGDZ.js";
-import "./chunk-EMSB2NVX.js";
-import "./chunk-6EX5KYT5.js";
+} from "./chunk-HIVMSPGM.js";
+import "./chunk-S7PIVPBX.js";
+import "./chunk-KU6HF2EW.js";
 import "./chunk-TW7KYJQ6.js";
 import "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";

package/dist/{sri-M7ZRU57G.js → sri-576GTDIA.js}

@@ -41,6 +41,7 @@ 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 mapped = /* @__PURE__ */ new Set();
 var probing;
 var preloads;
 var KEY = "vitral:sri-map";
@@ -98,7 +99,7 @@ async function verified(build, run) {
 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];
+  for (const u in sri) if (!/\.css([?#]|$)/.test(u) && !mapped.has(u)) mapped.add(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;

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-CA2p9KHC.js';
-export { R as RemoteContext } from './types-CA2p9KHC.js';
+import { P as Props, I as Isolation, a as RemoteModule } from './types-DUtcF3HO.js';
+export { R as RemoteContext } from './types-DUtcF3HO.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';
+import { S as SlotStatus } from './slot-D49L1rdU.js';
+export { e as events } from './events-0rxFlWJJ.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,13 +1,13 @@
 import {
   hostSlot
-} from "./chunk-W6322KGP.js";
+} from "./chunk-UXLKRSOM.js";
 import {
   defineRemote,
   events,
   navigate
-} from "./chunk-WD4CDGDZ.js";
-import "./chunk-EMSB2NVX.js";
-import "./chunk-6EX5KYT5.js";
+} from "./chunk-HIVMSPGM.js";
+import "./chunk-S7PIVPBX.js";
+import "./chunk-KU6HF2EW.js";
 import "./chunk-TW7KYJQ6.js";
 import "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";

package/dist/testing.d.ts

@@ -1,9 +1,177 @@
-import { P as Props, R as RemoteContext } from './types-CA2p9KHC.js';
+import { P as Props, R as RemoteContext, a as RemoteModule } from './types-DUtcF3HO.js';
 export { r as resetVitral } from './state-BDdCwc21.js';
 import './errors-kjBv6IH_.js';
 
+/** Endereço do JSON Schema do contrato. Vai no `$schema` do arquivo gravado. */
+declare const CONTRACT_SCHEMA = "https://joaogabriel15.github.io/vitral/schema/vitral-contract.json";
 /**
- * Utilidades de teste: monte o host sem subir nenhum remote de verdade.
+ * Contrato do consumidor: o que um host passou para um remote e o que ele
+ * espera de volta, gravado com `record()`. Arquivo `<remote>.contract.json`.
+ */
+interface Contract {
+    $schema?: string;
+    /** Nome com que o host monta o remote. */
+    remote: string;
+    /** Quem gravou (o host). */
+    host?: string;
+    /** `version` do manifesto do remote na gravação. */
+    version?: string;
+    /** Uma montagem por caso, sem repetições. */
+    cases: ContractCase[];
+}
+/** Quando o remote emitiu: no `mount`, num `update`, ao receber um evento do host, ou depois (clique, timer). */
+type EmitPhase = 'mount' | 'update' | 'input' | 'later';
+/**
+ * Uma montagem gravada. Valores que o JSON não guarda viram marcadores:
+ * `{ "$fn": true }` (função), `{ "$date": "…" }` e `{ "$unknown": "Classe" }`.
+ */
+interface ContractCase {
+    /** Props do mount. */
+    props: Props;
+    /** Props de cada `update`, em ordem. */
+    updates?: Props[];
+    /** Eventos que o host emitiu e o remote escutava, em ordem. */
+    inputs?: {
+        type: string;
+        payload?: unknown;
+    }[];
+    /** Valores que o remote leu com `ctx.events.last`. */
+    last?: Record<string, unknown>;
+    /** Chaves de `ctx.shared` que o remote leu, com o primeiro valor lido. */
+    shared?: Record<string, unknown>;
+    /** Eventos que o remote emitiu e o host escuta. */
+    emits?: {
+        type: string;
+        phase: EmitPhase;
+    }[];
+    /** Eventos que o remote assinou. */
+    listens?: string[];
+}
+interface HarnessOptions<P extends Props = Props> {
+    props: P;
+    /** Nome do remote em `ctx.name`. Padrão `'remote'`. */
+    name?: string;
+    /** Monta dentro de um shadow root (`ctx.shadowRoot` e `ctx.portalContainer` ficam nele). */
+    shadow?: boolean;
+    /** Valores iniciais de `ctx.shared`. */
+    shared?: Record<string, unknown>;
+    /** Valores iniciais de `ctx.events.last`. */
+    last?: Record<string, unknown>;
+    /** Campos que substituem os do `ctx` simulado. */
+    ctx?: Partial<RemoteContext>;
+    /** Onde montar. Padrão: um `<div>` novo no `document.body`. */
+    target?: HTMLElement;
+}
+interface Harness<P extends Props = Props> {
+    /** Elemento onde o remote montou. */
+    readonly el: HTMLElement;
+    /** O `ctx` que o remote recebeu. */
+    readonly ctx: RemoteContext;
+    /** Eventos que o remote emitiu por `ctx.events`, em ordem. */
+    readonly events: {
+        type: string;
+        payload: unknown;
+    }[];
+    /** Erros de `ctx.reportError` e de handlers de eventos. */
+    readonly errors: unknown[];
+    /** Chamadas de `ctx.navigate`. */
+    readonly navigations: {
+        url: string;
+        options?: {
+            replace?: boolean;
+        };
+    }[];
+    /** Tipos de evento que o remote escuta agora. */
+    listens(): string[];
+    /** Emite um evento como se fosse o host. */
+    emit(type: string, payload?: unknown): void;
+    update(props: P): void;
+    /** Dispara `ctx.onActivate` (keep-alive). */
+    activate(): void;
+    /** Dispara `ctx.onDeactivate` (keep-alive). */
+    deactivate(): void;
+    unmount(): void;
+}
+/**
+ * Monta `mod` com um `ctx` simulado: barramento de eventos próprio, `shared`
+ * em memória, `portalContainer`, `customElements`, `navigate` e
+ * `reportError` gravados.
+ *
+ *   const h = await harness(remote, { props: { itens: 2 } })
+ *   expect(h.el.textContent).toContain('2 itens')
+ *   h.emit('tema', 'escuro')
+ *   expect(h.events).toContainEqual({ type: 'carrinho:aberto', payload: undefined })
+ */
+declare function harness<P extends Props = Props>(mod: RemoteModule<P> | {
+    default: RemoteModule<P>;
+}, options: HarnessOptions<P>): Promise<Harness<P>>;
+interface VerifyOptions {
+    /**
+     * Código do remote (o texto dos arquivos JS). Um evento que o host escuta e
+     * que o remote só emite depois (clique, timer) é procurado aqui pelo nome.
+     */
+    sources?: string[];
+    /** Quanto esperar depois de cada etapa, em ms. Padrão 0. */
+    wait?: number;
+}
+interface VerifyResult {
+    /** Casos reproduzidos. */
+    cases: number;
+    /** O que quebra o host. Vazio quando o contrato passa. */
+    failures: string[];
+    /** O que mudou sem quebrar. */
+    warnings: string[];
+}
+/**
+ * Reproduz cada caso de `contract` em `mod` (props, updates, eventos do host,
+ * `shared` e `last`) e confere: mount, update e unmount sem erro, nenhum
+ * `reportError`, e cada evento que o host escuta ainda emitido (ou, se só sai
+ * depois de um clique, ainda presente no código).
+ */
+declare function verify(contract: Contract, mod: RemoteModule<any> | {
+    default: RemoteModule<any>;
+}, options?: VerifyOptions): Promise<VerifyResult>;
+
+/**
+ * Gravação do contrato do consumidor, no host: para cada remote montado,
+ * guarda as props, os updates, os eventos que o host emitiu para ele, o que
+ * ele leu de `ctx.shared` e `ctx.events.last`, e os eventos dele que o host
+ * escuta. O remote reproduz o arquivo no CI com `vitral test --contract`.
+ *
+ * Funciona trocando métodos do protocolo global (`load` e o barramento), sem
+ * nada no núcleo: o host só paga por isto quando importa `vitral/testing`.
+ */
+
+interface RecordOptions {
+    /** Nome do host, gravado no contrato. */
+    host?: string;
+    /** Máximo de casos diferentes por remote. Padrão 50. */
+    max?: number;
+}
+interface Recorder {
+    /** Contratos gravados até agora, por nome do remote. */
+    contracts(): Record<string, Contract>;
+    /** Grava `<remote>.contract.json` em `dir` (só no Node). Devolve os caminhos. */
+    save(dir?: string): Promise<string[]>;
+    /** Para de gravar e devolve o protocolo como estava. */
+    stop(): void;
+}
+/**
+ * Começa a gravar. Chame antes de o host montar os remotes e de assinar
+ * eventos (o recorder só vê as assinaturas feitas depois dele).
+ *
+ *   const rec = record({ host: 'loja' })
+ *   // ...testes do host montam os remotes...
+ *   await rec.save('contracts')
+ *
+ * Remotes em `isolate: 'iframe'` e partes (`carrinho/Mini`) não são gravados.
+ */
+declare function record(options?: RecordOptions): Recorder;
+
+/**
+ * Utilidades de teste: monte o host sem subir nenhum remote de verdade, monte
+ * um remote com `ctx` simulado (`harness`) e grave o contrato do consumidor
+ * (`record`) que o remote reproduz no CI com `vitral test --contract`.
  *
  *   import { mockRemote } from 'vitral/testing'
  *   const carrinho = mockRemote('carrinho', (el, props) => (el.textContent = `itens: ${props.itens}`))
@@ -26,4 +194,4 @@ declare function mockRemote<P extends Props = Props>(name: string, render?: (el:
 /** Remote que sempre falha ao montar, para testar telas de erro. */
 declare function failingRemote(name: string, message?: string): void;
 
-export { type MockRemote, failingRemote, mockRemote };
+export { CONTRACT_SCHEMA, type Contract, type ContractCase, type EmitPhase, type Harness, type HarnessOptions, type MockRemote, type RecordOptions, type Recorder, type VerifyOptions, type VerifyResult, failingRemote, harness, mockRemote, record, verify };

package/dist/testing.js

@@ -1,14 +1,197 @@
-import "./chunk-WD4CDGDZ.js";
+import {
+  CONTRACT_SCHEMA,
+  encode,
+  harness,
+  verify
+} from "./chunk-DAESKNQ6.js";
+import "./chunk-HIVMSPGM.js";
 import {
   register
-} from "./chunk-EMSB2NVX.js";
-import "./chunk-6EX5KYT5.js";
+} from "./chunk-S7PIVPBX.js";
+import "./chunk-KU6HF2EW.js";
 import "./chunk-TW7KYJQ6.js";
 import "./chunk-463H6B56.js";
 import {
+  protocol,
   resetProtocol
 } from "./chunk-GNPFWISJ.js";
 
+// src/recorder.ts
+function record(options = {}) {
+  const p = protocol();
+  const bus = p.events;
+  const { load, emit, on } = { load: p.load, emit: bus.emit, on: bus.on };
+  const cases = /* @__PURE__ */ new Map();
+  const versions = /* @__PURE__ */ new Map();
+  const hostListens = /* @__PURE__ */ new Set();
+  const wrapped = /* @__PURE__ */ new WeakMap();
+  let viaRemote = 0;
+  let hostEmitting = [];
+  bus.on = (type, handler) => {
+    if (viaRemote) return on.call(bus, type, handler);
+    hostListens.add(type);
+    return on.call(bus, type, (payload) => {
+      const before = viaRemote;
+      viaRemote = 0;
+      try {
+        handler(payload);
+      } finally {
+        viaRemote = before;
+      }
+    });
+  };
+  bus.emit = (type, payload) => {
+    hostEmitting.push(!viaRemote);
+    try {
+      return emit.call(bus, type, payload);
+    } finally {
+      hostEmitting.pop();
+    }
+  };
+  const scope = (live, events) => ({
+    emit(type, payload) {
+      live.emits.push({ type, phase: live.phase });
+      viaRemote++;
+      try {
+        events.emit(type, payload);
+      } finally {
+        viaRemote--;
+      }
+    },
+    on(type, handler) {
+      live.listens.add(type);
+      viaRemote++;
+      try {
+        return events.on(type, (payload) => {
+          if (!hostEmitting.at(-1)) return handler(payload);
+          live.inputs.push({ type, payload: encode(payload) });
+          const before = live.phase;
+          live.phase = "input";
+          try {
+            handler(payload);
+          } finally {
+            live.phase = before;
+          }
+        });
+      } finally {
+        viaRemote--;
+      }
+    },
+    last(type) {
+      const v = events.last(type);
+      if (v !== void 0 && !(type in live.last)) live.last[type] = encode(v);
+      return v;
+    }
+  });
+  const sharedOf = (live, api) => {
+    const seen = (key, v) => {
+      if (v !== void 0 && !(key in live.shared)) live.shared[key] = encode(v);
+      return v;
+    };
+    const wrap = (key) => {
+      const h = api(key);
+      return { ...h, get: () => seen(key, h.get()), subscribe: (fn) => h.subscribe((v) => fn(seen(key, v))) };
+    };
+    return Object.assign(wrap, { provide: api.provide, batch: api.batch });
+  };
+  const wrapModule = (mod) => {
+    let w = wrapped.get(mod);
+    if (w) return w;
+    w = Object.create(mod, {
+      mount: {
+        value: async (el, props, ctx) => {
+          const live = { props: encode(props), updates: [], inputs: [], last: {}, shared: {}, emits: [], listens: /* @__PURE__ */ new Set(), phase: "mount" };
+          const list = cases.get(ctx.name) ?? [];
+          cases.set(ctx.name, list);
+          list.push(live);
+          const own = { ...ctx, events: scope(live, ctx.events) };
+          if (ctx.shared) own.shared = sharedOf(live, ctx.shared);
+          let mounted;
+          try {
+            mounted = await mod.mount(el, props, own);
+          } finally {
+            live.phase = "later";
+          }
+          return {
+            update(next) {
+              live.updates.push(encode(next));
+              live.phase = "update";
+              try {
+                mounted.update?.(next);
+              } finally {
+                live.phase = "later";
+              }
+            },
+            unmount: () => mounted.unmount()
+          };
+        }
+      }
+    });
+    wrapped.set(mod, w);
+    return w;
+  };
+  p.load = (name, fetcher) => load.call(p, name, fetcher).then((r) => {
+    if (r.version) versions.set(r.name ?? name, r.version);
+    return typeof r.module?.mount === "function" ? { ...r, module: wrapModule(r.module) } : r;
+  });
+  const contracts = () => {
+    const out = {};
+    for (const [remote, lives] of cases) {
+      const unique = /* @__PURE__ */ new Map();
+      for (const live of lives) {
+        const c = { props: live.props };
+        if (live.updates.length) c.updates = live.updates;
+        if (live.inputs.length) c.inputs = live.inputs;
+        if (Object.keys(live.last).length) c.last = live.last;
+        if (Object.keys(live.shared).length) c.shared = live.shared;
+        const emits = /* @__PURE__ */ new Map();
+        for (const e of live.emits) if (hostListens.has(e.type) && (!emits.has(e.type) || emits.get(e.type) === "later")) emits.set(e.type, e.phase);
+        if (emits.size) c.emits = [...emits].map(([type, phase]) => ({ type, phase }));
+        if (live.listens.size) c.listens = [...live.listens].sort();
+        const key = JSON.stringify(c);
+        if (!unique.has(key) && unique.size < (options.max ?? 50)) unique.set(key, c);
+      }
+      out[remote] = {
+        $schema: CONTRACT_SCHEMA,
+        remote,
+        ...options.host && { host: options.host },
+        ...versions.has(remote) && { version: versions.get(remote) },
+        cases: [...unique.values()]
+      };
+    }
+    return out;
+  };
+  return {
+    contracts,
+    async save(dir = ".") {
+      const fs = "node:fs/promises";
+      const path = "node:path";
+      const { mkdir, writeFile } = await import(
+        /* @vite-ignore */
+        fs
+      );
+      const { join } = await import(
+        /* @vite-ignore */
+        path
+      );
+      await mkdir(dir, { recursive: true });
+      const files = [];
+      for (const [name, c] of Object.entries(contracts())) {
+        const file = join(dir, `${name.replace(/[^\w.-]+/g, "_")}.contract.json`);
+        await writeFile(file, JSON.stringify(c, null, 2) + "\n");
+        files.push(file);
+      }
+      return files;
+    },
+    stop() {
+      p.load = load;
+      bus.emit = emit;
+      bus.on = on;
+      hostEmitting = [];
+    }
+  };
+}
+
 // src/testing.ts
 function mockRemote(name, render = (el) => {
   el.setAttribute("data-mock-remote", name);
@@ -47,7 +230,11 @@ function failingRemote(name, message = "falha simulada") {
   });
 }
 export {
+  CONTRACT_SCHEMA,
   failingRemote,
+  harness,
   mockRemote,
-  resetProtocol as resetVitral
+  record,
+  resetProtocol as resetVitral,
+  verify
 };

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

@@ -157,6 +157,15 @@ interface MountedRemote<P extends Props = Props> {
 }
 interface RemoteModule<P extends Props = Props> {
     mount(el: HTMLElement, props: P, ctx: RemoteContext): MountedRemote<P> | Promise<MountedRemote<P>>;
+    /**
+     * Opcional. Quando o gateway de `vitral/edge` já renderizou o remote no
+     * servidor, o `<vitral-remote>` chama `hydrate` com `el` cheio do HTML de
+     * `render` (no Shadow DOM declarativo, se for o caso), em vez de limpar e
+     * chamar `mount`. Deve assumir o DOM que existe, sem recriar.
+     */
+    hydrate?(el: HTMLElement, props: P, ctx: RemoteContext): MountedRemote<P> | Promise<MountedRemote<P>>;
+    /** Opcional, só no servidor: o HTML do remote para estas props (SSR pelo gateway). */
+    render?(props: P): string | Promise<string>;
 }
 interface RemoteEntry {
     /** URL do módulo JS do remote, ou do `vitral.json` gerado pelo plugin. */
@@ -243,8 +252,10 @@ interface RollbackInfo {
 /**
  * `none`: CSS com escopo. `shadow`: Shadow DOM. `iframe`: iframe com
  * `sandbox`, para código de terceiros (precisa de `enableIframe()`).
+ * `reframe`: JS num iframe oculto de mesma origem (globals próprios) e DOM
+ * no Shadow DOM da página. Não é fronteira de segurança.
  */
-type Isolation = 'shadow' | 'none' | 'iframe';
+type Isolation = 'shadow' | 'none' | 'iframe' | 'reframe';
 /** Estilos do host dentro do Shadow DOM. Sem efeito no modo escopo. */
 interface StyleOptions {
     /**

package/dist/vitals.d.ts

@@ -0,0 +1,29 @@
+type VitalName = 'LCP' | 'CLS' | 'INP' | 'FCP' | 'TTFB';
+type VitalRating = 'good' | 'needs-improvement' | 'poor';
+interface VitalReport {
+    name: VitalName;
+    /** Remote dono do elemento. Ausente quando é do host ou da página. */
+    remote?: string;
+    /** Versão do remote (do manifesto) na hora da medição. */
+    version?: string;
+    /** Rota: pathname da navegação (soft ou não). */
+    route: string;
+    /** `navigationId` das entradas, só com Soft Navigations. */
+    navigationId?: string;
+    /** ms para LCP, INP, FCP e TTFB; sem unidade para CLS. */
+    value: number;
+    rating: VitalRating;
+}
+interface VitalsOptions {
+    onReport: (report: VitalReport) => void;
+}
+declare const rating: (name: VitalName, value: number) => VitalRating;
+/** Dono de `node`: o `data-vitral-root` mais próximo, atravessando shadow roots. `''` é o host. */
+declare function owner(node: Node | null | undefined): string;
+/**
+ * Observa as Web Vitals e chama `onReport` com cada uma, por remote e rota.
+ * Devolve `stop`, que relata o que falta e desliga os observers.
+ */
+declare function vitals({ onReport }: VitalsOptions): () => void;
+
+export { type VitalName, type VitalRating, type VitalReport, type VitalsOptions, owner, rating, vitals };