vitral 0.3.0 → 0.5.0

package/dist/federation.js

@@ -0,0 +1,101 @@
+// src/federation.ts
+var containers = /* @__PURE__ */ new Map();
+var fail = (msg) => new Error(`[vitral] ${msg}`);
+var key = (k) => "./" + k.replace(/^\.?\/?/, "");
+function federationRemote(url, options = {}) {
+  return { module: () => namespace(url, options) };
+}
+async function namespace(url, options) {
+  const { container, keys } = await loadContainer(new URL(url, document.baseURI).href, options);
+  const parts = /* @__PURE__ */ new Map();
+  const part = (k) => {
+    let p = parts.get(k);
+    if (!p) {
+      p = Promise.resolve(container.get(k)).then((factory) => adapted(factory(), k, options));
+      p.catch(() => parts.delete(k));
+      parts.set(k, p);
+    }
+    return p;
+  };
+  const exposes = keys ? Object.fromEntries(keys.map((k) => [k, () => part(k)])) : new Proxy({}, { get: (_, k) => typeof k == "string" && k.startsWith("./") ? () => part(k) : void 0 });
+  const main = options.expose ? key(options.expose) : keys?.length === 1 ? keys[0] : void 0;
+  const remote = {
+    async mount(el, props, ctx) {
+      if (!main) throw fail(`${ctx.name}: o manifesto exp\xF5e ${keys?.join(", ") || "v\xE1rias partes"}. Use ${ctx.name}/<parte> ou a op\xE7\xE3o expose.`);
+      const ns = await part(main);
+      const target = typeof ns?.mount == "function" ? ns : ns?.default;
+      if (typeof target?.mount != "function") throw fail(`${ctx.name}: ${main} n\xE3o exporta mount(). Use a op\xE7\xE3o adapt de federationRemote.`);
+      return target.mount(el, props, ctx);
+    }
+  };
+  return { default: remote, exposes };
+}
+function adapted(ns, k, options) {
+  if (typeof ns?.mount == "function" || typeof ns?.default?.mount == "function" || !options.adapt) return ns;
+  const remote = options.adapt(ns, k);
+  return typeof remote?.mount == "function" ? { ...ns, default: remote } : ns;
+}
+function loadContainer(url, options = {}) {
+  let job = containers.get(url);
+  if (!job) {
+    job = start(url, options);
+    job.catch(() => containers.delete(url));
+    containers.set(url, job);
+  }
+  return job;
+}
+async function start(url, options) {
+  let entry = url;
+  let global = options.global;
+  let keys = null;
+  if (new URL(url).pathname.endsWith(".json")) {
+    const res = await fetch(url, { cache: "no-cache" });
+    if (!res.ok) throw fail(`HTTP ${res.status} ao baixar ${url}`);
+    const m = await res.json();
+    const re = m.metaData?.remoteEntry;
+    if (!re?.name) throw fail(`${url} n\xE3o \xE9 um mf-manifest.json (falta metaData.remoteEntry)`);
+    const pub = m.metaData.publicPath;
+    if ((!pub || pub === "auto") && m.metaData.getPublicPath) throw fail(`${url}: getPublicPath n\xE3o \xE9 suportado. Use publicPath.`);
+    const base = pub && pub !== "auto" ? new URL(pub, url).href : url;
+    entry = new URL((re.path ? re.path.replace(/\/?$/, "/") : "") + re.name, base).href;
+    global = re.type === "module" || re.type === "esm" ? void 0 : m.metaData.globalName ?? m.name;
+    if (re.type !== "module" && re.type !== "esm" && !global) throw fail(`${url}: falta metaData.globalName`);
+    keys = (m.exposes ?? []).map((e) => key(e.path));
+  }
+  const origin = new URL(entry).origin;
+  const allowed = [new URL(url).origin, ...options.allowedOrigins ?? []];
+  if (!allowed.includes("*") && !allowed.includes(origin)) throw fail(`remoteEntry em ${origin} n\xE3o est\xE1 em allowedOrigins`);
+  const container = global ? await script(entry, global) : await import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    entry
+  );
+  if (typeof container?.get != "function" || typeof container.init != "function") throw fail(`${entry} n\xE3o \xE9 um container do Module Federation (sem get/init)`);
+  await container.init(shareScope(options.shared));
+  return { container, keys };
+}
+function shareScope(shared = {}) {
+  const out = {};
+  for (const { version, modules } of Object.values(shared)) {
+    for (const [spec, mod] of Object.entries(modules)) (out[spec] ??= {})[version] = { get: () => Promise.resolve(() => mod), loaded: 1, from: "vitral" };
+  }
+  return out;
+}
+function script(src, global) {
+  const w = window;
+  if (w[global]) return Promise.resolve(w[global]);
+  return new Promise((resolve, reject) => {
+    const s = document.createElement("script");
+    s.src = src;
+    s.onload = () => w[global] ? resolve(w[global]) : reject(fail(`${src} n\xE3o criou window.${global}`));
+    s.onerror = () => {
+      s.remove();
+      reject(fail(`falha ao carregar ${src}`));
+    };
+    document.head.appendChild(s);
+  });
+}
+export {
+  federationRemote,
+  shareScope
+};

