sibujs 4.5.0 → 4.6.0

package/dist/plugins.cjs

@@ -382,12 +382,17 @@ var init_sanitize = __esm({
 var dispose_exports = {};
 __export(dispose_exports, {
   MAX_DRAIN_TEARDOWNS: () => MAX_DRAIN_TEARDOWNS,
+  beginDisposerCapture: () => beginDisposerCapture,
   checkLeaks: () => checkLeaks,
+  currentDisposerCapture: () => currentDisposerCapture,
   dispose: () => dispose,
+  disposeNodeOwn: () => disposeNodeOwn,
+  endDisposerCapture: () => endDisposerCapture,
   registerDisposer: () => registerDisposer,
   replaceChildrenSafely: () => replaceChildrenSafely,
   reportDrainRunaway: () => reportDrainRunaway,
-  unregisterDisposer: () => unregisterDisposer
+  unregisterDisposer: () => unregisterDisposer,
+  withDisposerRollback: () => withDisposerRollback
 });
 function reportDrainRunaway(label2, executed, remaining) {
   if (typeof console === "undefined") return;
@@ -396,6 +401,22 @@ function reportDrainRunaway(label2, executed, remaining) {
     { executed, remaining }
   );
 }
+function resolveCapture(capture) {
+  let frame = capture;
+  while (frame?.closed) frame = frame.forwardTo;
+  return frame ?? null;
+}
+function currentDisposerCapture() {
+  return resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+}
+function beginDisposerCapture(capture) {
+  if (capture === null && registrationCaptures.length === 0) return false;
+  registrationCaptures.push(resolveCapture(capture));
+  return true;
+}
+function endDisposerCapture() {
+  registrationCaptures.pop();
+}
 function registerDisposer(node, teardown) {
   let disposers = elementDisposers.get(node);
   if (!disposers) {
@@ -404,15 +425,61 @@ function registerDisposer(node, teardown) {
   }
   disposers.push(teardown);
   if (DEV) activeBindingCount++;
+  const capture = resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+  if (capture) capture.entries.push([node, teardown]);
+}
+function withDisposerRollback(build) {
+  const frame = { entries: [], closed: false };
+  const captured = frame.entries;
+  registrationCaptures.push(frame);
+  let result;
+  try {
+    result = build();
+  } catch (err) {
+    let executed = 0;
+    try {
+      while (captured.length > 0) {
+        if (executed >= MAX_DRAIN_TEARDOWNS) {
+          reportDrainRunaway("rollback", executed, captured.length);
+          break;
+        }
+        const [node, teardown] = captured.pop();
+        if (!unregisterDisposer(node, teardown)) continue;
+        executed++;
+        try {
+          teardown();
+        } catch (cleanupErr) {
+          reportError(cleanupErr, { phase: "cleanup", name: "disposer" });
+        }
+      }
+    } finally {
+      frame.closed = true;
+      captured.length = 0;
+      registrationCaptures.pop();
+    }
+    throw err;
+  }
+  frame.closed = true;
+  registrationCaptures.pop();
+  const parent = resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+  if (parent) {
+    for (const entry of captured) {
+      if (elementDisposers.get(entry[0])?.includes(entry[1])) parent.entries.push(entry);
+    }
+    frame.forwardTo = parent;
+  }
+  captured.length = 0;
+  return result;
 }
 function unregisterDisposer(node, teardown) {
   const disposers = elementDisposers.get(node);
-  if (!disposers) return;
+  if (!disposers) return false;
   const index = disposers.indexOf(teardown);
-  if (index === -1) return;
+  if (index === -1) return false;
   disposers.splice(index, 1);
   if (DEV) activeBindingCount--;
   if (disposers.length === 0) elementDisposers.delete(node);
+  return true;
 }
 function dispose(node) {
   const stack = [node];
@@ -426,33 +493,34 @@ function dispose(node) {
     }
   }
   for (let i2 = order.length - 1; i2 >= 0; i2--) {
-    const current = order[i2];
-    if (elementDisposers.has(current)) {
-      let executed = 0;
-      let runaway = false;
-      while (!runaway) {
-        const pending = elementDisposers.get(current);
-        if (!pending || pending.length === 0) break;
-        const snapshot = pending.slice();
-        elementDisposers.delete(current);
-        if (DEV) activeBindingCount -= snapshot.length;
-        for (let i3 = 0; i3 < snapshot.length; i3++) {
-          if (executed >= MAX_DRAIN_TEARDOWNS) {
-            const rest = snapshot.slice(i3);
-            const added = elementDisposers.get(current);
-            elementDisposers.set(current, added ? rest.concat(added) : rest);
-            if (DEV) activeBindingCount += rest.length;
-            reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
-            runaway = true;
-            break;
-          }
-          executed++;
-          try {
-            snapshot[i3]();
-          } catch (err) {
-            reportError(err, { phase: "cleanup", name: "disposer" });
-          }
-        }
+    disposeNodeOwn(order[i2]);
+  }
+}
+function disposeNodeOwn(node) {
+  if (!elementDisposers.has(node)) return;
+  let executed = 0;
+  let runaway = false;
+  while (!runaway) {
+    const pending = elementDisposers.get(node);
+    if (!pending || pending.length === 0) break;
+    const snapshot = pending.slice();
+    elementDisposers.delete(node);
+    if (DEV) activeBindingCount -= snapshot.length;
+    for (let i2 = 0; i2 < snapshot.length; i2++) {
+      if (executed >= MAX_DRAIN_TEARDOWNS) {
+        const rest = snapshot.slice(i2);
+        const added = elementDisposers.get(node);
+        elementDisposers.set(node, added ? rest.concat(added) : rest);
+        if (DEV) activeBindingCount += rest.length;
+        reportDrainRunaway("dispose", executed, rest.length + (added?.length ?? 0));
+        runaway = true;
+        break;
+      }
+      executed++;
+      try {
+        snapshot[i2]();
+      } catch (err) {
+        reportError(err, { phase: "cleanup", name: "disposer" });
       }
     }
   }
@@ -477,7 +545,7 @@ function checkLeaks(warnThreshold = 0) {
   }
   return activeBindingCount;
 }
-var elementDisposers, MAX_DRAIN_TEARDOWNS, activeBindingCount;
+var elementDisposers, MAX_DRAIN_TEARDOWNS, activeBindingCount, registrationCaptures;
 var init_dispose = __esm({
   "src/core/rendering/dispose.ts"() {
     "use strict";
@@ -486,6 +554,7 @@ var init_dispose = __esm({
     elementDisposers = /* @__PURE__ */ new WeakMap();
     MAX_DRAIN_TEARDOWNS = 1e4;
     activeBindingCount = 0;
+    registrationCaptures = [];
   }
 });
 
@@ -985,7 +1054,7 @@ function renderToDocument(component, options = {}) {
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    ${options.title ? `<title>${escapeHtml(options.title)}</title>` : ""}
+    ${options.title != null ? `<title>${escapeHtml(options.title)}</title>` : ""}
     ${metaTags}
     ${linkTags}
     ${options.headExtra || ""}
@@ -1159,16 +1228,32 @@ function ssrSuspense(props) {
   const timeoutPromise = new Promise((_, reject) => {
     timer = setTimeout(() => reject(new Error(`[SibuJS SSR] ssrSuspense timed out after ${timeoutMs}ms`)), timeoutMs);
   });
-  const raced = Promise.race([props.content(), timeoutPromise]);
+  let contentPromise;
+  try {
+    contentPromise = Promise.resolve(props.content());
+  } catch (err) {
+    contentPromise = Promise.reject(err);
+  }
+  const toFallback = (err) => {
+    if (DEV) console.warn("[SibuJS SSR] ssrSuspense rejected:", err);
+    return { id, html: fallbackHtml };
+  };
+  const clearTimer = () => {
+    if (timer !== void 0) clearTimeout(timer);
+  };
+  const raced = Promise.race([contentPromise, timeoutPromise]);
   const promise = raced.then(
     (resolvedEl) => {
-      if (timer) clearTimeout(timer);
-      return { id, html: renderToString(resolvedEl) };
+      clearTimer();
+      try {
+        return { id, html: renderToString(resolvedEl) };
+      } catch (err) {
+        return toFallback(err);
+      }
     },
     (err) => {
-      if (timer) clearTimeout(timer);
-      if (DEV) console.warn("[SibuJS SSR] ssrSuspense rejected:", err);
-      return { id, html: fallbackHtml };
+      clearTimer();
+      return toFallback(err);
     }
   );
   promise.catch(noop);
@@ -1265,7 +1350,9 @@ var init_ssr = __esm({
 var plugins_exports = {};
 __export(plugins_exports, {
   KeepAliveRoute: () => KeepAliveRoute,
+  MigrationStorageError: () => MigrationStorageError,
   Outlet: () => Outlet,
+  PluginInstallCancelledError: () => PluginInstallCancelledError,
   Route: () => Route,
   RouterLink: () => RouterLink,
   SibuRouter: () => SibuRouter,
@@ -1309,6 +1396,7 @@ __export(plugins_exports, {
   healthCheck: () => healthCheck,
   hydrateRouter: () => hydrateRouter,
   inject: () => inject,
+  isPluginInstallCancelledError: () => isPluginInstallCancelledError,
   lazy: () => lazy,
   lazyModule: () => lazyModule,
   navigate: () => navigate,
@@ -1440,6 +1528,7 @@ init_dev();
 
 // src/reactivity/track-core.ts
 init_errors();
+init_dispose();
 var POOL_MAX = 4096;
 var nodePool = [];
 function createNode() {
@@ -1597,6 +1686,7 @@ function retrack(effectFn, subscriber) {
   }
   currentSubscriber = subscriber;
   const sub2 = subscriber;
+  if (sub2._cap === void 0) sub2._cap = currentDisposerCapture();
   const epoch = ++subscriberEpochCounter;
   sub2._epoch = epoch;
   sub2._structDirty = false;
@@ -1788,7 +1878,12 @@ function drainQueue() {
       quarantined.add(sub2);
       continue;
     }
-    safeInvoke(sub2);
+    const pushed = beginDisposerCapture(sub2._cap ?? null);
+    try {
+      safeInvoke(sub2);
+    } finally {
+      if (pushed) endDisposerCapture();
+    }
   }
 }
 function drainNotificationQueue() {
@@ -1924,7 +2019,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.5.0" : "dev";
+var _runtimeVersion = true ? "4.6.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g2 = globalThis;
@@ -2897,6 +2992,15 @@ function effect(effectFn, options) {
 
 // src/plugins/router.ts
 init_sanitize();
+function splitRouteUrl(url) {
+  const hashIndex = url.indexOf("#");
+  const beforeHash = hashIndex === -1 ? url : url.slice(0, hashIndex);
+  const hash = hashIndex === -1 ? "" : url.slice(hashIndex + 1);
+  const queryIndex = beforeHash.indexOf("?");
+  const path2 = queryIndex === -1 ? beforeHash : beforeHash.slice(0, queryIndex);
+  const query = queryIndex === -1 ? "" : beforeHash.slice(queryIndex + 1);
+  return { path: path2, query, hash };
+}
 function classifyNavigationTarget(path2) {
   if (path2 === "") return "internal";
   const normalized = stripControlChars(path2).replace(/\\/g, "/");
@@ -3615,8 +3719,7 @@ var _SibuRouter = class _SibuRouter {
     return (path2 || "/") + window.location.search + window.location.hash;
   }
   createRouteContext(fullPath) {
-    const [pathWithQuery, hash = ""] = fullPath.split("#");
-    const [path2, queryString = ""] = pathWithQuery.split("?");
+    const { path: path2, query: queryString, hash } = splitRouteUrl(fullPath);
     const query = Object.fromEntries(new URLSearchParams(queryString));
     const match = this.matcher.match(path2 || "/");
     const params = match?.params || {};
@@ -4363,8 +4466,7 @@ function RouterLink(props, children) {
   const rawHref = _routerRef.current["resolvePath"](to);
   const kind = classifyNavigationTarget(rawHref);
   const href = kind === "unsafe" ? "#" : rawHref;
-  const [hrefBeforeHash, hrefHash = ""] = href.split("#");
-  const [hrefPathRaw, hrefQueryRaw = ""] = hrefBeforeHash.split("?");
+  const { path: hrefPathRaw, query: hrefQueryRaw, hash: hrefHash } = splitRouteUrl(href);
   const targetPath = normalizePathname(hrefPathRaw);
   const targetQuery = normalizeQuery(hrefQueryRaw);
   const link2 = document.createElement("a");
@@ -5005,37 +5107,152 @@ function escapeAttrLocal(str) {
 }
 
 // src/plugins/plugin.ts
+init_dev();
+init_errors();
+
+// src/utils/adoptThenable.ts
+function adoptThenable(value) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return null;
+  let then;
+  try {
+    then = value.then;
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  if (typeof then !== "function") return null;
+  return new Promise((resolve, reject) => {
+    queueMicrotask(() => {
+      try {
+        Reflect.apply(then, value, [resolve, reject]);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+
+// src/plugins/plugin.ts
+var CANCELLED_BRAND = /* @__PURE__ */ Symbol.for("sibujs.plugins.installCancelled.v1");
+var _a;
+var PluginInstallCancelledError = class extends Error {
+  constructor(pluginName) {
+    super(`[Plugin] Installation of "${pluginName}" was cancelled before it was committed (registry reset).`);
+    /**
+     * Brand, not identity: the default registry is shared across duplicate copies
+     * of this module, so the error a caller receives may come from another copy's
+     * constructor. `instanceof` is taught to recognise the brand instead.
+     */
+    this[_a] = true;
+    this.name = "PluginInstallCancelledError";
+    this.pluginName = pluginName;
+  }
+  static [(_a = CANCELLED_BRAND, Symbol.hasInstance)](value) {
+    return isPluginInstallCancelledError(value);
+  }
+};
+function isPluginInstallCancelledError(value) {
+  return typeof value === "object" && value !== null && value[CANCELLED_BRAND] === true;
+}
 function createPluginRegistry() {
   const installedPlugins = /* @__PURE__ */ new Set();
   const hooks = { init: [], mount: [], unmount: [], error: [] };
   const provided = /* @__PURE__ */ new Map();
+  const installStack = /* @__PURE__ */ new Set();
+  const pendingInstalls = /* @__PURE__ */ new Map();
+  let generation = 0;
   const registry = {
     installedPlugins,
     hooks,
     provided,
+    /**
+     * Install a plugin as a transaction.
+     *
+     * Hooks and providers registered through `ctx` are staged and committed
+     * only if `install()` returns; a throwing install leaves the registry
+     * exactly as it found it (and can simply be retried). The plugin is marked
+     * installed at commit, before its init hooks run.
+     *
+     * Each `plugin()` call is its own transaction: a dependency installed by a
+     * nested `plugin()` call commits on its own and stays installed even if the
+     * outer installation later fails.
+     */
     plugin(p2, options) {
       if (installedPlugins.has(p2.name)) {
         console.warn(`[Plugin] "${p2.name}" is already installed.`);
         return;
       }
+      if (installStack.has(p2.name)) {
+        throw new Error(`[Plugin] "${p2.name}" is already being installed (recursive installation).`);
+      }
+      if (pendingInstalls.has(p2.name)) {
+        throw new Error(`[Plugin] "${p2.name}" is already being installed (asynchronous installation in flight).`);
+      }
+      const staged = { init: [], mount: [], unmount: [], error: [] };
+      const stagedProvided = /* @__PURE__ */ new Map();
+      let committed = false;
+      const myGeneration = generation;
+      const stale = () => {
+        if (myGeneration === generation) return false;
+        if (DEV) devWarn(`plugin: "${p2.name}" registered after the registry was reset; the registration was ignored.`);
+        return true;
+      };
+      const target = () => stale() ? null : committed ? hooks : staged;
       const ctx = {
-        onInit: (cb) => hooks.init.push(cb),
-        onMount: (cb) => hooks.mount.push(cb),
-        onUnmount: (cb) => hooks.unmount.push(cb),
-        onError: (cb) => hooks.error.push(cb),
-        provide: (key, value) => provided.set(key, value)
+        onInit: (cb) => void target()?.init.push(cb),
+        onMount: (cb) => void target()?.mount.push(cb),
+        onUnmount: (cb) => void target()?.unmount.push(cb),
+        onError: (cb) => void target()?.error.push(cb),
+        provide: (key, value) => {
+          if (stale()) return;
+          (committed ? provided : stagedProvided).set(key, value);
+        }
       };
-      const initHooksBefore = hooks.init.length;
-      p2.install(ctx, options);
-      installedPlugins.add(p2.name);
-      const justAdded = hooks.init.slice(initHooksBefore);
-      for (const cb of justAdded) {
-        try {
-          cb();
-        } catch (e) {
-          console.error(`[Plugin] "${p2.name}" init error:`, e);
+      const commit = () => {
+        if (myGeneration !== generation) return false;
+        hooks.init.push(...staged.init);
+        hooks.mount.push(...staged.mount);
+        hooks.unmount.push(...staged.unmount);
+        hooks.error.push(...staged.error);
+        for (const [key, value] of stagedProvided) provided.set(key, value);
+        installedPlugins.add(p2.name);
+        committed = true;
+        if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
+        for (const cb of staged.init.slice()) {
+          try {
+            cb();
+          } catch (e) {
+            console.error(`[Plugin] "${p2.name}" init error:`, e);
+          }
         }
+        return true;
+      };
+      installStack.add(p2.name);
+      let pending;
+      try {
+        pending = adoptThenable(p2.install(ctx, options));
+      } finally {
+        installStack.delete(p2.name);
+      }
+      if (!pending) {
+        if (!commit()) throw new PluginInstallCancelledError(p2.name);
+        return;
       }
+      if (myGeneration === generation) pendingInstalls.set(p2.name, myGeneration);
+      const settled = pending.then(
+        () => {
+          if (commit()) return;
+          if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
+          throw new PluginInstallCancelledError(p2.name);
+        },
+        (err) => {
+          if (pendingInstalls.get(p2.name) === myGeneration) pendingInstalls.delete(p2.name);
+          reportError(err, { phase: "async", name: `plugin(${p2.name})` });
+          throw err;
+        }
+      );
+      settled.catch(() => {
+      });
+      return settled;
     },
     inject(key, defaultValue) {
       if (provided.has(key)) return provided.get(key);
@@ -5073,6 +5290,8 @@ function createPluginRegistry() {
       }
     },
     reset() {
+      generation++;
+      pendingInstalls.clear();
       installedPlugins.clear();
       hooks.init.length = 0;
       hooks.mount.length = 0;
@@ -5092,7 +5311,7 @@ function createPlugin(name, install) {
 }
 function plugin(plugin2, options) {
   _defaults.touched = true;
-  _defaults.registry.plugin(plugin2, options);
+  return _defaults.registry.plugin(plugin2, options);
 }
 function inject(key, defaultValue) {
   return _defaults.registry.inject(key, defaultValue);
@@ -5123,35 +5342,44 @@ function setDefaultPluginRegistry(registry) {
 // src/plugins/modular.ts
 function createModuleRegistry() {
   const modules = /* @__PURE__ */ new Map();
-  function resolveInternal(name, stack) {
+  const resolving = [];
+  function resolveInternal(name) {
     const entry = modules.get(name);
     if (!entry) {
       throw new Error(`[ModuleRegistry] Module "${name}" is not registered.`);
     }
-    if (entry.loaded) {
+    if (entry.state === "loaded") {
       return entry.value;
     }
-    if (stack.has(name)) {
-      const cycle = [...stack, name].join(" -> ");
+    if (entry.state === "resolving") {
+      const cycle = [...resolving.slice(resolving.indexOf(name)), name].join(" -> ");
       throw new Error(`[ModuleRegistry] Circular dependency detected: ${cycle}`);
     }
-    stack.add(name);
-    for (const dep of entry.deps) {
-      resolveInternal(dep, stack);
+    entry.state = "resolving";
+    resolving.push(name);
+    try {
+      for (const dep of entry.deps) {
+        resolveInternal(dep);
+      }
+      entry.value = entry.factory();
+      entry.state = "loaded";
+      return entry.value;
+    } catch (err) {
+      entry.state = "unloaded";
+      entry.value = void 0;
+      throw err;
+    } finally {
+      resolving.pop();
     }
-    stack.delete(name);
-    entry.value = entry.factory();
-    entry.loaded = true;
-    return entry.value;
   }
   return {
     /** Register a module with its factory function and optional dependencies */
     register(name, factory, deps = []) {
-      modules.set(name, { factory, deps, loaded: false });
+      modules.set(name, { factory, deps, state: "unloaded" });
     },
     /** Resolve a module, loading its dependencies first */
     resolve(name) {
-      return resolveInternal(name, /* @__PURE__ */ new Set());
+      return resolveInternal(name);
     },
     /** Check if a module is registered */
     has(name) {
@@ -5186,7 +5414,7 @@ function createModuleRegistry() {
     /** Reset all loaded modules back to unloaded state (useful for testing) */
     reset() {
       for (const entry of modules.values()) {
-        entry.loaded = false;
+        entry.state = "unloaded";
         entry.value = void 0;
       }
     }
@@ -5214,46 +5442,83 @@ function createBundle(modules) {
 function lazyModule(loader) {
   let cached;
   let loadedFlag = false;
-  const handle = {
+  let inFlight = null;
+  return {
     get loaded() {
       return loadedFlag;
     },
-    async get() {
-      if (loadedFlag) return cached;
-      cached = await loader();
-      loadedFlag = true;
-      return cached;
+    get() {
+      if (loadedFlag) return Promise.resolve(cached);
+      if (inFlight) return inFlight;
+      let started;
+      try {
+        started = Promise.resolve(loader());
+      } catch (err) {
+        started = Promise.reject(err);
+      }
+      const attempt = started.then(
+        (value) => {
+          cached = value;
+          loadedFlag = true;
+          if (inFlight === attempt) inFlight = null;
+          return value;
+        },
+        (err) => {
+          if (inFlight === attempt) inFlight = null;
+          throw err;
+        }
+      );
+      inFlight = attempt;
+      return attempt;
     }
   };
-  return handle;
 }
+var MODULE_ENTRY_POINTS = {
+  main: "./index.ts",
+  data: "./data.ts",
+  browser: "./browser.ts",
+  patterns: "./patterns.ts",
+  motion: "./motion.ts",
+  ui: "./ui.ts",
+  widgets: "./widgets.ts",
+  ssr: "./ssr.ts",
+  devtools: "./devtools.ts",
+  performance: "./performance.ts",
+  ecosystem: "./ecosystem.ts",
+  plugins: "./plugins.ts",
+  build: "./build.ts",
+  testing: "./testing.ts",
+  extras: "./extras.ts"
+};
+var CDN_ENTRY_POINTS = {
+  cdn: "./dist/cdn.global.js",
+  "cdn-dev": "./dist/cdn.dev.global.js",
+  "cdn-full": "./dist/cdn.full.global.js",
+  "cdn-full-dev": "./dist/cdn.full.dev.global.js"
+};
 var packageInfo = {
-  name: "sibu",
-  version: "1.0.0",
-  entryPoints: {
-    main: "./index.ts",
-    core: "./src/core/html.ts",
-    hooks: "./src/core/signals/signal.ts",
-    router: "./src/plugins/router.ts",
-    i18n: "./src/plugins/i18n.ts",
-    testing: "./src/testing/index.ts",
-    ssr: "./src/core/ssr.ts"
-  },
+  name: "sibujs",
+  version: true ? "4.6.0" : "dev",
+  entryPoints: MODULE_ENTRY_POINTS,
   /**
-   * Generate a package.json `exports` map for Node.js subpath exports.
-   * Maps each entry point to its import, require, and types paths.
+   * Generate the package.json `exports` map. Module entries resolve to the
+   * `.js` (ESM), `.cjs` and `.d.ts` files tsup emits into `dist/`; CDN entries
+   * resolve to their prebuilt global script.
    */
   generateExportsMap() {
     const exportsMap = {};
-    for (const [name, sourcePath] of Object.entries(this.entryPoints)) {
+    for (const [name, sourcePath] of Object.entries(MODULE_ENTRY_POINTS)) {
       const distPath = sourcePath.replace(/^\.\//, "./dist/").replace(/\.ts$/, "");
       const subpath = name === "main" ? "." : `./${name}`;
       exportsMap[subpath] = {
-        import: `${distPath}.mjs`,
-        require: `${distPath}.cjs`,
-        types: `${distPath}.d.ts`
+        types: `${distPath}.d.ts`,
+        import: `${distPath}.js`,
+        require: `${distPath}.cjs`
       };
     }
+    for (const [name, file] of Object.entries(CDN_ENTRY_POINTS)) {
+      exportsMap[`./${name}`] = { default: file };
+    }
     return exportsMap;
   }
 };
@@ -5378,29 +5643,26 @@ var env = {
 };
 
 // src/plugins/versioning.ts
-var VERSION = "1.0.0";
+var VERSION = true ? "4.6.0" : "dev";
+var NUM = "(?:0|[1-9]\\d*)";
+var PRE_ID = `(?:${NUM}|\\d*[a-zA-Z-][0-9a-zA-Z-]*)`;
+var BUILD_ID = "[0-9a-zA-Z-]+";
+var SEMVER_PATTERN = new RegExp(
+  `^(${NUM})(?:\\.(${NUM})(?:\\.(${NUM})(?:-(${PRE_ID}(?:\\.${PRE_ID})*))?(?:\\+(${BUILD_ID}(?:\\.${BUILD_ID})*))?)?)?$`
+);
 function parseSemVer(version) {
-  const trimmed = version.trim().replace(/^v/i, "");
-  const prereleaseIndex = trimmed.indexOf("-");
-  let main2;
-  let prerelease;
-  if (prereleaseIndex !== -1) {
-    main2 = trimmed.slice(0, prereleaseIndex);
-    prerelease = trimmed.slice(prereleaseIndex + 1);
-  } else {
-    main2 = trimmed;
-  }
-  const parts = main2.split(".");
-  const major = parseInt(parts[0], 10);
-  const minor = parseInt(parts[1] || "0", 10);
-  const patch = parseInt(parts[2] || "0", 10);
-  if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) {
+  const trimmed = String(version).trim().replace(/^v/i, "");
+  const match = SEMVER_PATTERN.exec(trimmed);
+  if (!match) {
     throw new Error(`[Versioning] Invalid semver string: "${version}"`);
   }
-  const result = { major, minor, patch };
-  if (prerelease !== void 0) {
-    result.prerelease = prerelease;
-  }
+  const result = {
+    major: Number(match[1]),
+    minor: match[2] === void 0 ? 0 : Number(match[2]),
+    patch: match[3] === void 0 ? 0 : Number(match[3])
+  };
+  if (match[4] !== void 0) result.prerelease = match[4];
+  if (match[5] !== void 0) result.build = match[5];
   return result;
 }
 function compareSemVer(a2, b2) {
@@ -5483,82 +5745,154 @@ function satisfies(version, range) {
   const target = parseSemVer(exactStr);
   return compareSemVer(v, target) === 0;
 }
+var MigrationStorageError = class extends Error {
+  constructor(version, cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    super(`[Versioning] Migration ${version} completed, but recording it in storage failed: ${reason}`);
+    this.name = "MigrationStorageError";
+    this.version = version;
+    this.cause = cause;
+  }
+};
+var _migrationQueues = globalSingleton(
+  /* @__PURE__ */ Symbol.for("sibujs.migrationQueues.v1"),
+  () => /* @__PURE__ */ new WeakMap()
+);
+var NO_STORAGE = {};
 function createMigrationRunner(config) {
   const storageKey = config.storageKey || "__sibu_migration_version__";
   const sortedMigrations = [...config.migrations].sort((a2, b2) => compareSemVer(a2.version, b2.version));
   function getStorage() {
+    if (config.storage) return config.storage;
     try {
       return typeof localStorage !== "undefined" ? localStorage : null;
     } catch {
       return null;
     }
   }
+  function getAppliedVersion() {
+    const storage = getStorage();
+    if (!storage) return null;
+    return storage.getItem(storageKey);
+  }
+  function getPending() {
+    const appliedVersion = getAppliedVersion();
+    if (!appliedVersion) {
+      return sortedMigrations.filter((m) => compareSemVer(m.version, config.currentVersion) <= 0);
+    }
+    return sortedMigrations.filter(
+      (m) => compareSemVer(m.version, appliedVersion) > 0 && compareSemVer(m.version, config.currentVersion) <= 0
+    );
+  }
+  function writeApplied(version, migrationVersion) {
+    const storage = getStorage();
+    if (!storage) return;
+    try {
+      if (version === null) storage.removeItem(storageKey);
+      else storage.setItem(storageKey, version);
+    } catch (e) {
+      throw new MigrationStorageError(migrationVersion, e);
+    }
+  }
+  function serialize(operation) {
+    const identity = getStorage() ?? NO_STORAGE;
+    let queues = _migrationQueues.get(identity);
+    if (!queues) {
+      queues = /* @__PURE__ */ new Map();
+      _migrationQueues.set(identity, queues);
+    }
+    const run = (queues.get(storageKey) ?? Promise.resolve()).then(operation, operation);
+    const tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    queues.set(storageKey, tail);
+    const settled = queues;
+    tail.then(() => {
+      if (settled.get(storageKey) === tail) settled.delete(storageKey);
+    });
+    return run;
+  }
   return {
     /** Get the last applied migration version from storage */
-    getAppliedVersion() {
-      const storage = getStorage();
-      if (!storage) return null;
-      return storage.getItem(storageKey);
-    },
+    getAppliedVersion,
     /** Get pending migrations that haven't been applied */
-    getPending() {
-      const appliedVersion = this.getAppliedVersion();
-      if (!appliedVersion) {
-        return sortedMigrations.filter((m) => compareSemVer(m.version, config.currentVersion) <= 0);
-      }
-      return sortedMigrations.filter(
-        (m) => compareSemVer(m.version, appliedVersion) > 0 && compareSemVer(m.version, config.currentVersion) <= 0
-      );
-    },
-    /** Run all pending migrations in order */
-    async migrate() {
-      const pending = this.getPending();
-      const applied = [];
-      const errors = [];
-      for (const migration of pending) {
+    getPending,
+    /**
+     * Run all pending migrations in order. Concurrent calls (and calls racing
+     * `rollback()`) run one after another, each recomputing what is pending —
+     * on this runner and on every other runner in this realm sharing its
+     * storage and storage key.
+     */
+    migrate() {
+      return serialize(async () => {
+        const applied = [];
+        const errors = [];
+        let pending;
         try {
-          await migration.up();
-          applied.push(migration.version);
-          const storage = getStorage();
-          if (storage) {
-            storage.setItem(storageKey, migration.version);
-          }
+          pending = getPending();
         } catch (e) {
           errors.push({
-            version: migration.version,
+            version: getAppliedVersion() ?? "",
             error: e instanceof Error ? e : new Error(String(e))
           });
-          break;
+          return { applied, errors };
         }
-      }
-      return { applied, errors };
+        for (const migration of pending) {
+          try {
+            await migration.up();
+          } catch (e) {
+            errors.push({
+              version: migration.version,
+              error: e instanceof Error ? e : new Error(String(e))
+            });
+            break;
+          }
+          applied.push(migration.version);
+          try {
+            writeApplied(migration.version, migration.version);
+          } catch (e) {
+            errors.push({ version: migration.version, error: e });
+            break;
+          }
+        }
+        return { applied, errors };
+      });
     },
-    /** Rollback to a specific version */
-    async rollback(targetVersion) {
-      const appliedVersion = this.getAppliedVersion();
-      const rolledBack = [];
-      if (!appliedVersion) {
-        return { rolledBack };
-      }
-      const toRollback = sortedMigrations.filter((m) => compareSemVer(m.version, targetVersion) > 0 && compareSemVer(m.version, appliedVersion) <= 0).reverse();
-      for (const migration of toRollback) {
-        if (!migration.down) {
-          throw new Error(
-            `[Versioning] Migration ${migration.version} ("${migration.description}") does not have a down() function and cannot be rolled back.`
-          );
+    /**
+     * Rollback to a specific version.
+     *
+     * The applied version is checkpointed after EVERY successful `down()`, so a
+     * rollback that fails part-way leaves storage describing what is actually
+     * still applied, and a retry does not repeat completed `down()` steps.
+     * Throws the failing `down()`'s error, a missing-`down()` error, or a
+     * {@link MigrationStorageError} if a checkpoint cannot be written.
+     */
+    rollback(targetVersion) {
+      return serialize(async () => {
+        const appliedVersion = getAppliedVersion();
+        const rolledBack = [];
+        if (!appliedVersion) {
+          return { rolledBack };
         }
-        await migration.down();
-        rolledBack.push(migration.version);
-      }
-      const storage = getStorage();
-      if (storage) {
-        if (targetVersion === "0.0.0") {
-          storage.removeItem(storageKey);
-        } else {
-          storage.setItem(storageKey, targetVersion);
+        const toRollback = sortedMigrations.filter((m) => compareSemVer(m.version, targetVersion) > 0 && compareSemVer(m.version, appliedVersion) <= 0).reverse();
+        for (const migration of toRollback) {
+          if (!migration.down) {
+            throw new Error(
+              `[Versioning] Migration ${migration.version} ("${migration.description}") does not have a down() function and cannot be rolled back.`
+            );
+          }
         }
-      }
-      return { rolledBack };
+        for (const migration of toRollback) {
+          await migration.down();
+          rolledBack.push(migration.version);
+          const index = sortedMigrations.indexOf(migration);
+          const previous = index > 0 ? sortedMigrations[index - 1].version : null;
+          writeApplied(previous, migration.version);
+        }
+        writeApplied(targetVersion === "0.0.0" ? null : targetVersion, targetVersion);
+        return { rolledBack };
+      });
     }
   };
 }
@@ -5589,6 +5923,7 @@ function extractRangeTarget(range) {
 }
 
 // src/plugins/startup.ts
+init_errors();
 init_ssr();
 function preloadCritical(resources) {
   if (typeof document === "undefined") return;
@@ -5609,28 +5944,43 @@ function preloadCritical(resources) {
     document.head.appendChild(link2);
   }
 }
-function prerenderRoutes(routes, options) {
-  const maxCacheSize = options?.maxCacheSize ?? 50;
-  const cacheTTL = options?.cacheTTL ?? 0;
-  const cache = /* @__PURE__ */ new Map();
-  function isValid(entry) {
-    if (cacheTTL === 0) return true;
-    return Date.now() - entry.timestamp < cacheTTL;
+function assertCacheSize(name, value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new RangeError(`[Startup] ${name} must be a non-negative integer, got ${value}`);
+  }
+}
+function makeRoomFor(cache, key, maxSize, isValid) {
+  if (maxSize === 0) return false;
+  if (cache.has(key)) return true;
+  if (cache.size < maxSize) return true;
+  for (const [k, entry] of cache) {
+    if (!isValid(entry)) cache.delete(k);
   }
-  function evictOldest() {
-    if (cache.size < maxCacheSize) return;
+  while (cache.size >= maxSize) {
     let oldestKey = null;
     let oldestTime = Infinity;
-    for (const [key, entry] of cache) {
+    for (const [k, entry] of cache) {
       if (entry.timestamp < oldestTime) {
         oldestTime = entry.timestamp;
-        oldestKey = key;
+        oldestKey = k;
       }
     }
-    if (oldestKey) cache.delete(oldestKey);
+    if (oldestKey === null) break;
+    cache.delete(oldestKey);
+  }
+  return true;
+}
+function prerenderRoutes(routes, options) {
+  const maxCacheSize = options?.maxCacheSize ?? 50;
+  const cacheTTL = options?.cacheTTL ?? 0;
+  assertCacheSize("maxCacheSize", maxCacheSize);
+  const cache = /* @__PURE__ */ new Map();
+  function isValid(entry) {
+    if (cacheTTL === 0) return true;
+    return Date.now() - entry.timestamp < cacheTTL;
   }
   for (const route2 of routes) {
-    evictOldest();
+    if (!makeRoomFor(cache, route2.path, maxCacheSize, isValid)) break;
     const html2 = renderToString(route2.component());
     cache.set(route2.path, { html: html2, timestamp: Date.now() });
   }
@@ -5682,6 +6032,7 @@ function prerenderRoutes(routes, options) {
 function createSSRCache(config) {
   const maxSize = config?.maxSize ?? 100;
   const defaultTTL = config?.defaultTTL ?? 6e4;
+  assertCacheSize("maxSize", maxSize);
   const cache = /* @__PURE__ */ new Map();
   let hits = 0;
   let misses = 0;
@@ -5689,18 +6040,6 @@ function createSSRCache(config) {
     if (entry.ttl === 0) return true;
     return Date.now() - entry.timestamp < entry.ttl;
   }
-  function evictOldest() {
-    if (cache.size < maxSize) return;
-    let oldestKey = null;
-    let oldestTime = Infinity;
-    for (const [key, entry] of cache) {
-      if (entry.timestamp < oldestTime) {
-        oldestTime = entry.timestamp;
-        oldestKey = key;
-      }
-    }
-    if (oldestKey) cache.delete(oldestKey);
-  }
   return {
     /** Get cached HTML for a key, or undefined if not cached or expired */
     get(key) {
@@ -5719,7 +6058,7 @@ function createSSRCache(config) {
     },
     /** Cache an HTML string with an optional TTL override */
     set(key, html2, ttl) {
-      evictOldest();
+      if (!makeRoomFor(cache, key, maxSize, isValid)) return;
       cache.set(key, {
         html: html2,
         timestamp: Date.now(),
@@ -5752,25 +6091,30 @@ function createSSRCache(config) {
     }
   };
 }
+var DEFER_IDLE_TIMEOUT_MS = 2e3;
 function deferNonCritical(tasks) {
   if (tasks.length === 0) return;
-  const schedule = typeof requestIdleCallback !== "undefined" ? requestIdleCallback : (cb) => setTimeout(cb, 1);
+  const schedule = typeof requestIdleCallback !== "undefined" ? (cb) => {
+    requestIdleCallback(cb, { timeout: DEFER_IDLE_TIMEOUT_MS });
+  } : (cb) => {
+    setTimeout(cb, 1);
+  };
   const queue = [...tasks];
   let index = 0;
   function processNext(deadline) {
+    let ranOne = false;
     while (index < queue.length) {
-      if (deadline && deadline.timeRemaining() < 1) {
+      if (ranOne && deadline && deadline.timeRemaining() < 1) {
         schedule(processNext);
         return;
       }
       try {
         queue[index]();
       } catch (e) {
-        if (typeof console !== "undefined") {
-          console.error("[Startup] Deferred task failed:", e);
-        }
+        reportError(e, { phase: "scheduler", name: "deferNonCritical" });
       }
       index++;
+      ranOne = true;
     }
   }
   schedule(processNext);
@@ -5822,7 +6166,9 @@ function createBootSequence() {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KeepAliveRoute,
+  MigrationStorageError,
   Outlet,
+  PluginInstallCancelledError,
   Route,
   RouterLink,
   SibuRouter,
@@ -5866,6 +6212,7 @@ function createBootSequence() {
   healthCheck,
   hydrateRouter,
   inject,
+  isPluginInstallCancelledError,
   lazy,
   lazyModule,
   navigate,