sibujs 4.5.0 → 4.7.0

package/dist/{chunk-KKLW7YWL.js → chunk-4AWA2PVD.js}

@@ -1,39 +1,54 @@
 import {
   renderToString
-} from "./chunk-NIOYEGBQ.js";
+} from "./chunk-HURREPU2.js";
+import {
+  globalSingleton
+} from "./chunk-7ZHH77QA.js";
+import {
+  reportError
+} from "./chunk-NYNYSPK7.js";
 
 // 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) {
@@ -68,7 +83,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;
       }
     }
@@ -96,46 +111,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.7.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;
   }
 };
@@ -260,29 +312,26 @@ var env = {
 };
 
 // src/plugins/versioning.ts
-var VERSION = "1.0.0";
+var VERSION = true ? "4.7.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 main;
-  let prerelease;
-  if (prereleaseIndex !== -1) {
-    main = trimmed.slice(0, prereleaseIndex);
-    prerelease = trimmed.slice(prereleaseIndex + 1);
-  } else {
-    main = trimmed;
-  }
-  const parts = main.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(a, b) {
@@ -365,82 +414,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((a, b) => compareSemVer(a.version, b.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 };
+      });
     }
   };
 }
@@ -490,28 +611,43 @@ function preloadCritical(resources) {
     document.head.appendChild(link);
   }
 }
-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 route of routes) {
-    evictOldest();
+    if (!makeRoomFor(cache, route.path, maxCacheSize, isValid)) break;
     const html = renderToString(route.component());
     cache.set(route.path, { html, timestamp: Date.now() });
   }
@@ -563,6 +699,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;
@@ -570,18 +707,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) {
@@ -600,7 +725,7 @@ function createSSRCache(config) {
     },
     /** Cache an HTML string with an optional TTL override */
     set(key, html, ttl) {
-      evictOldest();
+      if (!makeRoomFor(cache, key, maxSize, isValid)) return;
       cache.set(key, {
         html,
         timestamp: Date.now(),
@@ -633,25 +758,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);
@@ -714,6 +844,7 @@ export {
   parseSemVer,
   compareSemVer,
   satisfies,
+  MigrationStorageError,
   createMigrationRunner,
   checkCompatibility,
   preloadCritical,

package/dist/chunk-5HZXGZ6T.js

@@ -0,0 +1,24 @@
+// 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);
+      }
+    });
+  });
+}
+
+export {
+  adoptThenable
+};

package/dist/{chunk-PCT43HW3.js → chunk-7LUJQAOJ.js}

@@ -1,7 +1,7 @@
 import {
   SVG_NS,
   tagFactory
-} from "./chunk-KEISJXBU.js";
+} from "./chunk-UOL2ECCS.js";
 
 // src/core/rendering/html.ts
 var html = tagFactory("html");

package/dist/{chunk-5DXA2J44.js → chunk-7XHATCIH.js}

@@ -1,7 +1,7 @@
 import {
   __require,
   devWarn
-} from "./chunk-2WLZ6757.js";
+} from "./chunk-NYNYSPK7.js";
 
 // src/core/ssr-context.ts
 var SSR_KEY = /* @__PURE__ */ Symbol.for("sibujs.ssr.v1");
@@ -74,16 +74,18 @@ function disableSSR() {
   getSSRStore().ssr = false;
 }
 function runInSSRContext(fn) {
-  const store = { ssr: true, suspenseIdCounter: 0, locale: void 0 };
+  const store = { ssr: true, suspenseIdCounter: 0, idCounter: 0, locale: void 0 };
   if (als) {
     return als.run(store, fn);
   }
   warnMissingAsyncLocalStorage();
   const prevSSR = fallbackStore.ssr;
   const prevCounter = fallbackStore.suspenseIdCounter;
+  const prevIdCounter = fallbackStore.idCounter;
   const prevLocale = fallbackStore.locale;
   fallbackStore.ssr = true;
   fallbackStore.suspenseIdCounter = 0;
+  fallbackStore.idCounter = 0;
   fallbackStore.locale = void 0;
   _shared.fallbackDepth++;
   try {
@@ -92,6 +94,7 @@ function runInSSRContext(fn) {
     _shared.fallbackDepth--;
     fallbackStore.ssr = prevSSR;
     fallbackStore.suspenseIdCounter = prevCounter;
+    fallbackStore.idCounter = prevIdCounter;
     fallbackStore.locale = prevLocale;
   }
 }