sibujs 3.0.0 → 3.2.0

package/dist/data.cjs

@@ -189,7 +189,7 @@ function retrack(effectFn, subscriber) {
   }
 }
 function track(effectFn, subscriber) {
-  if (!subscriber) subscriber = effectFn;
+  if (!subscriber) return reactiveBinding(effectFn);
   cleanup(subscriber);
   const prev = currentSubscriber;
   currentSubscriber = subscriber;
@@ -207,6 +207,32 @@ function track(effectFn, subscriber) {
   const sub = subscriber;
   return sub._dispose ?? (sub._dispose = () => cleanup(subscriber));
 }
+function reactiveBinding(commit) {
+  const run = () => {
+    const s = subscriber;
+    if (s._disposed || s._reentrant) return;
+    s._reentrant = true;
+    try {
+      retrack(commit, subscriber);
+    } finally {
+      s._reentrant = false;
+    }
+  };
+  const subscriber = run;
+  subscriber.depsHead = null;
+  subscriber.depsTail = null;
+  subscriber._epoch = 0;
+  subscriber._structDirty = false;
+  subscriber._runEpoch = 0;
+  subscriber._runs = 0;
+  subscriber._reentrant = false;
+  subscriber._disposed = false;
+  run();
+  return subscriber._dispose ?? (subscriber._dispose = () => {
+    subscriber._disposed = true;
+    cleanup(subscriber);
+  });
+}
 function recordDependency(signal2) {
   if (!currentSubscriber) return;
   const sub = currentSubscriber;
@@ -395,6 +421,7 @@ function derived(getter, options) {
   const equals = options?.equals;
   const cs = {};
   cs._d = false;
+  cs._init = false;
   cs._g = getter;
   cs.__v = 0;
   const markDirty = () => {
@@ -403,11 +430,18 @@ function derived(getter, options) {
   };
   markDirty._c = 1;
   markDirty._sig = cs;
+  const recompute = () => {
+    const next = getter();
+    cs._v = equals && cs._init ? equals(cs._v, next) ? cs._v : next : next;
+    cs._d = false;
+    cs._init = true;
+  };
   track(() => {
     let threw = true;
     try {
       cs._v = getter();
       cs._d = false;
+      cs._init = true;
       threw = false;
     } finally {
       if (threw) cs._d = true;
@@ -423,20 +457,13 @@ function derived(getter, options) {
     }
     if (trackingSuspended) {
       if (cs._d) {
+        const prev = cs._v;
         evaluating = true;
-        let threw = true;
         try {
-          const prev = cs._v;
-          retrack(() => {
-            const next = getter();
-            cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
-            cs._d = false;
-            threw = false;
-          }, markDirty);
+          retrack(recompute, markDirty);
           if (!Object.is(prev, cs._v)) cs.__v++;
         } finally {
           evaluating = false;
-          if (threw) cs._d = true;
         }
       }
       return cs._v;
@@ -445,18 +472,11 @@ function derived(getter, options) {
     if (cs._d) {
       const oldValue = cs._v;
       evaluating = true;
-      let threw = true;
       try {
-        retrack(() => {
-          const next = getter();
-          cs._v = equals && cs._v !== void 0 ? equals(cs._v, next) ? cs._v : next : next;
-          cs._d = false;
-          threw = false;
-        }, markDirty);
+        retrack(recompute, markDirty);
         if (!Object.is(oldValue, cs._v)) cs.__v++;
       } finally {
         evaluating = false;
-        if (threw) cs._d = true;
       }
       if (hook && oldValue !== cs._v) {
         hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
@@ -477,11 +497,15 @@ function derived(getter, options) {
 var als = null;
 try {
   if (typeof process !== "undefined" && process.versions && process.versions.node) {
-    const req = Function("return typeof require==='function'?require:null")();
-    if (req) {
-      const mod = req("node:async_hooks");
-      als = new mod.AsyncLocalStorage();
+    let mod = null;
+    const getBuiltin = process.getBuiltinModule;
+    if (typeof getBuiltin === "function") {
+      mod = getBuiltin("node:async_hooks");
+    } else {
+      const req = Function("return typeof require==='function'?require:null")();
+      if (req) mod = req("node:async_hooks");
     }
+    if (mod) als = new mod.AsyncLocalStorage();
   }
 } catch {
   als = null;
@@ -497,6 +521,17 @@ function getSSRStore() {
 function isSSR() {
   return getSSRStore().ssr;
 }
+function getRequestScopedCache(name) {
+  if (!isSSR()) return null;
+  const store = getSSRStore();
+  const caches = store.caches ?? (store.caches = /* @__PURE__ */ new Map());
+  let c = caches.get(name);
+  if (!c) {
+    c = /* @__PURE__ */ new Map();
+    caches.set(name, c);
+  }
+  return c;
+}
 
 // src/core/signals/effect.ts
 var _g = globalThis;
@@ -583,6 +618,7 @@ function effect(effectFn, options) {
     ctx.fn(ctx.onCleanup);
   };
   const sub = (() => {
+    if (ctx.disposed) return;
     if (ctx.running) {
       ctx.rerunPending = true;
       return;
@@ -779,9 +815,12 @@ async function withRetry(fn, options, onRetry, signal2) {
 }
 
 // src/data/query.ts
-var queryCache = /* @__PURE__ */ new Map();
-function getOrCreateEntry(key, initialData) {
-  let entry = queryCache.get(key);
+var globalQueryCache = /* @__PURE__ */ new Map();
+function getActiveQueryCache() {
+  return getRequestScopedCache("query") ?? globalQueryCache;
+}
+function getOrCreateEntry(cache, key, initialData) {
+  let entry = cache.get(key);
   if (!entry) {
     entry = {
       data: initialData,
@@ -793,7 +832,7 @@ function getOrCreateEntry(key, initialData) {
       listeners: /* @__PURE__ */ new Set(),
       refetchers: /* @__PURE__ */ new Set()
     };
-    queryCache.set(key, entry);
+    cache.set(key, entry);
   }
   return entry;
 }
@@ -813,6 +852,7 @@ function query(key, fetcher, options = {}) {
     select
   } = 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);
@@ -824,16 +864,16 @@ function query(key, fetcher, options = {}) {
   const isStale = derived(() => {
     data();
     if (!currentKey) return true;
-    const entry = queryCache.get(currentKey);
+    const entry = cache.get(currentKey);
     if (!entry || entry.dataUpdatedAt === 0) return true;
     return Date.now() - entry.dataUpdatedAt >= staleTime;
   });
   async function doFetch() {
     if (disposed || !currentKey || !enabled) return;
     const key2 = currentKey;
-    let entry = queryCache.get(key2);
+    let entry = cache.get(key2);
     if (!entry) {
-      entry = getOrCreateEntry(key2);
+      entry = getOrCreateEntry(cache, key2);
       entry.listeners.add(onCacheUpdate);
       entry.refetchers.add(doFetch);
     }
@@ -908,7 +948,7 @@ function query(key, fetcher, options = {}) {
   }
   function onCacheUpdate() {
     if (disposed || !currentKey) return;
-    const entry = queryCache.get(currentKey);
+    const entry = cache.get(currentKey);
     if (!entry) {
       batch(() => {
         setData(void 0);
@@ -928,7 +968,7 @@ function query(key, fetcher, options = {}) {
   const effectCleanup = effect(() => {
     const key2 = resolveKey();
     if (currentKey !== null && currentKey !== key2) {
-      const oldEntry = queryCache.get(currentKey);
+      const oldEntry = cache.get(currentKey);
       if (oldEntry) {
         oldEntry.listeners.delete(onCacheUpdate);
         oldEntry.refetchers.delete(doFetch);
@@ -936,13 +976,13 @@ function query(key, fetcher, options = {}) {
         if (oldEntry.subscribers <= 0 && cacheTime >= 0) {
           const oldKey = currentKey;
           if (oldEntry.gcTimer !== null) clearTimeout(oldEntry.gcTimer);
-          oldEntry.gcTimer = setTimeout(() => queryCache.delete(oldKey), cacheTime);
+          oldEntry.gcTimer = setTimeout(() => cache.delete(oldKey), cacheTime);
         }
       }
     }
     const keyChanged = currentKey !== key2;
     currentKey = key2;
-    const entry = getOrCreateEntry(key2, initialData);
+    const entry = getOrCreateEntry(cache, key2, initialData);
     if (keyChanged) entry.subscribers++;
     if (entry.gcTimer !== null) {
       clearTimeout(entry.gcTimer);
@@ -996,7 +1036,7 @@ function query(key, fetcher, options = {}) {
     effectCleanup();
     if (intervalTimer) clearInterval(intervalTimer);
     if (currentKey) {
-      const entry = queryCache.get(currentKey);
+      const entry = cache.get(currentKey);
       if (entry) {
         entry.listeners.delete(onCacheUpdate);
         entry.refetchers.delete(doFetch);
@@ -1004,7 +1044,7 @@ function query(key, fetcher, options = {}) {
         if (entry.subscribers <= 0 && cacheTime >= 0) {
           const key2 = currentKey;
           if (entry.gcTimer !== null) clearTimeout(entry.gcTimer);
-          entry.gcTimer = setTimeout(() => queryCache.delete(key2), cacheTime);
+          entry.gcTimer = setTimeout(() => cache.delete(key2), cacheTime);
         }
       }
     }
@@ -1027,7 +1067,7 @@ function query(key, fetcher, options = {}) {
 }
 function invalidateQueries(keyOrPredicate) {
   const predicate = typeof keyOrPredicate === "function" ? keyOrPredicate : (k) => k === keyOrPredicate;
-  for (const [key, entry] of queryCache.entries()) {
+  for (const [key, entry] of getActiveQueryCache().entries()) {
     if (predicate(key)) {
       entry.dataUpdatedAt = 0;
       for (const refetcher of entry.refetchers) refetcher();
@@ -1035,10 +1075,10 @@ function invalidateQueries(keyOrPredicate) {
   }
 }
 function getQueryData(key) {
-  return queryCache.get(key)?.data;
+  return getActiveQueryCache().get(key)?.data;
 }
 function setQueryData(key, data) {
-  const entry = queryCache.get(key);
+  const entry = getActiveQueryCache().get(key);
   if (!entry) return;
   const newData = typeof data === "function" ? data(entry.data) : data;
   entry.data = newData;
@@ -1048,14 +1088,15 @@ function setQueryData(key, data) {
 function clearQueryCache() {
   const activeListeners = [];
   const activeRefetchers = [];
-  for (const entry of queryCache.values()) {
+  const activeCache = getActiveQueryCache();
+  for (const entry of activeCache.values()) {
     if (entry.gcTimer) clearTimeout(entry.gcTimer);
     if (entry.subscribers > 0) {
       for (const listener of entry.listeners) activeListeners.push(listener);
       for (const refetcher of entry.refetchers) activeRefetchers.push(refetcher);
     }
   }
-  queryCache.clear();
+  activeCache.clear();
   for (const listener of activeListeners) listener();
   for (const refetcher of activeRefetchers) {
     refetcher().catch((err) => {
@@ -1066,10 +1107,11 @@ function clearQueryCache() {
   }
 }
 function __resetQueryCache() {
-  for (const entry of queryCache.values()) {
+  const activeCache = getActiveQueryCache();
+  for (const entry of activeCache.values()) {
     if (entry.gcTimer) clearTimeout(entry.gcTimer);
   }
-  queryCache.clear();
+  activeCache.clear();
 }
 
 // src/data/mutation.ts
@@ -1081,7 +1123,11 @@ function mutation(mutationFn, options = {}) {
   const isSuccess = derived(() => status() === "success");
   const isIdle = derived(() => status() === "idle");
   let runId = 0;
+  let abortController = null;
   async function execute(variables) {
+    abortController?.abort();
+    abortController = new AbortController();
+    const signal2 = abortController.signal;
     const myRun = ++runId;
     let context2;
     batch(() => {
@@ -1093,7 +1139,7 @@ function mutation(mutationFn, options = {}) {
       if (options.onMutate) {
         context2 = await options.onMutate(variables);
       }
-      const result = await withRetry(() => mutationFn(variables), options.retry);
+      const result = await withRetry(() => mutationFn(variables, signal2), options.retry, void 0, signal2);
       if (myRun !== runId) return result;
       batch(() => {
         setData(result);
@@ -1105,6 +1151,7 @@ function mutation(mutationFn, options = {}) {
       return result;
     } catch (err) {
       const errorObj = err instanceof Error ? err : new Error(String(err));
+      if (errorObj instanceof DOMException && errorObj.name === "AbortError") throw errorObj;
       if (myRun !== runId) throw errorObj;
       batch(() => {
         setError(errorObj);
@@ -1118,6 +1165,8 @@ function mutation(mutationFn, options = {}) {
   }
   function reset() {
     runId++;
+    abortController?.abort();
+    abortController = null;
     batch(() => {
       setData(void 0);
       setError(void 0);
@@ -1133,6 +1182,7 @@ function mutation(mutationFn, options = {}) {
     isIdle,
     mutate: (variables) => {
       execute(variables).catch((err) => {
+        if (err instanceof DOMException && err.name === "AbortError") return;
         if (typeof console !== "undefined") {
           console.warn("[SibuJS mutation] mutate() failed; check `.error()` signal or onError option.", err);
         }
@@ -1149,6 +1199,7 @@ function infiniteQuery(key, fetcher, options) {
     getNextPageParam,
     getPreviousPageParam,
     initialPageParam = 0,
+    maxPages,
     enabled = true,
     retry: retryOptions,
     onSuccess,
@@ -1172,8 +1223,9 @@ function infiniteQuery(key, fetcher, options) {
   let abortController = null;
   let disposed = false;
   let runId = 0;
-  async function fetchPage(pageParam, direction) {
-    if (disposed) return;
+  let inFlight = null;
+  function fetchPage(pageParam, direction) {
+    if (disposed) return Promise.resolve();
     abortController?.abort();
     abortController = new AbortController();
     const signal2 = abortController.signal;
@@ -1184,39 +1236,44 @@ function infiniteQuery(key, fetcher, options) {
       if (direction === "prev") setIsFetchingPrev(true);
       setError(void 0);
     });
-    try {
-      const page = await withRetry(() => fetcher({ signal: signal2, pageParam }), retryOptions, void 0, signal2);
-      if (disposed || myRun !== runId) return;
-      const currentPages = pages();
-      let newPages;
-      if (direction === "prev") {
-        newPages = [page, ...currentPages];
-      } else {
-        newPages = [...currentPages, page];
+    const promise = (async () => {
+      try {
+        const page = await withRetry(() => fetcher({ signal: signal2, pageParam }), retryOptions, void 0, signal2);
+        if (disposed || myRun !== runId) return;
+        const currentPages = pages();
+        let newPages = direction === "prev" ? [page, ...currentPages] : [...currentPages, page];
+        if (maxPages != null && maxPages > 0 && newPages.length > maxPages) {
+          newPages = direction === "prev" ? newPages.slice(0, maxPages) : newPages.slice(newPages.length - maxPages);
+        }
+        const nextParam = getNextPageParam(newPages[newPages.length - 1], newPages);
+        const prevParam = getPreviousPageParam?.(newPages[0], newPages);
+        batch(() => {
+          setPages(newPages);
+          setNextPageParam(nextParam);
+          setPrevPageParam(prevParam);
+          setIsFetching(false);
+          setIsFetchingNext(false);
+          setIsFetchingPrev(false);
+        });
+        onSuccess?.(newPages);
+      } catch (err) {
+        if (disposed || myRun !== runId) return;
+        if (err instanceof DOMException && err.name === "AbortError") return;
+        const errorObj = err instanceof Error ? err : new Error(String(err));
+        batch(() => {
+          setError(errorObj);
+          setIsFetching(false);
+          setIsFetchingNext(false);
+          setIsFetchingPrev(false);
+        });
+        onError?.(errorObj);
       }
-      const nextParam = getNextPageParam(page, newPages);
-      const prevParam = getPreviousPageParam?.(newPages[0], newPages);
-      batch(() => {
-        setPages(newPages);
-        setNextPageParam(nextParam);
-        setPrevPageParam(prevParam);
-        setIsFetching(false);
-        setIsFetchingNext(false);
-        setIsFetchingPrev(false);
-      });
-      onSuccess?.(newPages);
-    } catch (err) {
-      if (disposed || myRun !== runId) return;
-      if (err instanceof DOMException && err.name === "AbortError") return;
-      const errorObj = err instanceof Error ? err : new Error(String(err));
-      batch(() => {
-        setError(errorObj);
-        setIsFetching(false);
-        setIsFetchingNext(false);
-        setIsFetchingPrev(false);
-      });
-      onError?.(errorObj);
-    }
+    })();
+    inFlight = promise;
+    void promise.finally(() => {
+      if (inFlight === promise) inFlight = null;
+    });
+    return promise;
   }
   const effectCleanup = effect(() => {
     resolveKey();
@@ -1231,11 +1288,13 @@ function infiniteQuery(key, fetcher, options) {
     }
   });
   function fetchNextPage() {
+    if (inFlight) return inFlight;
     const param = nextPageParam();
     if (param === void 0) return Promise.resolve();
     return fetchPage(param, "next");
   }
   function fetchPreviousPage() {
+    if (inFlight) return inFlight;
     const param = prevPageParam();
     if (param === void 0) return Promise.resolve();
     return fetchPage(param, "prev");
@@ -1274,13 +1333,17 @@ function infiniteQuery(key, fetcher, options) {
 function previous(getter) {
   const [previous2, setPrevious] = signal(void 0);
   let current = getter();
-  effect(() => {
+  const stop = effect(() => {
     const next = getter();
     if (!Object.is(next, current)) {
       setPrevious(current);
       current = next;
     }
   });
+  Object.defineProperty(previous2, "dispose", {
+    value: stop,
+    enumerable: false
+  });
   return previous2;
 }
 
@@ -1288,7 +1351,7 @@ function previous(getter) {
 function debounce(getter, delay) {
   const [debounced, setDebounced] = signal(getter());
   let timer = null;
-  effect(() => {
+  const stop = effect(() => {
     const value = getter();
     if (timer !== null) clearTimeout(timer);
     timer = setTimeout(() => {
@@ -1296,6 +1359,16 @@ function debounce(getter, delay) {
       timer = null;
     }, delay);
   });
+  Object.defineProperty(debounced, "dispose", {
+    value: () => {
+      stop();
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    },
+    enumerable: false
+  });
   return debounced;
 }
 
@@ -1305,7 +1378,8 @@ function throttle(getter, interval) {
   let cooldown = false;
   let pending = null;
   let lastEmitted = getter();
-  effect(() => {
+  let timer = null;
+  const stop = effect(() => {
     const value = getter();
     if (!cooldown) {
       if (!Object.is(value, lastEmitted)) {
@@ -1313,7 +1387,8 @@ function throttle(getter, interval) {
         lastEmitted = value;
         cooldown = true;
         pending = null;
-        setTimeout(() => {
+        timer = setTimeout(() => {
+          timer = null;
           cooldown = false;
           if (pending !== null) {
             const trailingValue = pending.value;
@@ -1327,6 +1402,16 @@ function throttle(getter, interval) {
       pending = { value };
     }
   });
+  Object.defineProperty(throttled, "dispose", {
+    value: () => {
+      stop();
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    },
+    enumerable: false
+  });
   return throttled;
 }
 
@@ -1455,28 +1540,45 @@ function idbGet(db, store, key) {
     req.onerror = () => reject(req.error);
   });
 }
-function idbPut(db, store, item) {
+function idbPut(db, store, item, key) {
   return new Promise((resolve, reject) => {
     const tx = db.transaction(store, "readwrite");
-    tx.objectStore(store).put(item);
+    if (key !== void 0) tx.objectStore(store).put(item, key);
+    else tx.objectStore(store).put(item);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
 }
-function idbPutWithChange(db, item, change) {
+function coalesceAndAddChange(tx, change, keyPath) {
+  const store = tx.objectStore("_changes");
+  const targetKey = change.item[keyPath];
+  const cursorReq = store.openCursor();
+  cursorReq.onsuccess = () => {
+    const cursor = cursorReq.result;
+    if (cursor) {
+      const existing = cursor.value;
+      const k = existing.item[keyPath];
+      if (targetKey != null && k === targetKey) cursor.delete();
+      cursor.continue();
+    } else {
+      store.put(change);
+    }
+  };
+}
+function idbPutWithChange(db, item, change, keyPath) {
   return new Promise((resolve, reject) => {
     const tx = db.transaction(["items", "_changes"], "readwrite");
     tx.objectStore("items").put(item);
-    tx.objectStore("_changes").put(change);
+    coalesceAndAddChange(tx, change, keyPath);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
 }
-function idbDeleteWithChange(db, key, change) {
+function idbDeleteWithChange(db, key, change, keyPath) {
   return new Promise((resolve, reject) => {
     const tx = db.transaction(["items", "_changes"], "readwrite");
     tx.objectStore("items").delete(key);
-    tx.objectStore("_changes").put(change);
+    coalesceAndAddChange(tx, change, keyPath);
     tx.oncomplete = () => resolve();
     tx.onerror = () => reject(tx.error);
   });
@@ -1536,13 +1638,18 @@ async function offlineStore(options) {
     setPendingCount(changes.length);
   }
   async function put(item) {
-    await idbPutWithChange(db, item, { type: "put", item, timestamp: Date.now() });
+    await idbPutWithChange(db, item, { type: "put", item, timestamp: Date.now() }, keyPath);
     await refreshData();
   }
   async function remove(key) {
     const existing = await idbGet(db, "items", key);
     if (existing) {
-      await idbDeleteWithChange(db, key, { type: "delete", item: existing, timestamp: Date.now() });
+      await idbDeleteWithChange(
+        db,
+        key,
+        { type: "delete", item: existing, timestamp: Date.now() },
+        keyPath
+      );
       await refreshData();
     }
   }
@@ -1568,6 +1675,8 @@ async function offlineStore(options) {
             snapshot.map((e) => e.key)
           );
           if (closed) return;
+        } else if (typeof console !== "undefined") {
+          console.warn(`[offlineStore] push rejected by adapter${result.error ? `: ${result.error}` : ""}`);
         }
       }
       const remoteItems = await adapter.pull(lastSynced());
@@ -1586,7 +1695,7 @@ async function offlineStore(options) {
       await idbPutMany(db, "items", safeRemote);
       if (closed) return;
       const now = Date.now();
-      await idbPut(db, "_meta", now);
+      await idbPut(db, "_meta", now, "lastSynced");
       if (closed) return;
       setLastSynced(now);
       await refreshData();
@@ -1685,14 +1794,20 @@ function loaderData() {
 async function preloadRoute(route, context2, callerSignal) {
   if (!route.loader) return void 0;
   const controller = new AbortController();
+  let onAbort = null;
   if (callerSignal) {
     if (callerSignal.aborted) {
       controller.abort();
     } else {
-      callerSignal.addEventListener("abort", () => controller.abort(), { once: true });
+      onAbort = () => controller.abort();
+      callerSignal.addEventListener("abort", onAbort, { once: true });
     }
   }
-  return route.loader(context2, { signal: controller.signal });
+  try {
+    return await route.loader(context2, { signal: controller.signal });
+  } finally {
+    if (onAbort) callerSignal?.removeEventListener("abort", onAbort);
+  }
 }
 
 // src/ui/socket.ts
@@ -1798,9 +1913,12 @@ function socket(url, options) {
 }
 
 // src/utils/sanitize.ts
+function stripControlChars(value) {
+  return value.replace(/[\x00-\x20\x7f-\x9f]+/g, "");
+}
 var SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:", "ftp:"];
 function sanitizeUrl(url) {
-  const trimmed = url.replace(/[\x00-\x20\x7f-\x9f]+/g, "").trim();
+  const trimmed = stripControlChars(url).trim();
   if (!trimmed) return "";
   const lower = trimmed.toLowerCase();
   let schemeEnd = -1;

package/dist/data.d.cts

@@ -133,7 +133,7 @@ interface MutationResult<TData, TVariables> {
     /** Reset state to idle */
     reset: () => void;
 }
-declare function mutation<TData, TVariables = void, TContext = unknown>(mutationFn: (variables: TVariables) => Promise<TData>, options?: MutationOptions<TData, TVariables, TContext>): MutationResult<TData, TVariables>;
+declare function mutation<TData, TVariables = void, TContext = unknown>(mutationFn: (variables: TVariables, signal?: AbortSignal) => Promise<TData>, options?: MutationOptions<TData, TVariables, TContext>): MutationResult<TData, TVariables>;
 
 interface InfiniteQueryOptions<TData, TPageParam = number> {
     /** Get the param for the next page. Return undefined to signal end. */
@@ -142,6 +142,12 @@ interface InfiniteQueryOptions<TData, TPageParam = number> {
     getPreviousPageParam?: (firstPage: TData, allPages: TData[]) => TPageParam | undefined;
     /** Initial page param. Default: 0 (for number) */
     initialPageParam?: TPageParam;
+    /**
+     * Maximum number of pages to retain. When exceeded, the oldest page is
+     * dropped from the opposite end (sliding window) to bound memory. Unset =
+     * unbounded.
+     */
+    maxPages?: number;
     /** Whether to fetch on creation. Default: true */
     enabled?: boolean;
     /** Retry options */