sibujs 4.6.0 → 4.8.0

package/dist/{chunk-47M47FOM.js → chunk-O6TRVMJI.js}

@@ -1,14 +1,20 @@
+import {
+  ContextualRefusal,
+  contextualAttributeRefusal,
+  settleAttributeProvenance
+} from "./chunk-3ACAAQIN.js";
 import {
   isEventHandlerAttr,
   isHtmlContentAttribute,
-  sanitizeAttributeString
-} from "./chunk-2INLLLMZ.js";
+  resolveAttributeValue
+} from "./chunk-EXXSN3BW.js";
 import {
   reactiveBinding
-} from "./chunk-5Q4R7HCL.js";
+} from "./chunk-TQQUN4WR.js";
 import {
   DEV,
   devWarn,
+  devWarnLazy,
   reportError
 } from "./chunk-NYNYSPK7.js";
 
@@ -21,6 +27,19 @@ var BOOLEAN_IDL_ATTRS = /* @__PURE__ */ new Set(["checked", "disabled", "selecte
 function isHtmlElement(el) {
   return el.namespaceURI === null || el.namespaceURI === HTML_NS;
 }
+function warnContextualRefusal(label, name, refusal) {
+  devWarnLazy(() => {
+    const reasons = [
+      "",
+      'the element would become a <meta http-equiv="refresh"> directive the shared refresh policy forbids (a destination outside the URL allowlist, or a directive too malformed to read unambiguously)',
+      "a <meta> whose http-equiv or content is reactive may never carry a refresh directive: a browser schedules the navigation as soon as the directive is valid, and nothing can withdraw it when the state changes back",
+      "a runtime value may not choose the program a <script> runs; name the script in static template source, or load it through Head({ script }) as an explicit trust decision",
+      "an SVG animation may not target a URL, event-handler or nested-document attribute; its to / values would be written into that attribute without passing the URL policy",
+      'a runtime-chosen href may not become an applied <link rel="stylesheet">: a well-formed URL is not a trusted stylesheet. Name the stylesheet in static template source, or load a runtime-chosen one through Head({ link }) as an explicit trust decision'
+    ];
+    return `${label}: refusing "${name}" in this element's context \u2014 ${reasons[refusal]}. The write was not performed.`;
+  });
+}
 function setProp(el, key, val) {
   el[key] = val;
 }
@@ -32,6 +51,11 @@ function namespaceFor(el, name) {
   return null;
 }
 function setSafeAttribute(el, name, value, options = {}) {
+  const written = commitSafeAttribute(el, name, value, options);
+  if (el.localName === "link") settleAttributeProvenance(el, name, options.reactive ? "reactive" : "runtime");
+  return written;
+}
+function commitSafeAttribute(el, name, value, options) {
   const ns = namespaceFor(el, name);
   const localName = ns ? name.slice(name.indexOf(":") + 1) : name;
   if (isEventHandlerAttr(name)) {
@@ -44,6 +68,14 @@ function setSafeAttribute(el, name, value, options = {}) {
     else el.removeAttribute(name);
     return false;
   }
+  const pending = value == null || value === false ? null : value === true ? "" : String(value);
+  const refusal = contextualAttributeRefusal(el, name, pending, options.reactive ? "reactive" : "runtime");
+  if (refusal !== ContextualRefusal.None) {
+    warnContextualRefusal(options.label ?? "setSafeAttribute", name, refusal);
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return false;
+  }
   if (value == null) {
     if (ns) el.removeAttributeNS(ns, localName);
     else el.removeAttribute(name);
@@ -87,13 +119,32 @@ function setSafeAttribute(el, name, value, options = {}) {
     setProp(el, idlName, idlName === "checked" ? Boolean(value) : str);
     return true;
   }
-  const safe = sanitizeAttributeString(name, str, { element: el });
+  const safe = str === "" ? "" : resolveAttributeValue(name, str, { element: el });
+  if (safe === null) {
+    if (ns) el.removeAttributeNS(ns, localName);
+    else el.removeAttribute(name);
+    return true;
+  }
   const current = ns ? el.getAttributeNS(ns, localName) : el.getAttribute(name);
   if (current === safe) return true;
   if (ns) el.setAttributeNS(ns, name, safe);
   else el.setAttribute(name, safe);
   return true;
 }
+function setTrustedAttribute(el, name, value) {
+  if (isHtmlContentAttribute(name)) {
+    if (DEV) devWarn(`html: refusing static attribute "${name}" \u2014 the browser parses it as a nested document.`);
+    return false;
+  }
+  const refusal = contextualAttributeRefusal(el, name, value, "static");
+  if (refusal !== ContextualRefusal.None) {
+    warnContextualRefusal("html (static attribute)", name, refusal);
+    return false;
+  }
+  el.setAttribute(name, value);
+  if (el.localName === "link") settleAttributeProvenance(el, name, "static");
+  return true;
+}
 
 // src/reactivity/bindAttribute.ts
 function bindAttribute(el, attr, getter) {
@@ -110,7 +161,7 @@ function bindAttribute(el, attr, getter) {
       reportError(err, { phase: "binding", name: `bindAttribute("${attr}")`, node: el });
       return;
     }
-    setSafeAttribute(el, attr, value, { label: `bindAttribute("${attr}")` });
+    setSafeAttribute(el, attr, value, { label: `bindAttribute("${attr}")`, reactive: true });
   }
   return reactiveBinding(commit, el);
 }
@@ -135,7 +186,7 @@ function bindDynamic(el, nameGetter, valueGetter) {
       el.removeAttribute(prevName);
       prevName = null;
     }
-    if (!setSafeAttribute(el, name, value, { label: "bindDynamic" })) return;
+    if (!setSafeAttribute(el, name, value, { label: "bindDynamic", reactive: true })) return;
     prevName = name;
   }
   const teardown = reactiveBinding(commit, el);
@@ -149,6 +200,7 @@ function bindDynamic(el, nameGetter, valueGetter) {
 
 export {
   setSafeAttribute,
+  setTrustedAttribute,
   bindAttribute,
   bindDynamic
 };

package/dist/{chunk-JSXPZCET.js → chunk-Q5J2LVKH.js}

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

package/dist/{chunk-5MT6SJ3P.js → chunk-QGMSESDD.js}

@@ -1,9 +1,12 @@
 import {
   renderToString
-} from "./chunk-HURREPU2.js";
+} from "./chunk-FC6KCJSA.js";
 import {
   globalSingleton
 } from "./chunk-7ZHH77QA.js";
+import {
+  sanitizeUrl
+} from "./chunk-EXXSN3BW.js";
 import {
   reportError
 } from "./chunk-NYNYSPK7.js";
@@ -167,7 +170,7 @@ var CDN_ENTRY_POINTS = {
 };
 var packageInfo = {
   name: "sibujs",
-  version: true ? "4.6.0" : "dev",
+  version: true ? "4.8.0" : "dev",
   entryPoints: MODULE_ENTRY_POINTS,
   /**
    * Generate the package.json `exports` map. Module entries resolve to the
@@ -312,7 +315,7 @@ var env = {
 };
 
 // src/plugins/versioning.ts
-var VERSION = true ? "4.6.0" : "dev";
+var VERSION = true ? "4.8.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-]+";
@@ -595,12 +598,14 @@ function extractRangeTarget(range) {
 function preloadCritical(resources) {
   if (typeof document === "undefined") return;
   for (const resource of resources) {
-    const safeHref = typeof CSS !== "undefined" && typeof CSS.escape === "function" ? CSS.escape(resource.href) : resource.href.replace(/["\\]/g, "\\$&");
+    const href = sanitizeUrl(resource.href);
+    if (!href) continue;
+    const safeHref = typeof CSS !== "undefined" && typeof CSS.escape === "function" ? CSS.escape(href) : href.replace(/["\\]/g, "\\$&");
     const existing = document.querySelector(`link[rel="preload"][href="${safeHref}"]`);
     if (existing) continue;
     const link = document.createElement("link");
     link.rel = "preload";
-    link.href = resource.href;
+    link.href = href;
     link.setAttribute("as", resource.as);
     if (resource.type) {
       link.type = resource.type;

package/dist/{chunk-AIF3Z2T7.js → chunk-RGLPEBDE.js}

@@ -1,17 +1,17 @@
 import {
   isUnsafeKey,
   stripUnsafeKeys
-} from "./chunk-H3SRKIYX.js";
+} from "./chunk-62BDYGAG.js";
 import {
   derived
-} from "./chunk-QE4TTDU3.js";
+} from "./chunk-KJ3UKABJ.js";
 import {
   effect
-} from "./chunk-XC4MEKGA.js";
+} from "./chunk-V3LHZSU5.js";
 import {
   batch,
   signal
-} from "./chunk-D33YTSX5.js";
+} from "./chunk-DSID757X.js";
 import {
   DEV,
   devWarn,
@@ -19,6 +19,9 @@ import {
 } from "./chunk-NYNYSPK7.js";
 
 // src/patterns/machine.ts
+function ownEntry(table, key) {
+  return Object.hasOwn(table, key) ? table[key] : void 0;
+}
 function machine(config) {
   const [state, setState] = signal(config.initial);
   const [context, setContext] = signal(config.context || {});
@@ -40,9 +43,9 @@ function machine(config) {
     }
   }
   function step(event) {
-    const stateDef = config.states[currentState];
+    const stateDef = ownEntry(config.states, currentState);
     if (!stateDef?.on) return;
-    const transition = stateDef.on[event];
+    const transition = ownEntry(stateDef.on, event);
     if (!transition) return;
     let target;
     let guard;
@@ -70,7 +73,7 @@ function machine(config) {
       if (action) setContext(nextContext);
       setState(target);
     });
-    const targetDef = config.states[target];
+    const targetDef = ownEntry(config.states, target);
     if (targetDef?.entry) {
       targetDef.entry(currentContext);
     }
@@ -80,7 +83,7 @@ function machine(config) {
     if (processing) return;
     drain();
   }
-  const initialDef = config.states[config.initial];
+  const initialDef = ownEntry(config.states, config.initial);
   if (initialDef?.entry) {
     processing = true;
     try {
@@ -98,9 +101,9 @@ function machine(config) {
   }
   function can(event) {
     const currentState2 = state();
-    const stateDef = config.states[currentState2];
+    const stateDef = ownEntry(config.states, currentState2);
     if (!stateDef?.on) return false;
-    const transition = stateDef.on[event];
+    const transition = ownEntry(stateDef.on, event);
     if (!transition) return false;
     if (typeof transition === "string") return true;
     if (transition.guard) {

package/dist/{chunk-5Q4R7HCL.js → chunk-TQQUN4WR.js}

@@ -498,7 +498,7 @@ function forEachSubscriber(signal, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.6.0" : "dev";
+var _runtimeVersion = true ? "4.8.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
@@ -554,6 +554,14 @@ var getSubscriberCount2 = API.getSubscriberCount;
 var getSubscriberDeps2 = API.getSubscriberDeps;
 var forEachSubscriber2 = API.forEachSubscriber;
 
+// src/core/devtoolsHook.ts
+function emitDevtools(hook, event, payload) {
+  try {
+    hook.emit(event, payload);
+  } catch {
+  }
+}
+
 export {
   suspendTracking2 as suspendTracking,
   resumeTracking2 as resumeTracking,
@@ -570,5 +578,6 @@ export {
   notifySubscribers2 as notifySubscribers,
   getSubscriberCount2 as getSubscriberCount,
   getSubscriberDeps2 as getSubscriberDeps,
-  forEachSubscriber2 as forEachSubscriber
+  forEachSubscriber2 as forEachSubscriber,
+  emitDevtools
 };

package/dist/{chunk-PK6FK2G2.js → chunk-UCNP3HVM.js}

@@ -1,22 +1,25 @@
 import {
   derived
-} from "./chunk-QE4TTDU3.js";
-import {
-  sanitizeUrl
-} from "./chunk-2INLLLMZ.js";
+} from "./chunk-KJ3UKABJ.js";
 import {
   globalSingleton
 } from "./chunk-7ZHH77QA.js";
 import {
   effect
-} from "./chunk-XC4MEKGA.js";
+} from "./chunk-V3LHZSU5.js";
+import {
+  sanitizeUrl
+} from "./chunk-EXXSN3BW.js";
 import {
   getRequestScopedCache
 } from "./chunk-7XHATCIH.js";
 import {
   batch,
   signal
-} from "./chunk-D33YTSX5.js";
+} from "./chunk-DSID757X.js";
+import {
+  untracked
+} from "./chunk-TQQUN4WR.js";
 import {
   reportError
 } from "./chunk-NYNYSPK7.js";
@@ -132,7 +135,87 @@ function waitForRetryDelay(delay, signal2) {
   });
 }
 
+// src/data/structuralSharing.ts
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isPlainArray(value) {
+  return Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype;
+}
+function reconcile(prev, next, depth, walk, newRoot) {
+  if (Object.is(prev, next)) return prev;
+  const arrays = isPlainArray(prev) && isPlainArray(next);
+  if (!arrays && !(isPlainObject(prev) && isPlainObject(next))) return next;
+  if (Object.getPrototypeOf(prev) !== Object.getPrototypeOf(next)) return next;
+  const nextObject = next;
+  const seenAt = walk.path.get(nextObject);
+  if (seenAt !== void 0) {
+    walk.cycleTo = Math.min(walk.cycleTo, seenAt);
+    return next;
+  }
+  const prevRecord = prev;
+  const nextRecord = next;
+  const nextKeys = arrays ? Array.from({ length: next.length }, (_, i) => i) : Object.keys(nextRecord);
+  const prevSize = arrays ? prev.length : Object.keys(prevRecord).length;
+  const copy = arrays ? new Array(nextKeys.length) : Object.create(Object.getPrototypeOf(next));
+  let allFromPrev = prevSize === nextKeys.length;
+  let allFromNext = true;
+  const outerCycleTo = walk.cycleTo;
+  walk.cycleTo = Number.POSITIVE_INFINITY;
+  walk.path.set(nextObject, depth);
+  for (const key of nextKeys) {
+    if (arrays && !Object.hasOwn(nextRecord, key)) {
+      if (Object.hasOwn(prevRecord, key)) allFromPrev = false;
+      continue;
+    }
+    const nextChild = nextRecord[key];
+    const hasPrev = Object.hasOwn(prevRecord, key);
+    const shared = hasPrev ? reconcile(prevRecord[key], nextChild, depth + 1, walk, false) : nextChild;
+    if (key === "__proto__") {
+      Object.defineProperty(copy, key, { value: shared, writable: true, enumerable: true, configurable: true });
+    } else {
+      copy[key] = shared;
+    }
+    if (!hasPrev || !Object.is(shared, prevRecord[key])) allFromPrev = false;
+    if (!Object.is(shared, nextChild)) allFromNext = false;
+  }
+  walk.path.delete(nextObject);
+  const reached = walk.cycleTo;
+  walk.cycleTo = Math.min(outerCycleTo, reached < depth ? reached : Number.POSITIVE_INFINITY);
+  if (reached <= depth) return next;
+  if (allFromPrev && !newRoot) return prev;
+  if (allFromNext) return next;
+  return copy;
+}
+function applyStructuralSharing(option, prev, next, explicit = false) {
+  if (option === false || prev === void 0) return next;
+  const forceNew = explicit && !Object.is(prev, next);
+  if (typeof option === "function") {
+    const shared = option(prev, next);
+    return forceNew && Object.is(shared, prev) ? next : shared;
+  }
+  return reconcile(prev, next, 0, { path: /* @__PURE__ */ new Map(), cycleTo: Number.POSITIVE_INFINITY }, forceNew);
+}
+
 // src/data/query.ts
