vitral 0.3.0 → 0.5.0

package/dist/react.d.ts

@@ -1,9 +1,9 @@
 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-Czvm-siZ.js';
-export { E as EventBus } from './types-Czvm-siZ.js';
-export { e as events } from './events-D5gs7rff.js';
+import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared, R as RemoteContext } from './types-DUtcF3HO.js';
+export { E as EventBus } from './types-DUtcF3HO.js';
+export { e as events } from './events-0rxFlWJJ.js';
 import './errors-kjBv6IH_.js';
 
 /**

package/dist/react.js

@@ -1,18 +1,18 @@
 "use client";
 import {
   hostSlot
-} from "./chunk-IHTUM6LT.js";
+} from "./chunk-4Z77XNBR.js";
 import {
   defineRemote,
   events,
   memoSelect,
   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 {
   protocol
 } from "./chunk-GNPFWISJ.js";

package/dist/reframe-LQL4DZYP.js

@@ -0,0 +1,251 @@
+import {
+  splitName
+} from "./chunk-C3QOBAUE.js";
+import {
+  verifyIntegrity
+} from "./chunk-UYOPJ4XQ.js";
+import {
+  resolveEntry
+} from "./chunk-5JNV45BB.js";
+import {
+  prefetchCss
+} from "./chunk-KU6HF2EW.js";
+import {
+  fetchBytes,
+  metric,
+  withRetry,
+  withTimeout
+} from "./chunk-TW7KYJQ6.js";
+import {
+  RemoteError,
+  isRemoteError,
+  report
+} from "./chunk-463H6B56.js";
+import {
+  protocol
+} from "./chunk-GNPFWISJ.js";
+
+// src/core/reframe.ts
+var REFRAME_SCRIPT = "window.__vitral=function(u){return import(u)}";
+var OWN = /^(popstate|hashchange|message|messageerror|error|unhandledrejection|rejectionhandled)$/;
+var VIEW = ["innerWidth", "innerHeight", "outerWidth", "outerHeight", "devicePixelRatio", "scrollX", "scrollY", "pageXOffset", "pageYOffset", "screenX", "screenY", "visualViewport"];
+var VIEW_FNS = ["matchMedia", "scrollTo", "scroll", "scrollBy", "getComputedStyle", "getSelection"];
+var DOC_FNS = ["createElementNS", "createTextNode", "createComment", "createDocumentFragment", "createEvent", "createRange", "createTreeWalker", "createNodeIterator", "createAttribute", "importNode", "adoptNode", "getSelection"];
+var set = (o, values) => {
+  for (const k in values) Object.defineProperty(o, k, { configurable: true, writable: true, value: values[k] });
+};
+var get = (o, getters) => {
+  for (const k in getters) Object.defineProperty(o, k, { configurable: true, get: getters[k] });
+};
+async function load(name, _isolate, priority) {
+  const p = protocol();
+  const { timeout, retries } = p.settings();
+  const [remote, key] = splitName(name);
+  let resolved;
+  let realm;
+  try {
+    const entry = p.entry(remote);
+    if (!entry) throw new RemoteError("NOT_REGISTERED", name, "remote n\xE3o registrado. Use configure({ remotes }).");
+    if (!entry.url) throw new RemoteError("MOUNT_FAILED", name, "remote local (module) n\xE3o roda com isolate: 'reframe': registre a URL dele");
+    let t = performance.now();
+    const { integrity, ...r } = await resolveEntry(remote, entry, priority);
+    delete r.split;
+    resolved = r;
+    metric(name, "manifest", t);
+    prefetchCss(r, true, priority);
+    t = performance.now();
+    const bytes = integrity && await withRetry(retries, async () => {
+      const b = await fetchBytes(r.entry, timeout, name, { priority });
+      await verifyIntegrity(name, b, integrity);
+      return b;
+    });
+    const url = bytes ? URL.createObjectURL(new Blob([bytes], { type: "text/javascript" })) : r.entry;
+    const { registryFor } = await import("./shadow-S4SKHTA7.js");
+    realm = createRealm(r.name ?? name, registryFor(r.name ?? name));
+    let ns;
+    try {
+      ns = await withTimeout(timeout, name, realm.load(url));
+    } catch (e) {
+      throw isRemoteError(e) ? e : new RemoteError("LOAD_FAILED", name, `falha ao importar ${r.entry}`, e);
+    } finally {
+      if (bytes) URL.revokeObjectURL(url);
+    }
+    if (key) {
+      const part = ns?.exposes?.[key];
+      if (!part) throw new RemoteError("NOT_EXPOSED", name, `${remote} n\xE3o exp\xF5e ${key}`);
+      ns = typeof part === "function" ? await part() : part;
+    }
+    const mod = ns?.default ?? ns;
+    if (typeof mod?.mount != "function") throw new RemoteError("INVALID_MODULE", name, "o m\xF3dulo n\xE3o exporta mount()");
+    metric(name, "js", t);
+    const own = realm;
+    return { ...r, module: { mount: (el, props, ctx) => own.mount(mod, el, props, ctx) } };
+  } catch (e) {
+    realm?.dispose();
+    throw report(isRemoteError(e) ? e : new RemoteError("LOAD_FAILED", name, String(e?.message ?? e), e), resolved);
+  }
+}
+function noFrames(_target, name) {
+  return Promise.reject(new RemoteError("MOUNT_FAILED", name, 'isolate="iframe" precisa de enableIframe(), de vitral/iframe'));
+}
+function createRealm(name, registry) {
+  const host = document;
+  const frame = host.createElement("iframe");
+  frame.setAttribute("data-vitral-reframe", name);
+  frame.setAttribute("aria-hidden", "true");
+  frame.tabIndex = -1;
+  frame.style.display = "none";
+  host.body.appendChild(frame);
+  const w = frame.contentWindow;
+  const d = w.document;
+  d.open();
+  d.close();
+  const realHead = d.head;
+  const inFrame = d.createElement.bind(d);
+  const script = d.createElement("script");
+  script.nonce = host.querySelector("script[nonce]")?.nonce ?? "";
+  script.textContent = REFRAME_SCRIPT;
+  realHead.appendChild(script);
+  const load2 = w.__vitral;
+  delete w.__vitral;
+  const head = host.createElement("div");
+  head.setAttribute("data-vitral-head", "");
+  head.hidden = true;
+  let root = null;
+  let body = head;
+  let ctx = null;
+  const scope = () => root ?? head;
+  const ctrl = new AbortController();
+  const listen = (target, own) => {
+    const add = own?.addEventListener;
+    const remove = own?.removeEventListener;
+    return {
+      addEventListener(type, fn, o) {
+        if (own && OWN.test(type)) return add.call(own, type, fn, o);
+        const opts = typeof o == "object" ? o : { capture: !!o };
+        const signal = opts.signal && AbortSignal.any ? AbortSignal.any([opts.signal, ctrl.signal]) : ctrl.signal;
+        target.addEventListener(type, fn, { ...opts, signal });
+      },
+      removeEventListener(type, fn, o) {
+        if (own && OWN.test(type)) return remove.call(own, type, fn, o);
+        target.removeEventListener(type, fn, o);
+      }
+    };
+  };
+  const scoped = Object.getPrototypeOf(registry) !== customElements;
+  const createElement = (tag, o) => {
+    if (/^script$/i.test(tag)) return inFrame(tag);
+    if (scoped && !o?.customElementRegistry)
+      try {
+        return host.createElement(tag, { ...o, customElementRegistry: registry });
+      } catch {
+      }
+    return host.createElement(tag, o);
+  };
+  const fromHost = {};
+  for (const k of DOC_FNS) fromHost[k] = host[k].bind(host);
+  set(d, {
+    ...fromHost,
+    ...listen(host, null),
+    createElement,
+    querySelector: (s) => scope().querySelector(s),
+    querySelectorAll: (s) => scope().querySelectorAll(s),
+    getElementById: (id) => scope().querySelector(`#${CSS.escape(id)}`),
+    getElementsByClassName: (c) => scope().querySelectorAll(c.trim().split(/\s+/).map((x) => "." + CSS.escape(x)).join("")),
+    getElementsByTagName: (t) => scope().querySelectorAll(t),
+    getElementsByName: (n) => scope().querySelectorAll(`[name="${CSS.escape(n)}"]`),
+    elementFromPoint: (x, y) => (root ?? host).elementFromPoint(x, y),
+    elementsFromPoint: (x, y) => (root ?? host).elementsFromPoint(x, y)
+  });
+  get(d, {
+    head: () => head,
+    body: () => body,
+    documentElement: () => host.documentElement,
+    activeElement: () => root?.activeElement ?? host.body
+  });
+  const redirect = (el) => {
+    const append = el.appendChild;
+    const before = el.insertBefore;
+    set(el, {
+      appendChild: (n) => n.nodeName == "SCRIPT" ? realHead.appendChild(n) : append.call(el, n),
+      insertBefore: (n, ref) => n.nodeName == "SCRIPT" ? realHead.appendChild(n) : before.call(el, n, ref)
+    });
+  };
+  redirect(head);
+  const view = {};
+  for (const k of VIEW) view[k] = () => window[k];
+  get(w, view);
+  const viewFns = {};
+  for (const k of VIEW_FNS) viewFns[k] = window[k].bind(window);
+  set(w, { ...viewFns, ...listen(window, w), HTMLElement, customElements: registry });
+  w.addEventListener("error", (e) => ctx?.reportError(e.error ?? e.message));
+  w.addEventListener("unhandledrejection", (e) => ctx?.reportError(e.reason));
+  const h = w.history;
+  const push = h.pushState;
+  const replace = h.replaceState;
+  const go = (fn, method) => (state, title, url) => {
+    fn.call(h, state, title, url);
+    const href = w.location.href;
+    if (href === location.href) return;
+    history[method](state, "", href);
+    dispatchEvent(new PopStateEvent("popstate", { state }));
+    protocol().events.emit("vitral:navigate", location.pathname + location.search + location.hash);
+  };
+  set(h, { pushState: go(push, "pushState"), replaceState: go(replace, "replaceState") });
+  const pull = () => {
+    const old = w.location.href;
+    if (old === location.href) return;
+    try {
+      replace.call(h, history.state, "", location.href);
+    } catch {
+      return;
+    }
+    w.dispatchEvent(new w.PopStateEvent("popstate", { state: history.state }));
+    if (old.split("#")[1] !== location.href.split("#")[1]) w.dispatchEvent(new w.HashChangeEvent("hashchange", { oldURL: old, newURL: location.href }));
+  };
+  addEventListener("popstate", pull, { signal: ctrl.signal });
+  globalThis.navigation?.addEventListener("currententrychange", pull, { signal: ctrl.signal });
+  const dispose = () => {
+    ctx = null;
+    ctrl.abort();
+    head.remove();
+    frame.remove();
+  };
+  return {
+    load: (url) => {
+      if (!load2) throw new RemoteError("LOAD_FAILED", name, "a CSP bloqueou o script do iframe do isolate: 'reframe' (libere o hash de REFRAME_SCRIPT ou use nonce)");
+      return load2(url);
+    },
+    async mount(mod, el, props, c) {
+      ctx = c;
+      root = c.shadowRoot;
+      if (root) root.prepend(head);
+      body = c.portalContainer ?? el;
+      if (body !== head) redirect(body);
+      pull();
+      let handle;
+      try {
+        handle = await mod.mount(el, props, c);
+      } catch (e) {
+        dispose();
+        throw e;
+      }
+      return {
+        update: (next) => handle.update?.(next),
+        unmount() {
+          try {
+            handle.unmount();
+          } finally {
+            dispose();
+          }
+        }
+      };
+    },
+    dispose
+  };
+}
+export {
+  REFRAME_SCRIPT,
+  load,
+  noFrames
+};

package/dist/routes.d.ts

@@ -1,5 +1,5 @@
-import { P as Props } from './types-Czvm-siZ.js';
-import { S as SlotStatus } from './slot-DqXTwGbs.js';
+import { P as Props } from './types-DUtcF3HO.js';
+import { S as SlotStatus } from './slot-D49L1rdU.js';
 import './errors-kjBv6IH_.js';
 
 /** Padrão de URL → nome do remote. A primeira rota que bate vence. */