package/dist/hydrate-YVZDJ2V7.js

@@ -0,0 +1,168 @@
+import {
+  hostSlot
+} from "./chunk-4Z77XNBR.js";
+import {
+  mountOnce,
+  navigate,
+  refreshable,
+  registered,
+  scopedEvents,
+  track
+} from "./chunk-KZBH5MPD.js";
+import {
+  load
+} from "./chunk-5JNV45BB.js";
+import {
+  injectStyles
+} from "./chunk-KU6HF2EW.js";
+import {
+  metric
+} from "./chunk-TW7KYJQ6.js";
+import {
+  RemoteError,
+  ctxHooks,
+  isRemoteError,
+  report
+} from "./chunk-463H6B56.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/hydrate.ts
+function hydrateSlot(target, holder, options) {
+  const name = options.name ?? "";
+  let props = options.props ?? {};
+  let handle = null;
+  let inner = null;
+  let status = "loading";
+  let dead = false;
+  const setStatus = (s, e = null) => {
+    status = s;
+    options.onStatus?.(s, e);
+  };
+  const fallback = (next = {}) => {
+    handle?.unmount();
+    handle = null;
+    inner = hostSlot(target, {
+      ...options,
+      ...next,
+      props,
+      onStatus(s, e) {
+        if (s !== "loading") holder.remove();
+        if (s !== "loading" || !holder.isConnected) setStatus(s, e);
+      }
+    });
+  };
+  const initial = props;
+  hydrateRemote(holder, name, props, options).then(
+    (h) => {
+      if (dead) return h?.unmount();
+      if (!h) return fallback();
+      handle = h;
+      if (props !== initial) h.update?.(props);
+      setStatus("ready");
+    },
+    (e) => {
+      if (dead) return;
+      holder.remove();
+      setStatus("error", isRemoteError(e) ? e : new RemoteError("MOUNT_FAILED", name, String(e), e));
+    }
+  );
+  return {
+    update(next) {
+      props = next;
+      (inner ?? handle)?.update?.(next);
+    },
+    set(next) {
+      if (inner) return inner.set(next);
+      const changed = next.name !== void 0 && next.name !== name || "isolate" in next && next.isolate !== options.isolate;
+      if (changed) holder.remove(), fallback(next);
+    },
+    retry() {
+      if (inner) return inner.retry();
+      holder.remove();
+      fallback();
+    },
+    destroy() {
+      dead = true;
+      inner?.destroy();
+      handle?.unmount();
+      holder.remove();
+    },
+    get status() {
+      return inner?.status ?? status;
+    }
+  };
+}
+async function hydrateRemote(holder, name, props, options) {
+  const p = protocol();
+  await p.pending();
+  const isolate = options.isolate ?? registered(name)?.isolate ?? p.settings().isolate;
+  if (isolate === "iframe") return null;
+  const { module: mod, ...resolved } = await load(name, isolate, options.priority);
+  const shadow = isolate === "shadow";
+  const el = [...(shadow ? holder.shadowRoot : holder)?.children ?? []].find((c) => c.hasAttribute("data-vitral-root"));
+  if (typeof mod.hydrate !== "function" || !el) return null;
+  const untrack = track(name, resolved);
+  ctxHooks.watch?.(name);
+  const label = resolved.name ?? name;
+  let t = performance.now();
+  const [release, portal = document.body, shadowRoot = null, registry = customElements] = await injectStyles(resolved, shadow && holder, () => el, options.styles);
+  if (shadowRoot?.adoptedStyleSheets.length) for (const s of shadowRoot.querySelectorAll("style[data-vitral-ssr]")) s.remove();
+  metric(name, "css", t);
+  t = performance.now();
+  const scoped = scopedEvents();
+  const on = (type) => (fn) => (el.addEventListener(type, fn), () => el.removeEventListener(type, fn));
+  const ctx = {
+    name: label,
+    baseUrl: new URL(".", resolved.entry).href,
+    events: scoped.bus,
+    shadowRoot,
+    portalContainer: portal,
+    customElements: registry,
+    reportError(e) {
+      const err = report(isRemoteError(e) ? e : new RemoteError("RENDER_FAILED", label, String(e?.message ?? e), e), resolved);
+      if (options.onError) options.onError(err);
+      else console.error(err);
+    },
+    navigate,
+    protocol: p.protocol,
+    onActivate: on("vitral:activate"),
+    onDeactivate: on("vitral:deactivate")
+  };
+  if (ctxHooks.shared) ctx.shared = ctxHooks.shared(name, scoped.track);
+  let mounted;
+  try {
+    mounted = await mod.hydrate(el, props, ctx);
+    metric(name, "mount", t);
+  } catch (e) {
+    untrack();
+    scoped.dispose();
+    release();
+    el.remove();
+    throw report(new RemoteError("MOUNT_FAILED", label, "erro ao hidratar", e), resolved);
+  }
+  let alive = true;
+  const current = {
+    update(next) {
+      if (alive) mounted.update?.(next);
+    },
+    unmount() {
+      if (!alive) return;
+      alive = false;
+      try {
+        mounted.unmount();
+      } finally {
+        untrack();
+        scoped.dispose();
+        release();
+        el.remove();
+      }
+    }
+  };
+  return refreshable(current, name, props, (latest) => mountOnce(holder, name, latest, options));
+}
+export {
+  hydrateRemote,
+  hydrateSlot
+};