+function shareSafely(option, prev, next, explicit) {
+  const shared = untracked(
+    () => runSelect("query structuralSharing", () => applyStructuralSharing(option, prev, next, explicit))
+  );
+  return shared.ok ? shared.value : next;
+}
+function sharedView(entry) {
+  const raw = entry.data;
+  if (raw === void 0) return void 0;
+  if (entry.hasShared && Object.is(entry.sharedFrom, raw)) return entry.shared;
+  const value = shareSafely(true, entry.hasShared ? entry.shared : void 0, raw, entry.explicit);
+  entry.shared = value;
+  entry.sharedFrom = raw;
+  entry.hasShared = true;
+  return value;
+}
 var globalQueryCache = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.query.cache.v1"), () => /* @__PURE__ */ new Map());
 function getActiveQueryCache() {
   return getRequestScopedCache("query") ?? globalQueryCache;
@@ -158,7 +241,11 @@ function getOrCreateEntry(cache, key, initialData) {
       listeners: /* @__PURE__ */ new Set(),
       refetchers: /* @__PURE__ */ new Set(),
       controller: null,
-      generation: 0
+      generation: 0,
+      explicit: false,
+      shared: void 0,
+      sharedFrom: void 0,
+      hasShared: false
     };
     cache.set(key, entry);
   }