package/dist/routes.js

@@ -1,11 +1,11 @@
 import {
   createSlot,
   navigate
-} 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/routes.ts

package/dist/{shadow-6HELCHCJ.js → shadow-S4SKHTA7.js}

@@ -1,9 +1,9 @@
 import {
   fetchCssText,
   injectCss
-} from "./chunk-ZAC6QQI6.js";
-import "./chunk-GNHCZRQP.js";
-import "./chunk-AKNNHQ2H.js";
+} from "./chunk-KU6HF2EW.js";
+import "./chunk-TW7KYJQ6.js";
+import "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";
 
 // src/core/shadow.ts
@@ -23,6 +23,66 @@ function prefetch(r, priority) {
   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 {
+    }
+  if (!el.isConnected) 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);
@@ -93,6 +153,7 @@ function mirrorTheme(el) {
   return () => observer.disconnect();
 }
 export {
-  attachStyles,
-  prefetch
+  attachShadowRoot,
+  prefetch,
+  registryFor
 };

package/dist/single-spa.d.ts

@@ -0,0 +1,40 @@
+import { P as Props, a as RemoteModule } from './types-DUtcF3HO.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 };

package/dist/single-spa.js

@@ -0,0 +1,52 @@
+// src/single-spa.ts
+async function run(fns, props) {
+  for (const fn of [fns ?? []].flat()) await fn(props);
+}
+function singleSpaRemote(lifecycles) {
+  const l = "mount" in lifecycles ? lifecycles : lifecycles.default;
+  if (typeof l?.mount == "undefined" || typeof l.unmount == "undefined") throw new Error("[vitral] singleSpaRemote: faltam os lifecycles mount e unmount");
+  let booted;
+  let queue = Promise.resolve();
+  const used = /* @__PURE__ */ new Set();
+  const step = (fn) => queue = queue.then(fn, fn);
+  const boot = (props) => booted ??= run(l.bootstrap, props).catch((e) => {
+    booted = void 0;
+    throw e;
+  });
+  return {
+    async mount(el, props, ctx) {
+      let name = ctx.name;
+      for (let i = 2; used.has(name); i++) name = `${ctx.name}-${i}`;
+      used.add(name);
+      let current = { ...props, name, domElement: el };
+      try {
+        await step(async () => {
+          await boot(current);
+          await run(l.mount, current);
+        });
+      } catch (e) {
+        used.delete(name);
+        throw e;
+      }
+      const report = (e) => ctx.reportError(e);
+      return {
+        update(next) {
+          const before = current;
+          current = { ...next, name, domElement: el };
+          const job = l.update ? step(() => run(l.update, current)) : step(async () => {
+            await run(l.unmount, before);
+            await run(l.mount, current);
+          });
+          job.catch(report);
+        },
+        unmount() {
+          used.delete(name);
+          step(() => run(l.unmount, current)).catch(report);
+        }
+      };
+    }
+  };
+}
+export {
+  singleSpaRemote
+};

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