package/dist/iframe.js

@@ -1,28 +1,28 @@
 import {
   splitName
-} from "./chunk-SDB5AZEI.js";
+} from "./chunk-C3QOBAUE.js";
 import {
   verifyIntegrity
-} from "./chunk-AH7KNMBW.js";
+} from "./chunk-UYOPJ4XQ.js";
 import {
   events,
   navigate,
   setFrameMounter,
   track
-} from "./chunk-I3VSKSAZ.js";
+} from "./chunk-KZBH5MPD.js";
 import {
   resolveEntry
-} from "./chunk-TD4S3IHA.js";
-import "./chunk-ZAC6QQI6.js";
+} from "./chunk-5JNV45BB.js";
+import "./chunk-KU6HF2EW.js";
 import {
   fetchBytes,
   withRetry,
   withTimeout
-} from "./chunk-GNHCZRQP.js";
+} from "./chunk-TW7KYJQ6.js";
 import {
   RemoteError,
   report
-} from "./chunk-AKNNHQ2H.js";
+} from "./chunk-463H6B56.js";
 import {
   protocol
 } from "./chunk-GNPFWISJ.js";

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-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 { 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-DUtcF3HO.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-DUtcF3HO.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 { R as RemoteSlot, a as SlotOptions, S as SlotStatus, c as createSlot } from './slot-D49L1rdU.js';
+export { e as events } from './events-0rxFlWJJ.js';
 export { n as navigate } from './navigate-BRG1WJUM.js';
 export { r as __reset } from './state-BDdCwc21.js';
 

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   syncTabs,
   unsafeHTML,
   watchUpdates
-} from "./chunk-I3VSKSAZ.js";
+} from "./chunk-KZBH5MPD.js";
 import {
   configure,
   loadModule,
@@ -25,12 +25,12 @@ import {
   preload,
   register,
   registerSrc
-} from "./chunk-TD4S3IHA.js";
-import "./chunk-ZAC6QQI6.js";
-import "./chunk-GNHCZRQP.js";
+} from "./chunk-5JNV45BB.js";
+import "./chunk-KU6HF2EW.js";
+import "./chunk-TW7KYJQ6.js";
 import {
   RemoteError
-} from "./chunk-AKNNHQ2H.js";
+} from "./chunk-463H6B56.js";
 import {
   createEventBus,
   resetProtocol

package/dist/otel.d.ts

@@ -40,5 +40,33 @@ interface OtelOptions {
 }
 /** `onError` para o `configure` que registra cada `RemoteError` no OpenTelemetry. */
 declare function otelOnError({ trace, tracer }: OtelOptions): (error: RemoteError) => void;
+/** A parte de um `Meter` de `@opentelemetry/api` que `otelVitals` usa. */
+interface MeterLike {
+    createHistogram(name: string, options?: {
+        unit?: string;
+        description?: string;
+    }): {
+        record(value: number, attributes?: Attributes): void;
+    };
+}
+/**
+ * `onReport` para o `vitals()` de `vitral/vitals` que grava cada Web Vital
+ * num histograma `vitral.vitals.<lcp|cls|inp|fcp|ttfb>`:
+ *
+ *   import { metrics } from '@opentelemetry/api'
+ *   vitals({ onReport: otelVitals(metrics.getMeter('host')) })
+ *
+ * Atributos: `vitral.remote`, `vitral.version`, `vitral.route`,
+ * `vitral.navigation_id` e `vitral.rating`. Os ausentes ficam de fora.
+ */
+declare function otelVitals(meter: MeterLike): (report: {
+    name: string;
+    remote?: string;
+    version?: string;
+    route: string;
+    navigationId?: string;
+    value: number;
+    rating: string;
+}) => void;
 
-export { type Attributes, type OtelOptions, type SpanLike, otelOnError };
+export { type Attributes, type MeterLike, type OtelOptions, type SpanLike, otelOnError, otelVitals };

package/dist/otel.js

@@ -22,6 +22,18 @@ function otelOnError({ trace, tracer }) {
     span.end();
   };
 }
