vitral 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,17 +1,119 @@
+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-Czvm-siZ.js';
+export { C as CheckedProps, H as Handler, e as PropsOf, f as ProvideOptions, g as ProvidedValue, h as RemoteContract, i as RemoteManifest, j as RemoteMetric, k as Remotes, S as Shared, l as SharedApi, m as SharedModules, n as SharedType, o as batch, p as provide, s as shared } from './types-Czvm-siZ.js';
+import { R as RemoteError } from './errors-kjBv6IH_.js';
+export { a as RemoteErrorCode } from './errors-kjBv6IH_.js';
+export { R as RemoteSlot, a as SlotOptions, S as SlotStatus, c as createSlot } from './slot-DqXTwGbs.js';
+export { e as events } from './events-D5gs7rff.js';
+export { n as navigate } from './navigate-BRG1WJUM.js';
+export { r as __reset } from './state-BDdCwc21.js';
+
+/** 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[];
+}
+
+/** 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;
+
+/** 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. Resolve quando todas as
+ * montagens já mostram a versão nova. Rejeita se a versão nova não carregar
+ * ou se o `mount` dela falhar; nesse caso a montagem antiga fica na tela.
+ */
+declare function refresh(name: string): Promise<void>;
+/**
+ * Revalida os manifestos dos remotes montados agora (os desmontados ficam de
+ * fora) 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 +143,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,45 @@
 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-I3VSKSAZ.js";
+import {
+  configure,
+  loadModule,
+  loadRemote,
   preload,
   register,
-  render,
-  unsafeHTML
-} from "./chunk-TTL52BF2.js";
+  registerSrc
+} from "./chunk-TD4S3IHA.js";
+import "./chunk-ZAC6QQI6.js";
+import "./chunk-GNHCZRQP.js";
+import {
+  RemoteError
+} from "./chunk-AKNNHQ2H.js";
+import {
+  createEventBus,
+  resetProtocol
+} from "./chunk-GNPFWISJ.js";
 export {
   RemoteError,
-  __reset,
+  resetProtocol as __reset,
+  batch,
+  checkUpdates,
   component,
   configure,
   createEventBus,
@@ -26,11 +47,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/otel.d.ts

@@ -0,0 +1,44 @@
+import { R as RemoteError } from './errors-kjBv6IH_.js';
+
+/**
+ * Erros dos remotes no OpenTelemetry, sem depender do `@opentelemetry/api`:
+ *
+ *   import { trace } from '@opentelemetry/api'
+ *   import { otelOnError } from 'vitral/otel'
+ *
+ *   configure({ onError: otelOnError({ trace, tracer: trace.getTracer('host') }) })
+ *
+ * Com um span ativo, o erro vira um evento `exception` nele. Sem span ativo
+ * (ou sem `trace`), o `tracer` abre e fecha um span `vitral.error` com o erro.
+ * Os atributos são os de exceção do OpenTelemetry mais `vitral.remote`,
+ * `vitral.version`, `vitral.code`, `vitral.entry` e `vitral.route`.
+ */
+
+/** Atributos de span e de evento. */
+type Attributes = Record<string, string>;
+/** A parte de um `Span` que o adaptador usa. */
+interface SpanLike {
+    addEvent(name: string, attributes?: Attributes): unknown;
+    recordException(exception: Error): void;
+    setStatus(status: {
+        code: number;
+        message?: string;
+    }): unknown;
+    end(): void;
+}
+interface OtelOptions {
+    /** O `trace` de `@opentelemetry/api`, para achar o span ativo. */
+    trace?: {
+        getActiveSpan(): SpanLike | undefined;
+    };
+    /** Tracer que abre um span quando não há span ativo. */
+    tracer?: {
+        startSpan(name: string, options?: {
+            attributes?: Attributes;
+        }): SpanLike;
+    };
+}
+/** `onError` para o `configure` que registra cada `RemoteError` no OpenTelemetry. */
+declare function otelOnError({ trace, tracer }: OtelOptions): (error: RemoteError) => void;
+
+export { type Attributes, type OtelOptions, type SpanLike, otelOnError };

package/dist/otel.js

@@ -0,0 +1,27 @@
+// src/otel.ts
+function otelOnError({ trace, tracer }) {
+  return (error) => {
+    const all = {
+      "exception.type": error.name,
+      "exception.message": error.message,
+      "exception.stacktrace": error.stack,
+      "vitral.remote": error.remote,
+      "vitral.version": error.version,
+      "vitral.code": error.code,
+      "vitral.entry": error.entry,
+      "vitral.route": error.route
+    };
+    const attributes = {};
+    for (const k in all) if (all[k] !== void 0) attributes[k] = all[k];
+    const active = trace?.getActiveSpan();
+    if (active) return void active.addEvent("exception", attributes);
+    const span = tracer?.startSpan("vitral.error", { attributes });
+    if (!span) return;
+    span.recordException(error);
+    span.setStatus({ code: 2, message: error.message });
+    span.end();
+  };
+}
+export {
+  otelOnError
+};

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
+};

package/dist/preact.d.ts

@@ -1,22 +1,45 @@
 import * as preact from 'preact';
 import { VNode, ComponentType } from 'preact';
