sibujs 1.5.0 → 2.1.0

package/dist/{chunk-NHUC2QWH.js → chunk-CWBVQML6.js}

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

package/dist/{chunk-XHK6BDAJ.js → chunk-DRUZZAK4.js}

@@ -1,16 +1,18 @@
 import {
   recordDependency,
+  retrack,
   track,
   trackingSuspended
-} from "./chunk-K4G4ZQNR.js";
+} from "./chunk-QO3WC6FS.js";
 import {
   devAssert
-} from "./chunk-5X6PP2UK.js";
+} from "./chunk-LMLD24FC.js";
 
 // src/core/signals/derived.ts
 function derived(getter, options) {
   devAssert(typeof getter === "function", "derived: argument must be a getter function.");
   const debugName = options?.name;
+  const equals = options?.equals;
   const cs = {};
   cs._d = false;
   cs._g = getter;
@@ -21,8 +23,14 @@ function derived(getter, options) {
   markDirty._c = 1;
   markDirty._sig = cs;
   track(() => {
-    cs._d = false;
-    cs._v = getter();
+    let threw = true;
+    try {
+      cs._v = getter();
+      cs._d = false;
+      threw = false;
+    } finally {
+      if (threw) cs._d = true;
+    }
   }, markDirty);
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
   let evaluating = false;
@@ -35,11 +43,16 @@ function derived(getter, options) {
     if (trackingSuspended) {
       if (cs._d) {
         evaluating = true;
+        let threw = true;
         try {
-          cs._d = false;
-          cs._v = getter();
+          retrack(() => {
+            cs._v = getter();
+            cs._d = false;
+            threw = false;
+          }, markDirty);
         } finally {
           evaluating = false;
+          if (threw) cs._d = true;
         }
       }
       return cs._v;
@@ -48,13 +61,17 @@ function derived(getter, options) {
     if (cs._d) {
       const oldValue = cs._v;
       evaluating = true;
+      let threw = true;
       try {
-        track(() => {
+        retrack(() => {
+          const next = getter();
+          cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
           cs._d = false;
-          cs._v = getter();
+          threw = false;
         }, markDirty);
       } finally {
         evaluating = false;
+        if (threw) cs._d = true;
       }
       if (hook && oldValue !== cs._v) {
         hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });

package/dist/{chunk-RJ46C3CS.js → chunk-GWWURC5M.js}

@@ -1,10 +1,10 @@
 import {
   effect
-} from "./chunk-VQNQZCWJ.js";
+} from "./chunk-WZA53FXU.js";
 import {
   batch,
   signal
-} from "./chunk-NZIIMDWI.js";
+} from "./chunk-RDTDJCAB.js";
 
 // src/browser/media.ts
 function media(query) {
@@ -399,7 +399,10 @@ function dropZone(element, options) {
         const raw = e.dataTransfer.getData("application/json");
         if (raw) {
           try {
-            transferData = JSON.parse(raw);
+            transferData = JSON.parse(
+              raw,
+              (k, v) => k === "__proto__" || k === "constructor" || k === "prototype" ? void 0 : v
+            );
           } catch {
             transferData = raw;
           }
@@ -779,13 +782,21 @@ function wakeLock() {
   }
   const onVisibility = () => {
     if (sentinel?.released && !document.hidden) {
-      void request();
+      request().catch((err) => {
+        if (typeof console !== "undefined") {
+          console.warn("[SibuJS wakeLock] re-acquire failed:", err);
+        }
+      });
     }
   };
   document.addEventListener("visibilitychange", onVisibility);
   function dispose() {
     document.removeEventListener("visibilitychange", onVisibility);
-    void release();
+    release().catch((err) => {
+      if (typeof console !== "undefined") {
+        console.warn("[SibuJS wakeLock] release failed:", err);
+      }
+    });
   }
   return { active, request, release, dispose };
 }
@@ -981,11 +992,21 @@ function speech() {
     };
   }
   const synth = window.speechSynthesis;
-  const interval = setInterval(() => {
-    setSpeaking(synth.speaking);
-    setPaused(synth.paused);
-  }, 200);
+  let interval = null;
+  function startPolling() {
+    if (interval !== null) return;
+    interval = setInterval(() => {
+      setSpeaking(synth.speaking);
+      setPaused(synth.paused);
+      if (!synth.speaking && !synth.paused) {
+        clearInterval(interval);
+        interval = null;
+      }
+    }, 200);
+  }
+  let disposed = false;
   function speak(text, options = {}) {
+    if (disposed) return;
     const u = new SpeechSynthesisUtterance(text);
     if (options.lang) u.lang = options.lang;
     if (options.rate != null) u.rate = options.rate;
@@ -996,19 +1017,41 @@ function speech() {
       const match = voices.find((v) => v.name === options.voice);
       if (match) u.voice = match;
     }
-    u.addEventListener("start", () => setSpeaking(true));
-    u.addEventListener("end", () => {
-      setSpeaking(false);
-      setPaused(false);
-    });
-    u.addEventListener("error", () => {
-      setSpeaking(false);
-      setPaused(false);
-    });
+    u.addEventListener(
+      "start",
+      () => {
+        if (!disposed) setSpeaking(true);
+      },
+      { once: true }
+    );
+    u.addEventListener(
+      "end",
+      () => {
+        if (disposed) return;
+        setSpeaking(false);
+        setPaused(false);
+      },
+      { once: true }
+    );
+    u.addEventListener(
+      "error",
+      () => {
+        if (disposed) return;
+        setSpeaking(false);
+        setPaused(false);
+      },
+      { once: true }
+    );
     synth.speak(u);
+    setSpeaking(true);
+    startPolling();
   }
   function dispose() {
-    clearInterval(interval);
+    disposed = true;
+    if (interval !== null) {
+      clearInterval(interval);
+      interval = null;
+    }
     synth.cancel();
   }
   return {
@@ -1237,13 +1280,21 @@ function imageLoader(src) {
     };
     img.src = url;
   }
+  let srcEffectTeardown = null;
   if (typeof src === "function") {
-    start(src());
+    srcEffectTeardown = effect(() => {
+      const url = src();
+      start(url);
+    });
   } else {
     start(src);
   }
   function dispose() {
     disposed = true;
+    if (srcEffectTeardown) {
+      srcEffectTeardown();
+      srcEffectTeardown = null;
+    }
     if (current) {
       current.onload = null;
       current.onerror = null;

package/dist/{chunk-3X2YG6YM.js → chunk-JYD2PWXH.js}

@@ -1,9 +1,12 @@
 import {
   sanitizeUrl
-} from "./chunk-CMBFNA7L.js";
+} from "./chunk-UCS6AMJ7.js";
+import {
+  getSSRStore
+} from "./chunk-2RA7SHDA.js";
 import {
   isDev
-} from "./chunk-5X6PP2UK.js";
+} from "./chunk-LMLD24FC.js";
 
 // src/platform/ssr.ts
 var _isDev = isDev();
@@ -123,7 +126,7 @@ function hydrate(component, container, options = {}) {
         options.onMismatch(first);
       } else if (_isDev) {
         console.warn(
-          `[Sibu hydration] ${first.message}
+          `[SibuJS hydration] ${first.message}
   at ${first.path}
   server: ${first.serverValue}
   client: ${first.clientValue}`
@@ -131,17 +134,9 @@ function hydrate(component, container, options = {}) {
       }
     }
   }
-  hydrateNode(container.firstElementChild, clientTree);
+  container.replaceChildren(clientTree);
   container.setAttribute("data-sibu-hydrated", "true");
 }
-function hydrateNode(serverNode, clientNode) {
-  if (!serverNode) return;
-  const serverChildren = Array.from(serverNode.children);
-  const clientChildren = Array.from(clientNode.children);
-  for (let i = 0; i < Math.min(serverChildren.length, clientChildren.length); i++) {
-    hydrateNode(serverChildren[i], clientChildren[i]);
-  }
-}
 function collectMismatches(serverNode, clientNode, path, out, max = 5) {
   if (out.length >= max) return;
   const nodePath = path || clientNode?.tagName?.toLowerCase() || "(root)";
@@ -371,12 +366,16 @@ function renderToReadableStream(element) {
         controller.enqueue(value);
       }
     },
-    cancel() {
-      generator.return(void 0);
+    async cancel() {
+      await generator.return(void 0);
     }
   });
 }
+var SAFE_ID = /^[A-Za-z0-9_-]+$/;
 function island(id, component) {
+  if (!SAFE_ID.test(id)) {
+    throw new Error(`[SibuJS SSR] island: id must match [A-Za-z0-9_-]+ (got: ${JSON.stringify(id.slice(0, 32))})`);
+  }
   const el = component();
   el.setAttribute("data-sibu-island", id);
   return el;
@@ -389,8 +388,9 @@ function hydrateIslands(container, islands) {
     const factory = islands[id];
     if (typeof factory !== "function") continue;
     const clientTree = factory();
-    hydrateNode(marker, clientTree);
-    marker.setAttribute("data-sibu-hydrated", "true");
+    clientTree.setAttribute("data-sibu-island", id);
+    clientTree.setAttribute("data-sibu-hydrated", "true");
+    marker.replaceWith(clientTree);
   }
   container.setAttribute("data-sibu-hydrated", "partial");
 }
@@ -407,8 +407,9 @@ function hydrateProgressively(container, islands, options) {
         for (const entry of entries) {
           if (entry.isIntersecting) {
             const clientTree = factory();
-            hydrateNode(marker, clientTree);
-            marker.setAttribute("data-sibu-hydrated", "true");
+            clientTree.setAttribute("data-sibu-island", id);
+            clientTree.setAttribute("data-sibu-hydrated", "true");
+            marker.replaceWith(clientTree);
             observer.disconnect();
             break;
           }
@@ -424,20 +425,37 @@ function hydrateProgressively(container, islands, options) {
     for (const cleanup of cleanups) cleanup();
   };
 }
-var suspenseIdCounter = 0;
 function resetSSRState() {
-  suspenseIdCounter = 0;
+  getSSRStore().suspenseIdCounter = 0;
+}
+function noop() {
 }
 function ssrSuspense(props) {
-  const id = `sibu-sus-${suspenseIdCounter++}`;
+  const store = getSSRStore();
+  const id = `sibu-sus-${store.suspenseIdCounter++}`;
+  const timeoutMs = props.timeoutMs ?? 3e4;
   const fallbackEl = props.fallback();
   const wrapper = document.createElement("div");
   wrapper.setAttribute("data-sibu-suspense-id", id);
   wrapper.appendChild(fallbackEl);
-  const promise = props.content().then((resolvedEl) => ({
-    id,
-    html: renderToString(resolvedEl)
-  }));
+  const fallbackHtml = renderToString(fallbackEl);
+  let timer;
+  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]);
+  const promise = raced.then(
+    (resolvedEl) => {
+      if (timer) clearTimeout(timer);
+      return { id, html: renderToString(resolvedEl) };
+    },
+    (err) => {
+      if (timer) clearTimeout(timer);
+      if (_isDev) console.warn("[SibuJS SSR] ssrSuspense rejected:", err);
+      return { id, html: fallbackHtml };
+    }
+  );
+  promise.catch(noop);
   return { element: wrapper, promise };
 }
 var SAFE_SUSPENSE_ID = /^[A-Za-z0-9_-]+$/;
@@ -465,14 +483,27 @@ var SSR_DATA_ATTR = "__SIBU_SSR_DATA__";
 function escapeScriptJson(json) {
   return json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
-function serializeState(state, nonce) {
-  const json = escapeScriptJson(JSON.stringify(state));
+var DEFAULT_MAX_SSR_BYTES = 1024 * 1024;
+function serializeState(state, nonce, options) {
+  const rawJson = JSON.stringify(state);
+  const maxBytes = options?.maxBytes ?? DEFAULT_MAX_SSR_BYTES;
+  const byteLen = typeof TextEncoder !== "undefined" ? new TextEncoder().encode(rawJson).byteLength : Buffer.byteLength(rawJson, "utf8");
+  if (byteLen > maxBytes) {
+    throw new Error(`[SibuJS SSR] serializeState: payload (${byteLen} bytes) exceeds maxBytes (${maxBytes})`);
+  }
+  const json = escapeScriptJson(rawJson);
   const nonceAttr = nonce ? ` nonce="${escapeAttr(nonce)}"` : "";
   return `<script${nonceAttr}>window.${SSR_DATA_ATTR}=${json}</script>`;
 }
 function deserializeState(validate) {
   if (typeof window === "undefined") return void 0;
-  const raw = window[SSR_DATA_ATTR];
+  if (_isDev && !validate) {
+    console.warn(
+      "[SibuJS SSR] deserializeState() called without a validate guard \u2014 tampered SSR payloads will not be detected."
+    );
+  }
+  const w = window;
+  const raw = w[SSR_DATA_ATTR];
   if (raw === void 0) return void 0;
   if (validate && !validate(raw)) return void 0;
   return raw;