+function otelVitals(meter) {
+  const histograms = {};
+  return (r) => {
+    const attributes = { "vitral.route": r.route, "vitral.rating": r.rating };
+    if (r.remote) attributes["vitral.remote"] = r.remote;
+    if (r.version) attributes["vitral.version"] = r.version;
+    if (r.navigationId) attributes["vitral.navigation_id"] = r.navigationId;
+    const name = r.name.toLowerCase();
+    (histograms[name] ??= meter.createHistogram("vitral.vitals." + name, { unit: name == "cls" ? "1" : "ms" })).record(r.value, attributes);
+  };
+}
 export {
-  otelOnError
+  otelOnError,
+  otelVitals
 };

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-Czvm-siZ.js';
-export { R as RemoteContext } from './types-Czvm-siZ.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';
-import { S as SlotStatus } from './slot-DqXTwGbs.js';
-export { e as events } from './events-D5gs7rff.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/preact.js

@@ -1,6 +1,6 @@
 import {
   hostSlot
-} from "./chunk-IHTUM6LT.js";
+} from "./chunk-4Z77XNBR.js";
 import {
   defineRemote,
   events,
@@ -8,11 +8,11 @@ import {
   navigate,
   same,
   shared
-} from "./chunk-I3VSKSAZ.js";
-import "./chunk-TD4S3IHA.js";
-import "./chunk-ZAC6QQI6.js";
-import "./chunk-GNHCZRQP.js";
-import "./chunk-AKNNHQ2H.js";
+} from "./chunk-KZBH5MPD.js";
+import "./chunk-5JNV45BB.js";
+import "./chunk-KU6HF2EW.js";
+import "./chunk-TW7KYJQ6.js";
+import "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";
 
 // src/preact.ts

