vitral 0.2.0 → 0.4.0

package/dist/iframe.js

@@ -1,25 +1,28 @@
 import {
   splitName
-} from "./chunk-HP6QWU6K.js";
+} from "./chunk-IH3ZT3QU.js";
 import {
   verifyIntegrity
-} from "./chunk-S5MZT5IT.js";
+} from "./chunk-UYOPJ4XQ.js";
 import {
   events,
   navigate,
   setFrameMounter,
   track
-} from "./chunk-NCONW6WS.js";
+} from "./chunk-WD4CDGDZ.js";
 import {
   resolveEntry
-} from "./chunk-2XF5BKV3.js";
-import "./chunk-SFL6LTP3.js";
+} from "./chunk-EMSB2NVX.js";
+import "./chunk-6EX5KYT5.js";
 import {
-  RemoteError,
   fetchBytes,
   withRetry,
   withTimeout
-} from "./chunk-PX7PBCCT.js";
+} from "./chunk-TW7KYJQ6.js";
+import {
+  RemoteError,
+  report
+} from "./chunk-463H6B56.js";
 import {
   protocol
 } from "./chunk-GNPFWISJ.js";
@@ -46,7 +49,7 @@ var FRAME_RUNTIME = `function (w, load) {
     // 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,
+      name: d.name, baseUrl: d.baseUrl, events: events, shadowRoot: null, portalContainer: doc.body, 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) }) }
     }
@@ -119,7 +122,6 @@ async function mountFrame(target, name, props, options, sandbox, bridges) {
     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);
@@ -188,7 +190,7 @@ async function mountFrame(target, name, props, options, sandbox, bridges) {
         break;
       }
       case "report": {
-        const err = new RemoteError("RENDER_FAILED", name, String(d?.message));
+        const err = report(new RemoteError("RENDER_FAILED", name, String(d?.message)), resolved);
         if (options.onError) options.onError(err);
         else console.error(err);
         break;
@@ -217,6 +219,7 @@ async function mountFrame(target, name, props, options, sandbox, bridges) {
     cleanup();
     throw e;
   }
+  disposers.push(track(name, resolved));
   let alive = true;
   return {
     update(next) {

package/dist/index.d.ts

@@ -1,24 +1,12 @@
-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';
+import { V as VitralConfig, c as RemoteEntry, P as Props, a as RemoteModule, I as Isolation, d as StyleOptions, M as MountedRemote, E as EventBus, R as RemoteContext, e as SharedValue } from './types-CA2p9KHC.js';
+export { f as Channel, g as ChannelContext, C as CheckedProps, D as DevOverrides, H as Handler, h as McpAppBridge, i as PropsOf, j as ProvideOptions, k as ProvidedValue, l as RemoteContract, m as RemoteManifest, n as RemoteMetric, o as Remotes, p as RollbackInfo, S as Shared, q as SharedApi, b as SharedModules, r as SharedType, s as batch, t as provide, u as shared } from './types-CA2p9KHC.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-UPg6ob9v.js';
+export { e as events } from './events-Dkpkw_Sv.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;
@@ -60,6 +48,18 @@ interface SharedStore {
     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>>;
 /**
@@ -97,12 +97,14 @@ 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.
+ * 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 e emite
+ * 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.
  */

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   syncTabs,
   unsafeHTML,
   watchUpdates
-} from "./chunk-NCONW6WS.js";
+} from "./chunk-WD4CDGDZ.js";
 import {
   configure,
   loadModule,
@@ -25,11 +25,12 @@ import {
   preload,
   register,
   registerSrc
-} from "./chunk-2XF5BKV3.js";
-import "./chunk-SFL6LTP3.js";
+} from "./chunk-EMSB2NVX.js";
+import "./chunk-6EX5KYT5.js";
+import "./chunk-TW7KYJQ6.js";
 import {
   RemoteError
-} from "./chunk-PX7PBCCT.js";
+} from "./chunk-463H6B56.js";
 import {
   createEventBus,
   resetProtocol

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-NP754HY7.js

@@ -0,0 +1,27 @@
+import {
+  OVERRIDES_KEY,
+  activeOverrides,
+  clearOverrides,
+  dropOverride,
+  isRef,
+  manifestUrl,
+  overrideFor,
+  overridesEnabled,
+  resolveOverride,
+  storeOverride,
+  storedOverrides
+} from "./chunk-54CBIZES.js";
+import "./chunk-GNPFWISJ.js";
+export {
+  OVERRIDES_KEY,
+  activeOverrides,
+  clearOverrides,
+  dropOverride,
+  isRef,
+  manifestUrl,
+  overrideFor,
+  overridesEnabled,
+  resolveOverride,
+  storeOverride,
+  storedOverrides
+};

package/dist/preact.d.ts

@@ -1,10 +1,10 @@
 import * as preact from 'preact';
 import { VNode, ComponentType } from 'preact';
-import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared } from './types-BV-hUrms.js';
-export { R as RemoteContext } from './types-BV-hUrms.js';
-import { R as RemoteError } from './errors-KKB8FGCz.js';
-import { S as SlotStatus } from './slot-pB276oPt.js';
-export { e as events } from './events-DUdjhfps.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 { R as RemoteError } from './errors-kjBv6IH_.js';
+import { S as SlotStatus } from './slot-UPg6ob9v.js';
+export { e as events } from './events-Dkpkw_Sv.js';
 export { n as navigate } from './navigate-BRG1WJUM.js';
 import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 

package/dist/preact.js

@@ -1,6 +1,6 @@
 import {
   hostSlot
-} from "./chunk-UTYAX6MU.js";
+} from "./chunk-W6322KGP.js";
 import {
   defineRemote,
   events,
@@ -8,10 +8,11 @@ import {
   navigate,
   same,
   shared
-} from "./chunk-NCONW6WS.js";
-import "./chunk-2XF5BKV3.js";
-import "./chunk-SFL6LTP3.js";
-import "./chunk-PX7PBCCT.js";
+} from "./chunk-WD4CDGDZ.js";
+import "./chunk-EMSB2NVX.js";
+import "./chunk-6EX5KYT5.js";
+import "./chunk-TW7KYJQ6.js";
+import "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";
 
 // src/preact.ts

package/dist/react.d.ts

@@ -1,9 +1,10 @@
 import { ReactNode, ComponentType } from 'react';
 import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 import * as JSXRuntime from 'react/jsx-runtime';
-import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared, R as RemoteContext } from './types-BV-hUrms.js';
-export { E as EventBus } from './types-BV-hUrms.js';
-export { e as events } from './events-DUdjhfps.js';
+import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared, R as RemoteContext } from './types-CA2p9KHC.js';
+export { E as EventBus } from './types-CA2p9KHC.js';
+export { e as events } from './events-Dkpkw_Sv.js';
+import './errors-kjBv6IH_.js';
 
 /**
  * Adaptador React (funciona em Vite, CRA e Next.js App/Pages Router).
@@ -17,6 +18,13 @@ export { e as events } from './events-DUdjhfps.js';
 declare function reactRemote<P extends Props>(Component: ComponentType<P>): RemoteModule<P>;
 /** Dentro de um remote: dá acesso ao contexto (nome, eventos, baseUrl). */
 declare function useVitral(): RemoteContext | null;
+/**
+ * Dentro de um remote: onde renderizar portais. No Shadow DOM é um elemento
+ * dentro do shadow root (com os estilos do remote); fora de um remote,
+ * `undefined`, e a biblioteca usa o padrão dela (`document.body`). Use em
+ * `<Popover.Portal container={usePortalContainer()}>`.
+ */
+declare function usePortalContainer(): HTMLElement | undefined;
 /** Assina um evento do barramento global enquanto o componente estiver montado. */
 declare function useEvent<T = unknown>(type: string, handler: (payload: T) => void): void;
 /** Estado derivado do último valor emitido em `type`. */
@@ -60,4 +68,4 @@ interface RemoteProps<P extends Props = Props> {
  */
 declare function Remote<P extends Props = Props, N extends string = string>({ name, src, props, isolate, fallback, error, onError, className, loading, prefetch, priority, keepAlive, }: RemoteProps<P> & CheckedProps<N>): JSXRuntime.JSX.Element;
 
-export { Remote, type RemoteProps, reactRemote, useEvent, useEventValue, useShared, useVitral };
+export { Remote, type RemoteProps, reactRemote, useEvent, useEventValue, usePortalContainer, useShared, useVitral };

package/dist/react.js

@@ -1,17 +1,18 @@
 "use client";
 import {
   hostSlot
-} from "./chunk-UTYAX6MU.js";
+} from "./chunk-W6322KGP.js";
 import {
   defineRemote,
   events,
   memoSelect,
   same,
   shared
-} from "./chunk-NCONW6WS.js";
-import "./chunk-2XF5BKV3.js";
-import "./chunk-SFL6LTP3.js";
-import "./chunk-PX7PBCCT.js";
+} from "./chunk-WD4CDGDZ.js";
+import "./chunk-EMSB2NVX.js";
+import "./chunk-6EX5KYT5.js";
+import "./chunk-TW7KYJQ6.js";
+import "./chunk-463H6B56.js";
 import {
   protocol
 } from "./chunk-GNPFWISJ.js";
@@ -65,6 +66,9 @@ function reactRemote(Component) {
 function useVitral() {
   return useContext(VitralContext);
 }
+function usePortalContainer() {
+  return useVitral()?.portalContainer;
+}
 function useEvent(type, handler) {
   const ref = useRef(handler);
   ref.current = handler;
@@ -99,7 +103,7 @@ function offerReact() {
     // O React 19 expõe o react/compiler-runtime pelo próprio react.
     ...compiler && { "react/compiler-runtime": compiler }
   };
-  p.pending(import("./dedupe-IWFIXRWG.js").then((m) => m.offer(p, { react: { version: ReactAll.version, modules } })).catch(() => {
+  p.pending(import("./dedupe-S7BHQMOZ.js").then((m) => m.offer(p, { react: { version: ReactAll.version, modules } })).catch(() => {
   }));
 }
 function Remote({
@@ -162,6 +166,7 @@ export {
   reactRemote,
   useEvent,
   useEventValue,
+  usePortalContainer,
   useShared,
   useVitral
 };

package/dist/routes.d.ts

@@ -1,6 +1,6 @@
-import { P as Props } from './types-BV-hUrms.js';
-import { S as SlotStatus } from './slot-pB276oPt.js';
-import './errors-KKB8FGCz.js';
+import { P as Props } from './types-CA2p9KHC.js';
+import { S as SlotStatus } from './slot-UPg6ob9v.js';
+import './errors-kjBv6IH_.js';
 
 /** Padrão de URL → nome do remote. A primeira rota que bate vence. */
 type Routes = Record<string, string>;

package/dist/routes.js

@@ -1,10 +1,11 @@
 import {
   createSlot,
   navigate
-} from "./chunk-NCONW6WS.js";
-import "./chunk-2XF5BKV3.js";
-import "./chunk-SFL6LTP3.js";
-import "./chunk-PX7PBCCT.js";
+} from "./chunk-WD4CDGDZ.js";
+import "./chunk-EMSB2NVX.js";
+import "./chunk-6EX5KYT5.js";
+import "./chunk-TW7KYJQ6.js";
+import "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";
 
 // src/routes.ts

package/dist/sentry.d.ts

@@ -0,0 +1,25 @@
+import { R as RemoteError } from './errors-kjBv6IH_.js';
+
+/**
+ * Erros dos remotes no Sentry, sem depender do SDK:
+ *
+ *   import * as Sentry from '@sentry/browser'
+ *   import { sentryOnError } from 'vitral/sentry'
+ *
+ *   configure({ onError: sentryOnError(Sentry) })
+ *
+ * Cada `RemoteError` vira um `captureException` com as tags `vitral.remote`,
+ * `vitral.version` e `vitral.code`, e com `entry`, `route` e `docs` no `extra`.
+ */
+
+/** A parte do SDK do Sentry que o adaptador usa (`@sentry/browser`, `@sentry/react`…). */
+interface SentryLike {
+    captureException(exception: unknown, hint?: {
+        tags?: Record<string, string>;
+        extra?: Record<string, unknown>;
+    }): unknown;
+}
+/** `onError` para o `configure` que manda cada `RemoteError` ao Sentry. */
+declare function sentryOnError(sentry: SentryLike): (error: RemoteError) => void;
+
+export { type SentryLike, sentryOnError };

package/dist/sentry.js

@@ -0,0 +1,11 @@
+// src/sentry.ts
+function sentryOnError(sentry) {
+  return (error) => {
+    const tags = { "vitral.remote": error.remote, "vitral.code": error.code };
+    if (error.version) tags["vitral.version"] = error.version;
+    sentry.captureException(error, { tags, extra: { entry: error.entry, route: error.route, docs: error.docs } });
+  };
+}
+export {
+  sentryOnError
+};

package/dist/shadow-PVSETNMZ.js

@@ -0,0 +1,159 @@
+import {
+  fetchCssText,
+  injectCss
+} from "./chunk-6EX5KYT5.js";
+import "./chunk-TW7KYJQ6.js";
+import "./chunk-463H6B56.js";
+import "./chunk-GNPFWISJ.js";
+
+// src/core/shadow.ts
+var sheets = /* @__PURE__ */ new Map();
+var noop = () => {
+};
+var hoisted = /* @__PURE__ */ new Set();
+var RELATIVE_URL = /url\(\s*(['"]?)(?![a-z]+:|\/\/|#)([^'")]+)\1\s*\)/gi;
+var GLOBAL_RULES = /@property\s+(--[\w-]+)\s*\{[^}]*\}|@font-face\s*\{[^}]*\}|@import\s+(?:url\(\s*)?(?:(['"])(.*?)\2|([^'"\s);]+))\s*\)?[^;]*;/gi;
+function plan({ css, shadow: s }) {
+  const at = (u) => new URL(u, css[0]).href;
+  const ready = s ? s.css.map(at) : [];
+  return [s ? [...(s.imports ?? []).map(at), ...ready, ...css.slice(ready.length)] : css, ready, (s?.global ?? []).map(at)];
+}
+function prefetch(r, priority) {
+  const [urls, , global] = plan(r);
+  for (const u of urls) fetchCssText(u, r.sri?.[u], priority).catch(noop);
+  injectCss(global, null, r.sri);
+}
+async function attachShadowRoot(target, make, r, global = {}, local = {}) {
+  const name = make().getAttribute("data-vitral-root");
+  let registry = registryFor(name);
+  let root = target.shadowRoot;
+  if (!root && !fake(registry))
+    try {
+      root = target.attachShadow({ mode: "open", customElementRegistry: registry });
+    } catch {
+      broken = true;
+      registries.delete(name);
+      registry = registryFor(name);
+    }
+  root ??= target.attachShadow({ mode: "open" });
+  const own = root.customElementRegistry ?? registry;
+  let el = make();
+  if (!fake(own))
+    try {
+      el = make({ customElementRegistry: own });
+    } catch {
+    }
+  root.appendChild(el);
+  return [...await attachStyles(root, el, r, global, local), root, own, el];
+}
+var registries = /* @__PURE__ */ new Map();
+var broken = false;
+var fake = (registry) => Object.getPrototypeOf(registry) === customElements;
+var owners = /* @__PURE__ */ new Map();
+function registryFor(name) {
+  let registry = registries.get(name);
+  if (registry) return registry;
+  let real = customElements;
+  if (!broken && "initialize" in CustomElementRegistry.prototype)
+    try {
+      real = new CustomElementRegistry();
+    } catch {
+      broken = true;
+    }
+  const shared = real === customElements;
+  const own = registry = shared ? Object.create(real) : real;
+  if (shared) {
+    for (const k of ["get", "getName", "upgrade", "whenDefined"]) if (k in real) own[k] = real[k].bind(real);
+  }
+  const define = real.define;
+  own.define = (tag, ctor, options) => {
+    const had = real.get(tag);
+    const owner = owners.get(tag);
+    if (!had) return shared && owners.set(tag, name), define.call(real, tag, ctor, options);
+    if (shared && had !== ctor && owner !== name && dev())
+      console.warn(`[vitral] ${name}: <${tag}> j\xE1 foi definido por ${owner ?? "outro c\xF3digo"}; fica essa defini\xE7\xE3o. Sem Scoped Custom Element Registries, os remotes dividem o registro global.`);
+  };
+  registries.set(name, registry);
+  return registry;
+}
+function dev() {
+  try {
+    return process.env.NODE_ENV !== "production";
+  } catch {
+    return false;
+  }
+}
+async function attachStyles(root, el, r, global = {}, local = {}) {
+  const sri = r.sri ?? {};
+  const [css, ready, up] = plan(r);
+  const portal = el.cloneNode();
+  portal.setAttribute("data-vitral-portal", "");
+  el.after(portal);
+  const urls = [...global.inherit ?? [], ...local.inherit ?? []].map((u) => new URL(u, document.baseURI).href).concat(css);
+  const props = injectCss(up, null, sri);
+  if (typeof CSSStyleSheet !== "undefined" && "replaceSync" in CSSStyleSheet.prototype) {
+    const loaded = await Promise.all(urls.map((u) => loadSheet(u, [], sri[u], ready.includes(u) ? !!r.shadow.rebase : void 0)));
+    root.adoptedStyleSheets = [.../* @__PURE__ */ new Set([...root.adoptedStyleSheets, ...loaded.flat()])];
+  } else {
+    await injectCss(urls, root, sri);
+  }
+  await props;
+  const stop = (local.mirrorTheme ?? global.mirrorTheme) === false ? [] : [mirrorTheme(el), mirrorTheme(portal)];
+  return [() => (stop.forEach((fn) => fn()), portal.remove()), portal];
+}
+function loadSheet(href, chain, integrity, ready) {
+  let p = sheets.get(href);
+  if (!p) {
+    p = fetchCssText(href, integrity).then((text) => {
+      const sheet = new CSSStyleSheet();
+      if (ready !== false) text = text.replace(RELATIVE_URL, (_, q, u) => `url(${q}${new URL(u, href).href}${q})`);
+      if (ready != null) return sheet.replaceSync(text), [sheet];
+      const up = [];
+      const imports = [];
+      const rest = text.replace(GLOBAL_RULES, (rule, prop, _q, quoted, bare) => {
+        const url = quoted ?? bare;
+        if (url) imports.push(new URL(url, href).href);
+        else if (!hoisted.has(prop ?? rule)) {
+          hoisted.add(prop ?? rule);
+          up.push(rule);
+        }
+        return "";
+      });
+      if (up.length) {
+        const style = document.createElement("style");
+        style.setAttribute("data-vitral-properties", "");
+        style.textContent = up.join("\n");
+        document.head.appendChild(style);
+      }
+      sheet.replaceSync(rest);
+      const next = [...chain, href];
+      return Promise.all(imports.filter((u) => !next.includes(u)).map((u) => loadSheet(u, next))).then((found) => [...found.flat(), sheet]);
+    }).catch(() => {
+      sheets.delete(href);
+      return [];
+    });
+    sheets.set(href, p);
+  }
+  return p;
+}
+function mirrorTheme(el) {
+  const html = document.documentElement;
+  let added = [];
+  const sync = () => {
+    el.classList.remove(...added);
+    added = [...html.classList].filter((c) => !el.classList.contains(c));
+    el.classList.add(...added);
+    const theme = html.getAttribute("data-theme");
+    if (theme === null) el.removeAttribute("data-theme");
+    else el.setAttribute("data-theme", theme);
+  };
+  sync();
+  const observer = new MutationObserver(sync);
+  observer.observe(html, { attributeFilter: ["class", "data-theme"] });
+  return () => observer.disconnect();
+}
+export {
+  attachShadowRoot,
+  prefetch,
+  registryFor
+};

package/dist/single-spa.d.ts

@@ -0,0 +1,40 @@
+import { P as Props, a as RemoteModule } from './types-CA2p9KHC.js';
+import './errors-kjBv6IH_.js';
+
+/**
+ * App do single-spa como remote do vitral, sem reescrever o app:
+ *
+ *   // src/vitral-remote.js
+ *   import { singleSpaRemote } from 'vitral/single-spa'
+ *   import * as lifecycles from './main' // exporta bootstrap, mount e unmount
+ *
+ *   export default singleSpaRemote(lifecycles)
+ *
+ * Funciona com os lifecycles de `single-spa-react`, `single-spa-vue`,
+ * `single-spa-angular` etc. e com lifecycles escritos à mão. Os lifecycles
+ * recebem as props do host mais `name` e `domElement` (o elemento do remote).
+ */
+
+/** Um lifecycle do single-spa: uma função ou uma lista delas, em sequência. */
+type SingleSpaLifecycle = ((props: any) => unknown) | ((props: any) => unknown)[];
+/** O que um app ou parcel do single-spa exporta. */
+interface SingleSpaLifecycles {
+    bootstrap?: SingleSpaLifecycle;
+    mount: SingleSpaLifecycle;
+    unmount: SingleSpaLifecycle;
+    update?: SingleSpaLifecycle;
+}
+/**
+ * Embrulha os lifecycles de um app do single-spa no contrato `mount`.
+ *
+ * - `bootstrap` roda uma vez, antes do primeiro `mount`.
+ * - Os lifecycles nunca se sobrepõem: um `mount` espera o `unmount` anterior.
+ * - `update(props)` chama o `update` do app (parcels); sem ele, o app é
+ *   desmontado e montado de novo com as props novas.
+ * - Duas instâncias ao mesmo tempo recebem `name` diferentes (`conta`, `conta-2`).
+ */
+declare function singleSpaRemote<P extends Props = Props>(lifecycles: SingleSpaLifecycles | {
+    default: SingleSpaLifecycles;
+}): RemoteModule<P>;
+
+export { type SingleSpaLifecycle, type SingleSpaLifecycles, singleSpaRemote };