sibujs 4.4.0 → 4.6.0

package/dist/data.cjs

@@ -34,12 +34,14 @@ __export(data_exports, {
   preloadRoute: () => preloadRoute,
   previous: () => previous,
   query: () => query,
+  renderWithLoader: () => renderWithLoader,
   resource: () => resource,
   setQueryData: () => setQueryData,
   socket: () => socket,
   stream: () => stream,
   syncAdapter: () => syncAdapter,
   throttle: () => throttle,
+  withLoader: () => withLoader,
   withRetry: () => withRetry
 });
 module.exports = __toCommonJS(data_exports);
@@ -83,8 +85,8 @@ function safeStringify(value) {
     return Object.prototype.toString.call(value);
   }
 }
-function describe(context2) {
-  return context2.name ? `${context2.phase} "${context2.name}"` : context2.phase;
+function describe(context) {
+  return context.name ? `${context.phase} "${context.name}"` : context.phase;
 }
 var REACTIVE_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function untrackedRun(fn) {
@@ -92,8 +94,8 @@ function untrackedRun(fn) {
   return api?.untracked ? api.untracked(fn) : fn();
 }
 var PROPAGATE_EVENT = "sibu:error-propagate";
-function claimedByBoundary(error, context2) {
-  const raw = context2.node;
+function claimedByBoundary(error, context) {
+  const raw = context.node;
   if (!raw || typeof CustomEvent === "undefined") return false;
   const target = resolveEventTarget(raw);
   if (!target) return false;
@@ -101,7 +103,7 @@ function claimedByBoundary(error, context2) {
     const event = new CustomEvent(PROPAGATE_EVENT, {
       bubbles: true,
       cancelable: true,
-      detail: { error, context: context2 }
+      detail: { error, context }
     });
     return target.dispatchEvent(event) === false;
   } catch {
@@ -120,20 +122,20 @@ function resolveEventTarget(node) {
   const self = node;
   return typeof self.dispatchEvent === "function" ? self : null;
 }
-function defaultReport(error, context2) {
+function defaultReport(error, context) {
   if (typeof console === "undefined") return;
-  console.error(`[SibuJS] Uncaught error during ${describe(context2)}: ${error.message}`, error);
+  console.error(`[SibuJS] Uncaught error during ${describe(context)}: ${error.message}`, error);
 }
-function reportError(error, context2) {
+function reportError(error, context) {
   const err = normalizeError(error);
   untrackedRun(() => {
-    if (claimedByBoundary(err, context2)) return;
+    if (claimedByBoundary(err, context)) return;
     const s = state();
     const handler = s.handler;
     if (handler && s.handlerDepth === 0) {
       s.handlerDepth++;
       try {
-        handler(error instanceof Error ? error : err, context2);
+        handler(error instanceof Error ? error : err, context);
         return;
       } catch (handlerError) {
         if (typeof console !== "undefined") {
@@ -144,10 +146,29 @@ function reportError(error, context2) {
         s.handlerDepth--;
       }
     }
-    defaultReport(err, context2);
+    defaultReport(err, context);
   });
 }
 
+// src/core/rendering/dispose.ts
+function resolveCapture(capture) {
+  let frame = capture;
+  while (frame?.closed) frame = frame.forwardTo;
+  return frame ?? null;
+}
+var registrationCaptures = [];
+function currentDisposerCapture() {
+  return resolveCapture(registrationCaptures[registrationCaptures.length - 1]);
+}
+function beginDisposerCapture(capture) {
+  if (capture === null && registrationCaptures.length === 0) return false;
+  registrationCaptures.push(resolveCapture(capture));
+  return true;
+}
+function endDisposerCapture() {
+  registrationCaptures.pop();
+}
+
 // src/reactivity/track-core.ts
 var POOL_MAX = 4096;
 var nodePool = [];
@@ -295,8 +316,18 @@ function untracked(fn) {
 var subscriberEpochCounter = 0;
 function retrack(effectFn, subscriber) {
   const prev = currentSubscriber;
+  let savedDepth = 0;
+  let savedSuspendSub = null;
+  if (trackingSuspended) {
+    savedDepth = suspendDepth;
+    savedSuspendSub = suspendSavedSub;
+    suspendDepth = 0;
+    suspendSavedSub = null;
+    trackingSuspended = false;
+  }
   currentSubscriber = subscriber;
   const sub = subscriber;
+  if (sub._cap === void 0) sub._cap = currentDisposerCapture();
   const epoch = ++subscriberEpochCounter;
   sub._epoch = epoch;
   sub._structDirty = false;
@@ -309,6 +340,11 @@ function retrack(effectFn, subscriber) {
     effectFn();
   } finally {
     currentSubscriber = prev;
+    if (savedDepth !== 0) {
+      suspendDepth = savedDepth;
+      suspendSavedSub = savedSuspendSub;
+      trackingSuspended = true;
+    }
     let node = sub.depsHead ?? null;
     while (node !== null) {
       const next = node.subNext;
@@ -328,11 +364,25 @@ function track(effectFn, subscriber) {
   if (!subscriber) return reactiveBinding(effectFn);
   cleanup(subscriber);
   const prev = currentSubscriber;
+  let savedDepth = 0;
+  let savedSuspendSub = null;
+  if (trackingSuspended) {
+    savedDepth = suspendDepth;
+    savedSuspendSub = suspendSavedSub;
+    suspendDepth = 0;
+    suspendSavedSub = null;
+    trackingSuspended = false;
+  }
   currentSubscriber = subscriber;
   try {
     effectFn();
   } finally {
     currentSubscriber = prev;
+    if (savedDepth !== 0) {
+      suspendDepth = savedDepth;
+      suspendSavedSub = savedSuspendSub;
+      trackingSuspended = true;
+    }
     const sub2 = subscriber;
     for (let n = sub2.depsHead ?? null; n !== null; n = n.subNext) {
       const sig = n.sig;
@@ -469,7 +519,12 @@ function drainQueue() {
       quarantined.add(sub);
       continue;
     }
-    safeInvoke(sub);
+    const pushed = beginDisposerCapture(sub._cap ?? null);
+    try {
+      safeInvoke(sub);
+    } finally {
+      if (pushed) endDisposerCapture();
+    }
   }
 }
 function drainNotificationQueue() {
@@ -503,8 +558,9 @@ function propagateDirty(sub) {
         if (s._c) {
           const nSig = s._sig;
           if (nSig) {
-            if (!nSig._d) {
+            if (!nSig._d || nSig._f === true) {
               nSig._d = true;
+              nSig._f = false;
               stack.push(nSig);
             }
           } else {
@@ -604,7 +660,7 @@ function forEachSubscriber(signal2, visit) {
 }
 
 // src/reactivity/track.ts
-var _runtimeVersion = true ? "4.4.0" : "dev";
+var _runtimeVersion = true ? "4.6.0" : "dev";
 var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("sibujs.reactive.v1");
 function resolveReactiveApi() {
   const g = globalThis;
@@ -668,10 +724,14 @@ function derived(getter, options) {
   const cs = {};
   cs._d = false;
   cs._init = false;
+  cs._f = false;
   cs._g = getter;
   cs.__v = 0;
+  let evaluating = false;
+  let disposed = false;
+  let pendingError;
   const markDirty = () => {
-    if (cs._d) return;
+    if (cs._d || disposed) return;
     cs._d = true;
   };
   markDirty._c = 1;
@@ -694,33 +754,53 @@ function derived(getter, options) {
     }
   }, markDirty);
   const hook = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
-  let evaluating = false;
   const validate = () => {
-    if (!cs._d) return;
+    if (!cs._d || disposed || pendingError !== void 0) return;
     const oldValue = cs._v;
     evaluating = true;
     try {
       retrack2(recompute, markDirty);
       if (!Object.is(oldValue, cs._v)) cs.__v++;
+    } catch (err) {
+      pendingError = { error: err };
+      cs.__v++;
+      if (disposed) cs._d = true;
+      else cs._f = true;
     } finally {
       evaluating = false;
+      if (disposed) cleanup2(markDirty);
     }
-    if (hook && !Object.is(oldValue, cs._v)) {
+    if (hook && !disposed && !Object.is(oldValue, cs._v)) {
       hook.emit("computed:update", { signal: cs, oldValue, newValue: cs._v });
     }
   };
   cs._validate = validate;
+  const throwPending = () => {
+    const { error } = pendingError;
+    pendingError = void 0;
+    if (disposed) cs._d = false;
+    throw error;
+  };
   function computedGetter() {
     if (evaluating) {
       throw new Error(
         `[SibuJS] Circular dependency detected in derived${debugName ? ` "${debugName}"` : ""}. A derived signal cannot read itself (directly or through a chain).`
       );
     }
-    if (isTrackingSuspended2()) {
-      if (cs._d) validate();
+    if (isTrackingSuspended2() || disposed) {
+      if (cs._d) {
+        validate();
+        if (pendingError !== void 0) throwPending();
+      }
       return cs._v;
     }
-    if (cs._d) validate();
+    if (cs._d) {
+      validate();
+      if (pendingError !== void 0) {
+        recordDependency2(cs);
+        throwPending();
+      }
+    }
     recordDependency2(cs);
     return cs._v;
   }
@@ -729,6 +809,19 @@ function derived(getter, options) {
     cs.__name = debugName;
   }
   computedGetter.__signal = cs;
+  computedGetter.dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    cs._d = pendingError !== void 0;
+    cleanup2(markDirty);
+    const h = globalThis.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (h) {
+      try {
+        h.emit("computed:destroy", { signal: cs, getter: computedGetter });
+      } catch {
+      }
+    }
+  };
   if (hook) hook.emit("computed:create", { signal: cs, name: debugName, getter: computedGetter });
   return computedGetter;
 }
@@ -1402,6 +1495,8 @@ function query(key, fetcher, options = {}) {
     if (disposed) return;
     disposed = true;
     effectCleanup();
+    loading.dispose();
+    isStale.dispose();
     if (intervalTimer) clearInterval(intervalTimer);
     detachFromEntry();
     if (focusHandler && typeof globalThis.removeEventListener === "function") {
@@ -1487,7 +1582,7 @@ function mutation(mutationFn, options = {}) {
     abortController = new AbortController();
     const signal2 = abortController.signal;
     const myRun = ++runId;
-    let context2;
+    let context;
     batch(() => {
       setLoading(true);
       setError(void 0);
@@ -1495,7 +1590,7 @@ function mutation(mutationFn, options = {}) {
     });
     try {
       if (options.onMutate) {
-        context2 = await options.onMutate(variables);
+        context = await options.onMutate(variables);
       }
       const result = await withRetry(() => mutationFn(variables, signal2), options.retry, void 0, signal2);
       if (myRun !== runId) return result;
@@ -1506,8 +1601,8 @@ function mutation(mutationFn, options = {}) {
         setLoading(false);
         setStatus("success");
       });
-      runCallback("mutation onSuccess", () => options.onSuccess?.(result, variables, context2));
-      runCallback("mutation onSettled", () => options.onSettled?.(result, void 0, variables, context2));
+      runCallback("mutation onSuccess", () => options.onSuccess?.(result, variables, context));
+      runCallback("mutation onSettled", () => options.onSettled?.(result, void 0, variables, context));
       return result;
     } catch (err) {
       if (isAbortError(err)) {
@@ -1529,8 +1624,8 @@ function mutation(mutationFn, options = {}) {
         setLoading(false);
         setStatus("error");
       });
-      runCallback("mutation onError", () => options.onError?.(errorObj, variables, context2));
-      runCallback("mutation onSettled", () => options.onSettled?.(void 0, errorObj, variables, context2));
+      runCallback("mutation onError", () => options.onError?.(errorObj, variables, context));
+      runCallback("mutation onSettled", () => options.onSettled?.(void 0, errorObj, variables, context));
       throw errorObj;
     }
   }
@@ -1668,18 +1763,21 @@ function infiniteQuery(key, fetcher, options) {
     }
   });
   function fetchNextPage() {
+    if (disposed) return Promise.resolve();
     if (inFlight) return inFlight;
     const param = nextPageParam();
     if (param === void 0) return Promise.resolve();
     return fetchPage(param, "next");
   }
   function fetchPreviousPage() {
+    if (disposed) return Promise.resolve();
     if (inFlight) return inFlight;
     const param = prevPageParam();
     if (param === void 0) return Promise.resolve();
     return fetchPage(param, "prev");
   }
   async function refetch() {
+    if (disposed) return;
     batch(() => {
       setPages([]);
       setNextPageParam(initialPageParam);
@@ -1691,6 +1789,10 @@ function infiniteQuery(key, fetcher, options) {
     disposed = true;
     abortController?.abort();
     effectCleanup();
+    data.dispose();
+    loading.dispose();
+    hasNextPage.dispose();
+    hasPreviousPage.dispose();
   }
   return {
     data,
@@ -1759,25 +1861,26 @@ function throttle(getter, interval) {
   let pending = null;
   let lastEmitted = getter();
   let timer = null;
+  function emit(value) {
+    setThrottled(value);
+    lastEmitted = value;
+    cooldown = true;
+    pending = null;
+    timer = setTimeout(endWindow, interval);
+  }
+  function endWindow() {
+    timer = null;
+    if (pending !== null && !Object.is(pending.value, lastEmitted)) {
+      emit(pending.value);
+      return;
+    }
+    pending = null;
+    cooldown = false;
+  }
   const stop = effect(() => {
     const value = getter();
     if (!cooldown) {
-      if (!Object.is(value, lastEmitted)) {
-        setThrottled(value);
-        lastEmitted = value;
-        cooldown = true;
-        pending = null;
-        timer = setTimeout(() => {
-          timer = null;
-          cooldown = false;
-          if (pending !== null) {
-            const trailingValue = pending.value;
-            pending = null;
-            setThrottled(trailingValue);
-            lastEmitted = trailingValue;
-          }
-        }, interval);
-      }
+      if (!Object.is(value, lastEmitted)) emit(value);
     } else {
       pending = { value };
     }
@@ -1851,7 +1954,7 @@ function resource(sourceOrFetcher, fetcherOrOptions, maybeOptions) {
       });
       runCallback("resource onError", () => options.onError?.(errorObj));
     } finally {
-      if (version === fetchVersion) {
+      if (!disposed && version === fetchVersion) {
         runCallback("resource onSettled", () => options.onSettled?.());
       }
     }
@@ -2157,62 +2260,55 @@ function syncAdapter(config) {
   return config;
 }
 
-// src/core/rendering/context.ts
-function context(defaultValue) {
-  const [getValue, setValue] = signal(defaultValue);
-  const warnIfSSR = (method) => {
-    if (!DEV || !isSSR()) return;
-    devWarn(
-      `context.${method}() called during SSR. SibuJS context() is application-global \u2014 it is NOT isolated per request, so a concurrent request can observe this value. Do not use context() for request-specific SSR data; pass it explicitly or use request-scoped storage instead.`
-    );
-  };
-  const ctx = {
-    provide(value) {
-      warnIfSSR("provide");
-      const previous2 = getValue();
-      setValue(value);
-      return () => setValue(previous2);
-    },
-    use() {
-      return getValue;
-    },
-    get() {
-      return getValue();
-    },
-    set(value) {
-      warnIfSSR("set");
-      setValue(value);
-    },
-    withContext(value, fn) {
-      warnIfSSR("withContext");
-      const previous2 = getValue();
-      setValue(value);
-      try {
-        const result = fn();
-        if (DEV && result !== null && typeof result?.then === "function") {
-          devWarn(
-            "context.withContext() received an async callback. Scoping is synchronous only \u2014 the previous value is restored as soon as the callback returns its promise, so anything after an `await` runs outside the scope."
-          );
-        }
-        return result;
-      } finally {
-        setValue(previous2);
-      }
-    }
-  };
-  return ctx;
-}
-
 // src/data/routeLoader.ts
-var LoaderContext = context(null);
-function executeLoader(loader, context2, options) {
-  const res = resource(({ signal: signal2 }) => loader(context2, { signal: signal2 }), options);
-  LoaderContext.provide(res);
+var _clientScope = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.routeLoader.v2"), () => ({ stack: [] }));
+var _disposed = globalSingleton(/* @__PURE__ */ Symbol.for("sibujs.routeLoader.disposed.v1"), () => /* @__PURE__ */ new WeakSet());
+function currentScope() {
+  const cache = getRequestScopedCache("routeLoader");
+  if (!cache) return _clientScope;
+  let scope = cache.get("scope");
+  if (!scope) {
+    scope = { stack: [] };
+    cache.set("scope", scope);
+  }
+  return scope;
+}
+function executeLoader(loader, context, options) {
+  const res = resource(({ signal: signal2 }) => loader(context, { signal: signal2 }), options);
+  const disposeResource = res.dispose;
+  res.dispose = () => {
+    _disposed.add(res);
+    disposeResource();
+  };
   return res;
 }
+function renderWithLoader(loader, render) {
+  if (_disposed.has(loader)) {
+    throw new Error("renderWithLoader: the loader resource has been disposed");
+  }
+  const scope = currentScope();
+  const entry = loader;
+  scope.stack.push(entry);
+  try {
+    return render();
+  } finally {
+    const index = scope.stack.lastIndexOf(entry);
+    if (index !== -1) scope.stack.splice(index, 1);
+  }
+}
+function withLoader(loader, context, render, options) {
+  const res = executeLoader(loader, context, options);
+  try {
+    return { view: renderWithLoader(res, render), resource: res };
+  } catch (err) {
+    res.dispose();
+    throw err;
+  }
+}
 function loaderData() {
-  const resource2 = LoaderContext.get();
-  if (!resource2) {
+  const scope = currentScope();
+  const resource2 = scope.stack[scope.stack.length - 1];
+  if (!resource2 || _disposed.has(resource2)) {
     throw new Error("loaderData must be used inside a route with a loader");
   }
   return {
@@ -2221,7 +2317,7 @@ function loaderData() {
     error: resource2.error
   };
 }
-async function preloadRoute(route, context2, callerSignal) {
+async function preloadRoute(route, context, callerSignal) {
   if (!route.loader) return void 0;
   const controller = new AbortController();
   let onAbort = null;
@@ -2234,7 +2330,7 @@ async function preloadRoute(route, context2, callerSignal) {
     }
   }
   try {
-    return await route.loader(context2, { signal: controller.signal });
+    return await route.loader(context, { signal: controller.signal });
   } finally {
     if (onAbort) callerSignal?.removeEventListener("abort", onAbort);
   }
@@ -2262,34 +2358,73 @@ function socket(url, options) {
   let heartbeatTimer = null;
   let disposed = false;
   let manuallyClosed = false;
+  let lifecycle = 0;
   function getUrl() {
     return typeof url === "function" ? url() : url;
   }
   function connect() {
     if (disposed) return;
+    const generation = lifecycle;
+    const invalidated = () => disposed || generation !== lifecycle;
     if (typeof WebSocket === "undefined") {
       setStatus("closed");
       return;
     }
-    const safeUrl = validateWsUrl(getUrl());
+    let rawUrl;
+    try {
+      rawUrl = getUrl();
+    } catch (error) {
+      setStatus("closed");
+      reportError(error, { phase: "async", name: "socket" });
+      return;
+    }
+    if (invalidated()) {
+      setStatus("closed");
+      return;
+    }
+    const safeUrl = validateWsUrl(rawUrl);
     if (safeUrl === null) {
       setStatus("closed");
       return;
     }
     setStatus("connecting");
-    ws = new WebSocket(safeUrl, protocols);
-    ws.onopen = () => {
+    if (invalidated()) {
+      setStatus("closed");
+      return;
+    }
+    let instance;
+    try {
+      instance = new WebSocket(safeUrl, protocols);
+    } catch (error) {
+      setStatus("closed");
+      reportError(error, { phase: "async", name: "socket" });
+      return;
+    }
+    if (invalidated()) {
+      instance.close();
+      setStatus("closed");
+      return;
+    }
+    ws = instance;
+    instance.onopen = () => {
+      if (ws !== instance) return;
+      const openGeneration = lifecycle;
       setStatus("open");
+      if (disposed || openGeneration !== lifecycle || ws !== instance) return;
       reconnectCount = 0;
       startHeartbeat();
     };
-    ws.onmessage = (event) => {
+    instance.onmessage = (event) => {
+      if (ws !== instance) return;
       setData(event.data);
     };
-    ws.onclose = () => {
+    instance.onclose = () => {
+      if (ws !== instance) return;
+      ws = null;
+      const closeGeneration = lifecycle;
       setStatus("closed");
       stopHeartbeat();
-      const wasManual = manuallyClosed;
+      const wasManual = manuallyClosed || closeGeneration !== lifecycle;
       manuallyClosed = false;
       if (autoReconnect && !disposed && !wasManual && reconnectCount < maxReconnects) {
         const cap = 3e4;
@@ -2303,7 +2438,7 @@ function socket(url, options) {
         }, jittered);
       }
     };
-    ws.onerror = () => {
+    instance.onerror = () => {
     };
   }
   function startHeartbeat() {
@@ -2327,13 +2462,23 @@ function socket(url, options) {
     }
   }
   function close() {
+    lifecycle++;
     manuallyClosed = true;
     if (reconnectTimer !== null) {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
     }
     stopHeartbeat();
-    if (ws) {
+    if (!ws) {
+      setStatus("closed");
+      return;
+    }
+    if (ws.readyState === WebSocket.CLOSED) {
+      ws = null;
+      setStatus("closed");
+      return;
+    }
+    if (ws.readyState !== WebSocket.CLOSING) {
       setStatus("closing");
       ws.close();
     }
@@ -2391,6 +2536,7 @@ function stream(url, options) {
   let disposed = false;
   let reconnectTimer = null;
   let attempts = 0;
+  let closeGeneration = 0;
   function connect() {
     if (disposed) return;
     if (typeof EventSource === "undefined") {
@@ -2402,44 +2548,64 @@ function stream(url, options) {
       setStatus("closed");
       return;
     }
+    const generation = closeGeneration;
     setStatus("connecting");
-    source = new EventSource(safeUrl, {
+    if (disposed || generation !== closeGeneration) return;
+    const instance = new EventSource(safeUrl, {
       withCredentials: options?.withCredentials ?? false
     });
-    source.onopen = () => {
+    if (disposed || generation !== closeGeneration) {
+      instance.close();
+      return;
+    }
+    source = instance;
+    const live = () => !disposed && source === instance;
+    instance.onopen = () => {
+      if (!live()) return;
       setStatus("open");
       attempts = 0;
     };
-    source.onmessage = (evt) => {
+    instance.onmessage = (evt) => {
+      if (!live()) return;
       setData(evt.data);
       setEvent(evt.type);
     };
-    source.onerror = () => {
-      if (source && source.readyState === EventSource.CLOSED) {
-        setStatus("closed");
-        source = null;
-        if (autoReconnect && !disposed && attempts < maxReconnects) {
-          const delay = Math.min(maxMs, baseMs * 2 ** attempts);
-          const jittered = delay * (0.5 + Math.random() * 0.5);
-          attempts++;
-          reconnectTimer = setTimeout(() => {
-            reconnectTimer = null;
-            connect();
-          }, jittered);
-        }
+    instance.onerror = () => {
+      if (!live() || instance.readyState !== EventSource.CLOSED) return;
+      detach(instance);
+      source = null;
+      const generation2 = closeGeneration;
+      setStatus("closed");
+      if (disposed || generation2 !== closeGeneration) return;
+      if (autoReconnect && attempts < maxReconnects) {
+        const delay = Math.min(maxMs, baseMs * 2 ** attempts);
+        const jittered = delay * (0.5 + Math.random() * 0.5);
+        attempts++;
+        reconnectTimer = setTimeout(() => {
+          reconnectTimer = null;
+          connect();
+        }, jittered);
       }
     };
   }
+  function detach(instance) {
+    instance.onopen = null;
+    instance.onmessage = null;
+    instance.onerror = null;
+  }
   function close() {
+    closeGeneration++;
     if (reconnectTimer !== null) {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
     }
-    if (source) {
-      source.close();
-      setStatus("closed");
+    const instance = source;
+    if (instance) {
       source = null;
+      detach(instance);
+      instance.close();
     }
+    setStatus("closed");
   }
   function dispose() {
     disposed = true;
@@ -2464,11 +2630,13 @@ function stream(url, options) {
   preloadRoute,
   previous,
   query,
+  renderWithLoader,
   resource,
   setQueryData,
   socket,
   stream,
   syncAdapter,
   throttle,
+  withLoader,
   withRetry
 });