package/dist/prefetch.d.ts

@@ -0,0 +1,25 @@
+interface PrefetchOptions {
+    /** Probabilidade mínima da rota seguinte para baixar os remotes dela. Padrão: 0.4. */
+    threshold?: number;
+    /** Transições contadas a partir da rota atual antes de prever. Padrão: 2. */
+    min?: number;
+    /** Onde guardar as contagens. `null` guarda só na memória. Padrão: localStorage. */
+    storage?: Pick<Storage, 'getItem' | 'setItem'> | null;
+    /** Chave da rota. Padrão: `url.pathname`. */
+    key?: (url: URL) => string;
+    /** Chamado depois de baixar os remotes previstos. */
+    onPrefetch?: (remotes: string[], route: string) => void;
+}
+/**
+ * Começa a aprender as rotas e a pré-carregar o próximo remote. Devolve a
+ * função que para tudo (as contagens continuam guardadas).
+ */
+declare function prefetch(options?: PrefetchOptions): () => void;
+/**
+ * Baixa o manifesto e os arquivos de um remote sem executar nada. Com
+ * integrity, pelo mesmo caminho de SRI que a montagem vai usar. Devolve
+ * false se o remote não pôde ser pré-carregado (sem erro no console).
+ */
+declare function warm(name: string): Promise<boolean>;
+
+export { type PrefetchOptions, prefetch, warm };

package/dist/prefetch.js

