vitral 0.4.0 → 0.5.0

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-KZBH5MPD.js";
 import {
   register
-} from "./chunk-EMSB2NVX.js";
-import "./chunk-6EX5KYT5.js";
+} from "./chunk-5JNV45BB.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 };

package/dist/vitals.js

@@ -0,0 +1,152 @@
+import {
+  mounted
+} from "./chunk-463H6B56.js";
+import "./chunk-GNPFWISJ.js";
+
+// src/vitals.ts
+var LIMITS = {
+  LCP: [2500, 4e3],
+  CLS: [0.1, 0.25],
+  INP: [200, 500],
+  FCP: [1800, 3e3],
+  TTFB: [800, 1800]
+};
+var rating = (name, value) => value <= LIMITS[name][0] ? "good" : value <= LIMITS[name][1] ? "needs-improvement" : "poor";
+function owner(node) {
+  while (node) {
+    const el = node.nodeType === 1 ? node : node.parentElement;
+    const root = el?.closest("[data-vitral-root]");
+    if (root) return root.getAttribute("data-vitral-root");
+    node = (el ?? node).getRootNode().host;
+  }
+  return "";
+}
+function vitals({ onReport }) {
+  if (typeof PerformanceObserver == "undefined") return () => {
+  };
+  const types = PerformanceObserver.supportedEntryTypes ?? [];
+  const soft = types.includes("soft-navigation");
+  const navs = /* @__PURE__ */ new Map();
+  const done = /* @__PURE__ */ new Set();
+  const routes = /* @__PURE__ */ new Map();
+  const versions = /* @__PURE__ */ new Map();
+  const observers = [];
+  const send = (name, value, nav, who2 = "") => {
+    const key = name + "|" + who2;
+    if (nav.sent.get(key) === value) return;
+    nav.sent.set(key, value);
+    const report = { name, route: routes.get(nav.id)?.[0] ?? nav.route, value, rating: rating(name, value) };
+    if (who2) report.remote = who2, report.version = versions.get(who2);
+    if (nav.id !== void 0) report.navigationId = nav.id;
+    if (report.version === void 0) delete report.version;
+    try {
+      onReport(report);
+    } catch {
+    }
+  };
+  const flush = (nav) => {
+    const start = routes.get(nav.id)?.[1] ?? nav.start;
+    if (nav.lcp) send("LCP", Math.max(0, nav.lcp[0] - start), nav, nav.lcp[1]);
+    for (const [who2, s] of nav.cls) send("CLS", s.max, nav, who2);
+    for (const [who2, list] of nav.inp) {
+      const all2 = [...list.values()].sort((a, b) => b - a);
+      send("INP", all2[Math.min(all2.length - 1, Math.floor(all2.length / 50))], nav, who2);
+    }
+  };
+  const navOf = (e) => {
+    const id = soft && e.navigationId != null ? String(e.navigationId) : void 0;
+    const key = id ?? "r:" + location.pathname;
+    if (done.has(key)) return;
+    let nav = navs.get(key);
+    if (!nav) {
+      for (const [k, old] of navs) flush(old), navs.delete(k), old.id !== void 0 && done.add(k);
+      navs.set(key, nav = { id, route: location.pathname, start: 0, cls: /* @__PURE__ */ new Map(), inp: /* @__PURE__ */ new Map(), sent: /* @__PURE__ */ new Map() });
+    }
+    return nav;
+  };
+  const who = (node) => {
+    const name = owner(node);
+    if (name && !versions.has(name)) versions.set(name, mounted.get(name)?.version);
+    return name;
+  };
+  const handle = (e) => {
+    switch (e.entryType) {
+      case "soft-navigation": {
+        routes.set(String(e.navigationId), [new URL(e.name, location.href).pathname, e.startTime]);
+        return;
+      }
+      case "navigation": {
+        if (e.navigationId != null && soft) routes.set(String(e.navigationId), [new URL(e.name, location.href).pathname, 0]);
+        const nav = navOf(e);
+        if (nav && e.responseStart > 0) send("TTFB", Math.max(0, e.responseStart - (e.activationStart ?? 0)), nav);
+        return;
+      }
+      case "paint": {
+        const nav = e.name == "first-contentful-paint" && navOf(e);
+        if (nav) send("FCP", Math.max(0, e.startTime - (activation() ?? 0)), nav);
+        return;
+      }
+      case "largest-contentful-paint": {
+        const nav = navOf(e);
+        if (nav) nav.lcp = [e.startTime, who(e.element)];
+        return;
+      }
+      case "layout-shift": {
+        if (e.hadRecentInput) return;
+        const nav = navOf(e);
+        if (!nav) return;
+        let big;
+        let area = -1;
+        for (const s2 of e.sources ?? []) {
+          const r = s2.currentRect ?? s2.previousRect;
+          const a = r ? r.width * r.height : 0;
+          if (a > area) area = a, big = s2.node;
+        }
+        const name = who(big);
+        const t = e.startTime;
+        const s = nav.cls.get(name);
+        if (s && t - s.last < 1e3 && t - s.first < 5e3) s.current += e.value;
+        else if (s) s.current = e.value, s.first = t;
+        if (s) s.last = t, s.max = Math.max(s.max, s.current);
+        else nav.cls.set(name, { first: t, last: t, current: e.value, max: e.value });
+        return;
+      }
+      case "event": {
+        if (!e.interactionId) return;
+        const nav = navOf(e);
+        if (!nav) return;
+        const name = who(e.target);
+        const list = nav.inp.get(name) ?? /* @__PURE__ */ new Map();
+        nav.inp.set(name, list);
+        list.set(e.interactionId, Math.max(list.get(e.interactionId) ?? 0, e.duration));
+      }
+    }
+  };
+  const activation = () => performance.getEntriesByType?.("navigation")[0]?.activationStart;
+  for (const type of ["soft-navigation", "navigation", "paint", "largest-contentful-paint", "layout-shift", "event"]) {
+    if (!types.includes(type)) continue;
+    try {
+      const o = new PerformanceObserver((list) => list.getEntries().forEach((e) => handle(e)));
+      o.observe({ type, buffered: true, durationThreshold: 40, includeSoftNavigationObservations: true });
+      observers.push(o);
+    } catch {
+    }
+  }
+  const all = () => {
+    for (const o of observers) o.takeRecords().forEach((e) => handle(e));
+    navs.forEach(flush);
+  };
+  const hidden = () => document.visibilityState == "hidden" && all();
+  document.addEventListener("visibilitychange", hidden);
+  return () => {
+    document.removeEventListener("visibilitychange", hidden);
+    all();
+    observers.forEach((o) => o.disconnect());
+    observers.length = 0;
+  };
+}
+export {
+  owner,
+  rating,
+  vitals
+};