-import { Props, Isolation, RemoteError, SlotStatus, RemoteModule } from './index.js';
-export { RemoteContext, events, navigate } from './index.js';
+import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared } from './types-Czvm-siZ.js';
+export { R as RemoteContext } from './types-Czvm-siZ.js';
+import { R as RemoteError } from './errors-kjBv6IH_.js';
+import { S as SlotStatus } from './slot-DqXTwGbs.js';
+export { e as events } from './events-D5gs7rff.js';
+export { n as navigate } from './navigate-BRG1WJUM.js';
+import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 
 /** Transforma um componente Preact em um remote. O contexto chega na prop `vitral`. */
 declare function preactRemote<P extends Props>(Component: ComponentType<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?: VNode | string | null;
     error?: VNode | string | ((error: RemoteError, retry: () => void) => VNode | string | null) | null;
     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>({ name, props, isolate, fallback, error, ...rest }: RemoteProps<P>): VNode<preact.ClassAttributes<HTMLElement> & {
-    'data-vitral': string;
+declare function Remote<P extends Props = Props, N extends string = string>({ name, src, props, isolate, fallback, error, loading, prefetch, priority, keepAlive, ...rest }: RemoteProps<P> & CheckedProps<N>): VNode<preact.ClassAttributes<HTMLElement> & {
+    'data-vitral': string | undefined;
     'data-vitral-status': SlotStatus;
-    class: string | undefined;
+    class: (RemoteProps<P> & CheckedProps<N>)["class"] | undefined;
 }>;
+/**
+ * Lê uma chave compartilhada (`provide`/`shared`) e re-renderiza só quando
+ * ela muda. Com seletor, só quando o resultado do seletor muda (`Object.is`).
+ *
+ *   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): S;
+declare function useShared<T = unknown, S = T | undefined>(key: string, select?: (value: T | undefined) => S): S;
 
-export { Remote, type RemoteProps, preactRemote };
+export { Remote, type RemoteProps, preactRemote, useShared };

package/dist/preact.js

@@ -1,13 +1,23 @@
 import {
-  createSlot,
+  hostSlot
+} from "./chunk-IHTUM6LT.js";
+import {
   defineRemote,
   events,
-  navigate
-} from "./chunk-TTL52BF2.js";
+  memoSelect,
+  navigate,
+  same,
+  shared
+} from "./chunk-I3VSKSAZ.js";
+import "./chunk-TD4S3IHA.js";
+import "./chunk-ZAC6QQI6.js";
+import "./chunk-GNHCZRQP.js";
+import "./chunk-AKNNHQ2H.js";
+import "./chunk-GNPFWISJ.js";
 
 // src/preact.ts
 import { h, render } from "preact";
-import { useEffect, useRef, useState } from "preact/hooks";
+import { useEffect, useMemo, useRef, useState } from "preact/hooks";
 function preactRemote(Component) {
   return defineRemote({
     mount(el, props, ctx) {
@@ -17,27 +27,46 @@ function preactRemote(Component) {
     }
   });
 }
-function Remote({ name, props, isolate, fallback = null, error = null, ...rest }) {
+function Remote({ name, src, props, isolate, fallback = null, error = null, loading, prefetch, priority, keepAlive, ...rest }) {
   const ref = useRef(null);
   const slot = useRef(null);
   const [state, setState] = useState({ status: "loading", error: null });
   useEffect(() => {
-    slot.current = createSlot(ref.current, { name, props: props ?? {}, isolate, onStatus: (status, error2) => setState({ status, error: error2 }) });
+    slot.current = hostSlot(ref.current, { name, src, props: props ?? {}, isolate, loading, prefetch, priority, keepAlive, onStatus: (status, error2) => setState({ status, error: error2 }) });
     return () => slot.current?.destroy();
   }, []);
-  useEffect(() => slot.current?.set({ name, isolate }), [name, isolate]);
+  useEffect(() => slot.current?.set({ name, src, isolate }), [name, src, isolate]);
   useEffect(() => slot.current?.update(props ?? {}), [props]);
   const retry = () => slot.current?.retry();
-  return h("div", { "data-vitral": name, "data-vitral-status": state.status, class: rest.class }, [
+  return h("div", { "data-vitral": name ?? src, "data-vitral-status": state.status, class: rest.class }, [
     state.status === "loading" ? fallback : null,
     state.status === "error" && state.error ? typeof error === "function" ? error(state.error, retry) : error : null,
     // O Preact nunca coloca filhos neste div: ele pertence ao remote.
     h("div", { ref })
   ]);
 }
+function useShared(key, select = same) {
+  const handle = useMemo(() => shared(key), [key]);
+  const [pick] = useState(memoSelect);
+  const [, rerender] = useState(0);
+  const value = pick(handle.get(), select);
+  const latest = useRef({ value, select });
+  latest.current = { value, select };
+  useEffect(
+    () => (
+      // subscribe chama na hora: pega mudanças entre o render e o efeito.
+      handle.subscribe((v) => {
+        if (!Object.is(pick(v, latest.current.select), latest.current.value)) rerender((n) => n + 1);
+      })
+    ),
+    [handle]
+  );
+  return value;
+}
 export {
   Remote,
   events,
   navigate,
-  preactRemote
+  preactRemote,
+  useShared
 };