@@ -1,5 +1,5 @@
 import { R as RemoteError } from './errors-kjBv6IH_.js';
-import { P as Props, I as Isolation, b as StyleOptions } from './types-Czvm-siZ.js';
+import { P as Props, I as Isolation, d as StyleOptions } from './types-DUtcF3HO.js';
 
 type SlotStatus = 'loading' | 'ready' | 'error';
 interface SlotOptions<P extends Props = Props> {

package/dist/solid.d.ts

@@ -1,8 +1,8 @@
 import { JSX, Component, Accessor } from 'solid-js';
-import { P as Props, I as Isolation, C as CheckedProps, a as RemoteModule, S as Shared } from './types-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';
-export { e as events } from './events-D5gs7rff.js';
+export { e as events } from './events-0rxFlWJJ.js';
 export { n as navigate } from './navigate-BRG1WJUM.js';
 import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 

package/dist/solid.js

@@ -1,6 +1,6 @@
 import {
   hostSlot
-} from "./chunk-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/solid.ts

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

@@ -1,14 +1,14 @@
 import {
   verifyIntegrity
-} from "./chunk-AH7KNMBW.js";
+} from "./chunk-UYOPJ4XQ.js";
 import {
   addLink,
   fetchBytes,
   withTimeout
-} from "./chunk-GNHCZRQP.js";
+} from "./chunk-TW7KYJQ6.js";
 import {
   RemoteError
-} from "./chunk-AKNNHQ2H.js";
+} from "./chunk-463H6B56.js";
 import "./chunk-GNPFWISJ.js";
 
 // src/core/sri.ts