@@ -177,13 +264,24 @@ function query(key, fetcher, options = {}) {
     onSuccess,
     onError,
     onSettled,
-    select
+    select,
+    structuralSharing = true
   } = options;
   const resolveKey = typeof key === "function" ? key : () => key;
   const cache = getActiveQueryCache();
   const [data, setData] = signal(initialData);
   const [isFetching, setIsFetching] = signal(false);
   const [error, setError] = signal(void 0);
+  const [updatedAt, setUpdatedAt] = signal(0);
+  const [base, setBase] = signal(void 0);
+  let baseEntry = null;
+  let baseValue;
+  let baseExplicit = false;
+  let customEntry = null;
+  let customFrom;
+  let customValue;
+  let selectedEntry = null;
+  let selectedValue;
   let disposed = false;
   let currentKey = null;
   let attachedEntry = null;
@@ -192,11 +290,57 @@ function query(key, fetcher, options = {}) {
   const loading = derived(() => isFetching() && data() === void 0);
   const isStale = derived(() => {
     data();
+    updatedAt();
     if (!currentKey) return true;
     const entry = cache.get(currentKey);
     if (!entry || entry.dataUpdatedAt === 0) return true;
     return Date.now() - entry.dataUpdatedAt >= staleTime;
   });
+  function viewOf(entry) {
+    const raw = entry.data;
+    if (raw === void 0) return void 0;
+    if (structuralSharing === false) return raw;
+    if (typeof structuralSharing !== "function") return sharedView(entry);
+    const sameEntry = customEntry === entry;
+    if (sameEntry && Object.is(customFrom, raw)) return customValue;
+    const value = shareSafely(structuralSharing, sameEntry ? customValue : void 0, raw, entry.explicit);
+    customEntry = entry;
+    customFrom = raw;
+    customValue = value;
+    return value;
+  }
+  function commitBase(entry, value) {
+    const changed = !Object.is(value, baseValue);
+    baseEntry = entry;
+    baseValue = value;
+    if (!select) {
+      setData(value);
+      return;
+    }
+    if (!changed) return;
+    baseExplicit = entry?.explicit === true;
+    setBase(value);
+  }
+  const stopSelect = select ? effect(() => {
+    const raw = base();
+    const entry = baseEntry;
+    const explicit = baseExplicit;
+    baseExplicit = false;
+    if (entry === null && selectedEntry === null) return;
+    if (raw === void 0) {
+      selectedEntry = entry;
+      selectedValue = void 0;
+      setData(void 0);
+      return;
+    }
+    const selected = runSelect("query select", () => select(raw));
+    if (!selected.ok) return;
+    const prev = selectedEntry === entry ? selectedValue : void 0;
+    const value = shareSafely(structuralSharing, prev, selected.value, explicit);
+    selectedEntry = entry;
+    selectedValue = value;
+    setData(value);
+  }) : null;
   function detachFromEntry() {
     const entry = attachedEntry;
     const key2 = attachedKey;
@@ -255,7 +399,7 @@ function query(key, fetcher, options = {}) {
             const settledError = entry.error;
             runCallback("query onError", () => onError?.(settledError));
           } else if (entry.data !== void 0) {
-            const settledData = entry.data;
+            const settledData = viewOf(entry);
             runCallback("query onSuccess", () => onSuccess?.(settledData));
           }
           runCallback("query onSettled", () => onSettled?.());
@@ -286,17 +430,14 @@ function query(key, fetcher, options = {}) {
       entry.promise = null;
       entry.controller = null;
       entry.data = result;
+      entry.explicit = false;
       entry.dataUpdatedAt = Date.now();
       entry.error = void 0;
       notifyListeners(entry.listeners, "query cache listener");
       if (disposed || currentKey !== key2) return;
-      const selected = runSelect("query select", () => select ? select(result) : result);
-      batch(() => {
-        if (selected.ok) setData(selected.value);
-        setIsFetching(false);
-        setError(void 0);
-      });
-      runCallback("query onSuccess", () => onSuccess?.(result));
+      if (!entry.listeners.has(onCacheUpdate)) onCacheUpdate();
+      const committedResult = viewOf(entry);
+      runCallback("query onSuccess", () => onSuccess?.(committedResult));
     } catch (err) {
       if (entry.generation !== generation) return;
       entry.promise = null;
@@ -326,18 +467,19 @@ function query(key, fetcher, options = {}) {
     const entry = cache.get(currentKey);
     if (!entry) {
       batch(() => {
-        setData(void 0);
+        commitBase(null, void 0);
         setError(void 0);
         setIsFetching(false);
+        setUpdatedAt(0);
       });
       return;
     }
-    const raw = entry.data;
-    const selected = raw !== void 0 && select ? runSelect("query select", () => select(raw)) : { ok: true, value: raw };
+    const view = viewOf(entry);
     batch(() => {
-      if (selected.ok) setData(selected.value);
+      commitBase(entry, view);
       setError(entry.error);
       if (!entry.promise) setIsFetching(false);
+      setUpdatedAt(entry.dataUpdatedAt);
     });
   }
   const effectCleanup = effect(() => {
@@ -347,11 +489,11 @@ function query(key, fetcher, options = {}) {
     const entry = getOrCreateEntry(cache, key2, initialData);
     attachToEntry(entry, key2);
     if (entry.data !== void 0) {
-      const raw = entry.data;
-      const selected = runSelect("query select", () => select ? select(raw) : raw);
+      const view = viewOf(entry);
       batch(() => {
-        if (selected.ok) setData(selected.value);
+        commitBase(entry, view);
         setError(entry.error);
+        setUpdatedAt(entry.dataUpdatedAt);
       });
     }
     if (!keyChanged && currentKey === key2 && entry.data !== void 0) {
@@ -389,6 +531,7 @@ function query(key, fetcher, options = {}) {
     if (disposed) return;
     disposed = true;
     effectCleanup();
+    stopSelect?.();
     loading.dispose();
     isStale.dispose();
     if (intervalTimer) clearInterval(intervalTimer);
@@ -420,13 +563,15 @@ function invalidateQueries(keyOrPredicate) {
   }
 }
 function getQueryData(key) {
-  return getActiveQueryCache().get(key)?.data;
+  const entry = getActiveQueryCache().get(key);
+  return entry ? sharedView(entry) : void 0;
 }
 function setQueryData(key, data) {
   const entry = getActiveQueryCache().get(key);
   if (!entry) return;
-  const newData = typeof data === "function" ? data(entry.data) : data;
+  const newData = typeof data === "function" ? data(sharedView(entry)) : data;
   entry.data = newData;
+  entry.explicit = true;
   entry.dataUpdatedAt = Date.now();
   notifyListeners(entry.listeners, "query cache listener");
 }
@@ -810,6 +955,15 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
   const [loading, setLoading] = signal(false);
   const [error, setError] = signal(void 0);
   let currentData = options.initialValue;
+  function commitData(next, explicit) {
+    const sharing = options.structuralSharing ?? true;
+    const shared = untracked(
+      () => runSelect("resource structuralSharing", () => applyStructuralSharing(sharing, currentData, next, explicit))
+    );
+    currentData = shared.ok ? shared.value : next;
+    setData(currentData);
+    return currentData;
+  }
   let abortController = null;
   let disposed = false;
   let effectCleanup = null;
@@ -829,12 +983,12 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
     try {
       const result = await withRetry(() => fetcher(sourceValue, { signal: signal2, prev }), options.retry, void 0, signal2);
       if (version !== fetchVersion || disposed) return;
-      currentData = result;
+      let committed = result;
       batch(() => {
-        setData(result);
+        committed = commitData(result, false);
         setLoading(false);
       });
-      runCallback("resource onSuccess", () => options.onSuccess?.(result));
+      runCallback("resource onSuccess", () => options.onSuccess?.(committed));
     } catch (err) {
       if (version !== fetchVersion || disposed) return;
       if (isAbortError(err)) {
@@ -868,8 +1022,7 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
     refetch: () => doFetch(source ? source() : void 0),
     mutate: (value) => {
       const newValue = typeof value === "function" ? value(currentData) : value;
-      currentData = newValue;
-      setData(newValue);
+      commitData(newValue, true);
     },
     abort: () => abortController?.abort(),
     dispose: () => {

package/dist/{chunk-XC4MEKGA.js → chunk-V3LHZSU5.js}

@@ -3,9 +3,10 @@ import {
 } from "./chunk-7XHATCIH.js";
 import {
   cleanup,
+  emitDevtools,
   retrack,
   untracked
-} from "./chunk-5Q4R7HCL.js";
+} from "./chunk-TQQUN4WR.js";
 import {
   devAssert,
   reportError
@@ -142,12 +143,17 @@ function effect(effectFn, options) {
   try {
     retrack(ctx.bodyFn, ctx.subscriber);
     if (ctx.rerunPending) drainReruns(ctx);
+  } catch (err) {
+    ctx.disposed = true;
+    if (ctx.userCleanups.length > 0) flushUserCleanups(ctx);
+    cleanup(ctx.subscriber);
+    throw err;
   } finally {
     ctx.running = false;
     ctx.rerunPending = false;
   }
   const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-  if (hook) hook.emit("effect:create", { effectFn });
+  if (hook) emitDevtools(hook, "effect:create", { effectFn });
   return () => disposeEffect(ctx);
 }