@@ -0,0 +1,178 @@
+import {
+  resolveEntry
+} from "./chunk-5JNV45BB.js";
+import "./chunk-KU6HF2EW.js";
+import {
+  addLink
+} from "./chunk-TW7KYJQ6.js";
+import "./chunk-463H6B56.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/markov.ts
+var LIMITS = { routes: 50, next: 10, remotes: 8, total: 1e3, key: 200 };
+var ok = (k) => typeof k === "string" && k.length <= LIMITS.key && k !== "__proto__";
+var sum = (row) => Object.values(row).reduce((a, b) => a + b, 0);
+var smallest = (o, keep) => Object.keys(o).filter((k) => k !== keep).reduce((min, k) => min === void 0 || o[k] < o[min] ? k : min, void 0);
+var empty = () => ({ t: {}, r: {} });
+function parse(text) {
+  try {
+    const c = JSON.parse(text ?? "");
+    const rows = Object.values(c.t).every((row) => row && typeof row === "object" && Object.values(row).every((n) => Number.isFinite(n)));
+    const lists = Object.values(c.r).every((l) => Array.isArray(l) && l.every((n) => typeof n === "string"));
+    if (rows && lists) return c;
+  } catch {
+  }
+  return empty();
+}
+function record(c, from, to) {
+  if (from === to || !ok(from) || !ok(to)) return;
+  const row = c.t[from] ??= {};
+  row[to] = (row[to] ?? 0) + 1;
+  if (sum(row) > LIMITS.total) {
+    for (const k in row) if (!(row[k] >>= 1)) delete row[k];
+  }
+  if (Object.keys(row).length > LIMITS.next) delete row[smallest(row, to)];
+  if (Object.keys(c.t).length > LIMITS.routes) {
+    const totals = Object.fromEntries(Object.entries(c.t).map(([k, v]) => [k, sum(v)]));
+    delete c.t[smallest(totals, from)];
+  }
+}
+function remember(c, route, remote) {
+  if (!ok(route)) return false;
+  const list = c.r[route] ??= [];
+  if (list.includes(remote)) return false;
+  list.push(remote);
+  if (list.length > LIMITS.remotes) list.shift();
+  const routes = Object.keys(c.r);
+  if (routes.length > LIMITS.routes) delete c.r[routes.find((k) => k !== route)];
+  return true;
+}
+function predict(c, from, threshold, min = 1) {
+  const row = Object.prototype.hasOwnProperty.call(c.t, from) ? c.t[from] : void 0;
+  if (!row) return null;
+  const total = sum(row);
+  let best = null;
+  for (const k in row) if (best === null || row[k] > row[best]) best = k;
+  return best !== null && total >= min && row[best] / total >= threshold ? best : null;
+}
+
+// src/prefetch.ts
+var KEY = "vitral:prefetch";
+function slow() {
+  const c = navigator.connection;
+  return !!c?.saveData || /2g/.test(c?.effectiveType ?? "");
+}
+var idle = (fn) => typeof requestIdleCallback === "function" ? requestIdleCallback(fn, { timeout: 3e3 }) : setTimeout(fn, 300);
+function prefetch(options = {}) {
+  if (typeof window === "undefined") return () => {
+  };
+  const { threshold = 0.4, min = 2, key = (u) => u.pathname, onPrefetch } = options;
+  let storage = options.storage;
+  if (storage === void 0)
+    try {
+      storage = localStorage;
+    } catch {
+      storage = null;
+    }
+  let chain = empty();
+  try {
+    chain = parse(storage?.getItem(KEY));
+  } catch {
+  }
+  const save = () => {
+    try {
+      storage?.setItem(KEY, JSON.stringify(chain));
+    } catch {
+    }
+  };
+  const here = () => key(new URL(location.href));
+  let current = here();
+  const loaded = /* @__PURE__ */ new Set();
+  let seq = 0;
+  const schedule = () => {
+    const id = ++seq;
+    if (slow()) return;
+    idle(() => {
+      const next = id === seq && predict(chain, current, threshold, min);
+      if (!next) return;
+      const names = (chain.r[next] ?? []).filter((n) => !loaded.has(n));
+      if (!names.length) return;
+      for (const n of names) loaded.add(n);
+      Promise.all(names.map(warm)).then((ok2) => {
+        const done = names.filter((_, i) => ok2[i]);
+        if (done.length) onPrefetch?.(done, next);
+      });
+    });
+  };
+  const visit = () => {
+    const next = here();
+    if (next === current) return;
+    record(chain, current, next);
+    current = next;
+    save();
+    schedule();
+  };
+  let observer;
+  try {
+    observer = new PerformanceObserver((list) => {
+      visit();
+      let changed = false;
+      for (const e of list.getEntries()) {
+        const m = /^vitral:(.+):mount$/.exec(e.name);
+        if (!m) continue;
+        loaded.add(m[1]);
+        changed = remember(chain, current, m[1]) || changed;
+      }
+      if (changed) save();
+    });
+    observer.observe({ type: "measure", buffered: true });
+  } catch {
+  }
+  const nav = globalThis.navigation;
+  const event = nav ? "currententrychange" : "popstate";
+  const target = nav ?? window;
+  target.addEventListener(event, visit);
+  schedule();
+  return () => {
+    seq++;
+    observer?.disconnect();
+    target.removeEventListener(event, visit);
+  };
+}
+var heat = (u) => fetch(u, { priority: "low" }).then((res) => res.arrayBuffer());
+function modulepreload(href) {
+  return new Promise((resolve, reject) => {
+    const link = addLink("modulepreload", href, { fetchPriority: "low" });
+    link.onload = resolve;
+    link.onerror = reject;
+  });
+}
+async function verifiedOnly(r) {
+  const b = r.split ?? { entry: r.entry, chunks: [], sri: { [r.entry]: r.integrity }, priority: "low" };
+  const { verified } = await import("./sri-576GTDIA.js");
+  const url = await verified(b);
+  if (!url) await Promise.all([...b.chunks, b.entry].map(heat));
+  else if (!document.querySelector(`link[rel=modulepreload][href="${CSS.escape(url)}"]`)) await heat(url);
+}
+async function warm(name) {
+  try {
+    const p = protocol();
+    await p.pending();
+    let n = name;
+    while (n && !p.entry(n)) n = n.slice(0, Math.max(0, n.lastIndexOf("/")));
+    const entry = p.entry(n);
+    if (!entry?.url || (entry.isolate ?? p.settings().isolate) === "iframe") return false;
+    const r = await resolveEntry(n, entry, "low");
+    const css = r.css.map(heat);
+    await Promise.all([r.integrity ? verifiedOnly(r) : modulepreload(r.entry), ...css]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export {
+  prefetch,
+  warm
+};