sibujs 3.4.1 → 4.0.0

package/dist/{chunk-BQLVTAUZ.js → chunk-ACBT6UZS.js}

@@ -1,10 +1,10 @@
 import {
   devWarn,
-  isDev
-} from "./chunk-COY6PUD2.js";
+  isDev,
+  reportError
+} from "./chunk-VPP2FONR.js";
 
 // src/reactivity/track-core.ts
-var _isDev = isDev();
 var POOL_MAX = 4096;
 var nodePool = [];
 function createNode() {
@@ -12,6 +12,7 @@ function createNode() {
     sig: null,
     sub: null,
     epoch: 0,
+    depVersion: 0,
     sigPrev: null,
     sigNext: null,
     subPrev: null,
@@ -96,8 +97,27 @@ function safeInvoke(sub) {
   try {
     sub();
   } catch (err) {
-    if (_isDev) devWarn(`Subscriber threw during notification: ${err instanceof Error ? err.message : String(err)}`);
+    const s = sub;
+    reportError(err, { phase: s._errorPhase ?? "effect", name: s.__name, node: s._errorNode });
+  }
+}
+function depsChanged(sub) {
+  let node = sub.depsHead ?? null;
+  if (node === null) return true;
+  while (node !== null) {
+    const sig = node.sig;
+    if (sig === null) return true;
+    if (sig._d === true && sig._validate !== void 0) {
+      try {
+        sig._validate();
+      } catch {
+        return true;
+      }
+    }
+    if (node.depVersion !== sig.__v) return true;
+    node = node.subNext;
   }
+  return false;
 }
 var suspendDepth = 0;
 var trackingSuspended = false;
@@ -179,7 +199,7 @@ function track(effectFn, subscriber) {
   const sub = subscriber;
   return sub._dispose ?? (sub._dispose = () => cleanup(subscriber));
 }
-function reactiveBinding(commit) {
+function reactiveBinding(commit, ownerNode) {
   const run = () => {
     const s = subscriber;
     if (s._disposed || s._reentrant) return;
@@ -195,13 +215,17 @@ function reactiveBinding(commit) {
   subscriber.depsTail = null;
   subscriber._epoch = 0;
   subscriber._structDirty = false;
+  subscriber._hasComputedDep = false;
   subscriber._runEpoch = 0;
   subscriber._runs = 0;
   subscriber._reentrant = false;
   subscriber._disposed = false;
+  subscriber._errorPhase = "binding";
+  subscriber._errorNode = ownerNode;
   run();
   return subscriber._dispose ?? (subscriber._dispose = () => {
     subscriber._disposed = true;
+    subscriber._errorNode = void 0;
     cleanup(subscriber);
   });
 }
@@ -213,9 +237,12 @@ function recordDependency(signal) {
   const active = sig.__activeNode ?? null;
   if (active !== null && active.sub === sub) {
     active.epoch = epoch;
+    active.depVersion = sig.__v ?? Number.NaN;
     return;
   }
+  if (sig._validate !== void 0) sub._hasComputedDep = true;
   const node = allocNode(signal, sub, epoch);
+  node.depVersion = sig.__v ?? Number.NaN;
   node.prevActive = active;
   sig.__activeNode = node;
   linkSub(sub, node);
@@ -234,9 +261,10 @@ function cleanup(subscriber) {
     node = next;
   }
 }
-var maxSubscriberRepeats = 50;
+var maxSubscriberRepeats = 1e3;
 var maxDrainIterations = 1e6;
 var drainEpoch = 0;
+var quarantined = /* @__PURE__ */ new Set();
 function setMaxSubscriberRepeats(n) {
   const prev = maxSubscriberRepeats;
   if (Number.isFinite(n) && n > 0) maxSubscriberRepeats = Math.floor(n);
@@ -258,19 +286,21 @@ function tickRepeat(sub) {
   return s._runs > maxSubscriberRepeats;
 }
 function cycleError(sub) {
-  if (typeof console !== "undefined") {
-    const name = sub.__name ?? "<unnamed>";
-    console.error(
-      `[SibuJS] subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. Breaking to prevent infinite loop.`
-    );
-  }
+  const name = sub.__name ?? "<unnamed>";
+  reportError(
+    new Error(
+      `subscriber "${name}" fired more than ${maxSubscriberRepeats} times \u2014 likely a write-reads-self cycle between effects/signals. This subscriber is quarantined for the rest of this update; other pending work still runs.`
+    ),
+    { phase: "scheduler", name }
+  );
 }
 function absoluteDrainError() {
-  if (typeof console !== "undefined") {
-    console.error(
-      `[SibuJS] Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
-    );
-  }
+  reportError(
+    new Error(
+      `Notification drain exceeded ${maxDrainIterations} iterations \u2014 absolute safety net tripped. Breaking to prevent infinite loop.`
+    ),
+    { phase: "scheduler" }
+  );
 }
 function drainQueue() {
   let i = 0;
@@ -280,11 +310,14 @@ function drainQueue() {
       break;
     }
     const sub = pendingQueue[i++];
+    pendingSet.delete(sub);
+    if (quarantined.size > 0 && quarantined.has(sub)) continue;
+    if (sub._hasComputedDep === true && !depsChanged(sub)) continue;
     if (tickRepeat(sub)) {
       cycleError(sub);
-      break;
+      quarantined.add(sub);
+      continue;
     }
-    pendingSet.delete(sub);
     safeInvoke(sub);
   }
 }
@@ -299,6 +332,7 @@ function drainNotificationQueue() {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -392,6 +426,7 @@ function notifySubscribers(signal) {
     if (notifyDepth === 0) {
       pendingQueue.length = 0;
       pendingSet.clear();
+      if (quarantined.size > 0) quarantined.clear();
     }
   }
 }
@@ -418,14 +453,14 @@ function forEachSubscriber(signal, visit) {
 }
 
 // src/reactivity/track.ts
-var _isDev2 = isDev();
-var _runtimeVersion = true ? "3.4.1" : "dev";
+var _isDev = isDev();
+var _runtimeVersion = true ? "4.0.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
   const existing = g[REGISTRY_KEY];
   if (existing) {
-    if (_isDev2 && !existing.__dupWarned) {
+    if (_isDev && !existing.__dupWarned) {
       existing.__dupWarned = true;
       devWarn(
         `Multiple instances of the reactive runtime detected on this page (active: ${existing.version}, duplicate: ${_runtimeVersion}). Reactivity still works \u2014 all copies share the first one \u2014 but de-duplicate sibujs in your bundler (e.g. Vite optimizeDeps.exclude: ['sibujs'] or resolve.dedupe: ['sibujs']).`

package/dist/{chunk-F7HW2NI5.js → chunk-AW6HPJ3L.js}

@@ -1,6 +1,6 @@
 import {
   renderToString
-} from "./chunk-EX77FXTT.js";
+} from "./chunk-HYCCIYNS.js";
 
 // src/plugins/modular.ts
 function createModuleRegistry() {

package/dist/chunk-DHDZ7IVN.js

@@ -0,0 +1,109 @@
+import {
+  devWarn,
+  isDev,
+  reportError
+} from "./chunk-VPP2FONR.js";
+
+// src/core/rendering/dispose.ts
+var elementDisposers = /* @__PURE__ */ new WeakMap();
+var MAX_DRAIN_TEARDOWNS = 1e4;
+function reportDrainRunaway(label, executed, remaining) {
+  if (typeof console === "undefined") return;
+  console.error(
+    `[SibuJS ${label}] runaway cleanup: stopped after running ${executed} teardowns with ${remaining} still queued. Cleanup production did not stabilize before the teardown safety ceiling was reached \u2014 the remaining work was NOT run.`,
+    { executed, remaining }
+  );
+}
+var _isDev = isDev();
+var activeBindingCount = 0;
+function registerDisposer(node, teardown) {
+  let disposers = elementDisposers.get(node);
+  if (!disposers) {
+    disposers = [];
+    elementDisposers.set(node, disposers);
+  }
+  disposers.push(teardown);
+  if (_isDev) activeBindingCount++;
+}
+function unregisterDisposer(node, teardown) {
+  const disposers = elementDisposers.get(node);
+  if (!disposers) return;
+  const index = disposers.indexOf(teardown);
+  if (index === -1) return;
+  disposers.splice(index, 1);
+  if (_isDev) activeBindingCount--;
+  if (disposers.length === 0) elementDisposers.delete(node);
+}
+function dispose(node) {
+  const stack = [node];
+  const order = [];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    order.push(current);
+    const children = Array.from(current.childNodes);
+    for (let i = 0; i < children.length; i++) {
+      stack.push(children[i]);
+    }
+  }
+  for (let i = order.length - 1; i >= 0; i--) {
+    const current = order[i];
+    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 (_isDev) 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(current);
+            elementDisposers.set(current, added ? rest.concat(added) : rest);
+            if (_isDev) 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" });
+          }
+        }
+      }
+    }
+  }
+}
+function replaceChildrenSafely(parent, ...next) {
+  for (let i = 0; i < next.length; i++) {
+    const node = next[i];
+    node.parentNode?.removeChild(node);
+  }
+  const current = Array.from(parent.childNodes);
+  for (let i = 0; i < current.length; i++) {
+    dispose(current[i]);
+  }
+  parent.replaceChildren(...next);
+}
+function checkLeaks(warnThreshold = 0) {
+  if (!_isDev) return 0;
+  if (warnThreshold > 0 && activeBindingCount > warnThreshold) {
+    devWarn(
+      `checkLeaks: ${activeBindingCount} active DOM bindings detected. Expected \u2264${warnThreshold}. This may indicate a component was removed from the DOM without calling dispose().`
+    );
+  }
+  return activeBindingCount;
+}
+
+export {
+  MAX_DRAIN_TEARDOWNS,
+  reportDrainRunaway,
+  registerDisposer,
+  unregisterDisposer,
+  dispose,
+  replaceChildrenSafely,
+  checkLeaks
+};

package/dist/{chunk-NXR2YFZB.js → chunk-DQVUBVNX.js}

@@ -1,23 +1,25 @@
 import {
-  bindAttribute
-} from "./chunk-DLBFEAIS.js";
+  bindAttribute,
+  setSafeAttribute
+} from "./chunk-4MFZMLUU.js";
 import {
   isEventHandlerAttr,
-  sanitizeAttributeString,
-  sanitizeCSSValue
-} from "./chunk-L3GAGWCC.js";
+  sanitizeCSSValue,
+  sanitizeStyleAttribute
+} from "./chunk-5INI7D2L.js";
 import {
   dispose,
   registerDisposer
-} from "./chunk-5VGSK6D2.js";
+} from "./chunk-DHDZ7IVN.js";
 import {
   reactiveBinding,
   track
-} from "./chunk-BQLVTAUZ.js";
+} from "./chunk-ACBT6UZS.js";
 import {
   devWarn,
-  isDev
-} from "./chunk-COY6PUD2.js";
+  isDev,
+  reportError
+} from "./chunk-VPP2FONR.js";
 
 // src/reactivity/bindChildNode.ts
 var _isDev = isDev();
@@ -28,7 +30,7 @@ function bindChildNode(placeholder, getter) {
     try {
       result = getter();
     } catch (err) {
-      if (_isDev) devWarn(`bindChildNode: getter threw: ${err instanceof Error ? err.message : String(err)}`);
+      reportError(err, { phase: "binding", name: "bindChildNode", node: placeholder });
       return;
     }
     if (result == null || typeof result === "boolean") {
@@ -89,7 +91,7 @@ function bindChildNode(placeholder, getter) {
     }
     lastNodes = newNodes;
   }
-  return reactiveBinding(commit);
+  return reactiveBinding(commit, placeholder);
 }
 
 // src/core/rendering/tagFactory.ts
@@ -112,9 +114,6 @@ var CLOBBER_RISKY_IDS = /* @__PURE__ */ new Set([
   "self",
   "frames"
 ]);
-function setProp(el, key, val) {
-  el[key] = val;
-}
 function looksLikeClassList(s) {
   const t = s.trim();
   if (!t) return false;
@@ -138,13 +137,13 @@ function toKebab(prop) {
 function applyStyle(el, style) {
   if (typeof style === "function") {
     const teardown = track(() => {
-      el.setAttribute("style", style());
+      el.setAttribute("style", sanitizeStyleAttribute(String(style())));
     });
     registerDisposer(el, teardown);
     return;
   }
   if (typeof style === "string") {
-    el.setAttribute("style", style);
+    el.setAttribute("style", sanitizeStyleAttribute(style));
     return;
   }
   const htmlEl = el;
@@ -329,16 +328,8 @@ var tagFactory = (tag, ns) => {
           if (isEventHandlerAttr(key)) continue;
           if (typeof value === "function") {
             registerDisposer(el, bindAttribute(el, key, value));
-          } else if (typeof value === "boolean") {
-            if (key in el && (key === "checked" || key === "disabled" || key === "selected")) {
-              setProp(el, key, value);
-            } else if (value) {
-              el.setAttribute(key, "");
-            } else {
-              el.removeAttribute(key);
-            }
           } else {
-            el.setAttribute(key, sanitizeAttributeString(key, String(value)));
+            setSafeAttribute(el, key, value, { syncValueProperty: false, label: "tagFactory" });
           }
         }
       }