@@ -41,7 +41,25 @@ var STRICT = /^(sha(256|384|512)-[A-Za-z0-9+/]+={0,2}( +|$))+$/;
 var PROBE = "data:text/javascript,export{}";
 var PROBE_SRI = "sha256-d3bjIZdvLjBurwdLwkSVOnEBPFFly+T1SR9r3VVHBGg=";
 var maps;
+var mapped = /* @__PURE__ */ new Set();
+var probing;
 var preloads;
+var KEY = "vitral:sri-map";
+async function useMap(sri) {
+  if (probing) return await probing && addMap(sri, false);
+  let seen = false;
+  try {
+    seen = localStorage[KEY] === navigator.userAgent;
+  } catch {
+  }
+  const ok = await (probing = addMap(sri, !seen));
+  if (ok && !seen)
+    try {
+      localStorage[KEY] = navigator.userAgent;
+    } catch {
+    }
+  return ok;
+}
 var tick = () => new Promise((resolve) => {
   const c = new MessageChannel();
   c.port1.onmessage = () => resolve();
@@ -65,7 +83,7 @@ async function verified(build, run) {
         }
       });
   };
-  if (maps !== false && (maps = await addMap(sri))) {
+  if (maps !== false && (maps = await useMap(sri))) {
     await share();
     for (const u of chunks) fetch(u, { priority }).catch(() => {
     });
@@ -78,7 +96,12 @@ async function verified(build, run) {
     return entry;
   }
 }
-async function addMap(integrity) {
+async function addMap(sri, probe) {
+  if (!HTMLScriptElement.supports?.("importmap")) return false;
+  const integrity = {};
+  for (const u in sri) if (!/\.css([?#]|$)/.test(u) && !mapped.has(u)) mapped.add(u), integrity[u] = sri[u];
+  const urls = probe ? ["export{}", "export{}//"].map((c) => URL.createObjectURL(new Blob([c], { type: "text/javascript" }))) : [];
+  for (const u of urls) integrity[u] = PROBE_SRI;
   let ok = true;
   try {
     const s = document.createElement("script");
@@ -88,11 +111,17 @@ async function addMap(integrity) {
     s.addEventListener("securitypolicyviolation", () => ok = false);
     s.textContent = JSON.stringify({ integrity });
     document.head.append(s);
+    await tick();
+    await tick();
+    if (ok && probe) ok = await check((u) => import(
+      /* @vite-ignore */
+      /* webpackIgnore: true */
+      u
+    ), urls[0], urls[1]);
   } catch {
-    return false;
+    ok = false;
   }
-  await tick();
-  await tick();
+  for (const u of urls) URL.revokeObjectURL(u);
   return ok;
 }
 function preload(href, integrity, fetchPriority = "auto") {
@@ -104,9 +133,11 @@ function preload(href, integrity, fetchPriority = "auto") {
 }
 function checkPreloads() {
   if (!document.createElement("link").relList.supports("modulepreload")) return Promise.resolve(false);
-  const run = (href, good) => preload(href, PROBE_SRI).then(() => good, () => !good);
+  return check((href) => preload(href, PROBE_SRI), PROBE, PROBE + "//");
+}
+function check(load, good, bad) {
   return Promise.race([
-    Promise.all([run(PROBE, true), run(PROBE + "//", false)]).then(([a, b]) => a && b),
+    Promise.all([load(good).then(() => true, () => false), load(bad).then(() => false, () => true)]).then(([a, b]) => a && b),
     new Promise((resolve) => setTimeout(resolve, 3e3, false))
   ]);
 }

package/dist/svelte.d.ts

@@ -1,9 +1,9 @@
 import { Component } from 'svelte';
-import { P as Props, I as Isolation, a as RemoteModule } from './types-Czvm-siZ.js';
-export { R as RemoteContext } from './types-Czvm-siZ.js';
+import { P as Props, I as Isolation, a as RemoteModule } from './types-DUtcF3HO.js';
+export { R as RemoteContext } from './types-DUtcF3HO.js';
 import { R as RemoteError } from './errors-kjBv6IH_.js';
-import { S as SlotStatus } from './slot-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';