@techstuff-dev/foundation-api-utils 2.1.1 → 2.2.0

package/dist/esm/chunks/{slice-DpwJIX84.js → slice-B4QZ6txZ.js}

@@ -45,7 +45,7 @@ var errors = process.env.NODE_ENV !== "production" ? [
 function die(error, ...args) {
   if (process.env.NODE_ENV !== "production") {
     const e = errors[error];
-    const msg = typeof e === "function" ? e.apply(null, args) : e;
+    const msg = isFunction$1(e) ? e.apply(null, args) : e;
     throw new Error(`[Immer] ${msg}`);
   }
   throw new Error(
@@ -54,36 +54,49 @@ function die(error, ...args) {
 }
 
 // src/utils/common.ts
-var getPrototypeOf = Object.getPrototypeOf;
-function isDraft(value) {
-  return !!value && !!value[DRAFT_STATE];
-}
+var O = Object;
+var getPrototypeOf = O.getPrototypeOf;
+var CONSTRUCTOR = "constructor";
+var PROTOTYPE = "prototype";
+var CONFIGURABLE = "configurable";
+var ENUMERABLE = "enumerable";
+var WRITABLE = "writable";
+var VALUE = "value";
+var isDraft = (value) => !!value && !!value[DRAFT_STATE];
 function isDraftable(value) {
   if (!value)
     return false;
-  return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
+  return isPlainObject(value) || isArray(value) || !!value[DRAFTABLE] || !!value[CONSTRUCTOR]?.[DRAFTABLE] || isMap(value) || isSet(value);
 }
-var objectCtorString = Object.prototype.constructor.toString();
+var objectCtorString = O[PROTOTYPE][CONSTRUCTOR].toString();
+var cachedCtorStrings = /* @__PURE__ */ new WeakMap();
 function isPlainObject(value) {
-  if (!value || typeof value !== "object")
+  if (!value || !isObjectish(value))
     return false;
   const proto = getPrototypeOf(value);
-  if (proto === null) {
+  if (proto === null || proto === O[PROTOTYPE])
     return true;
-  }
-  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  const Ctor = O.hasOwnProperty.call(proto, CONSTRUCTOR) && proto[CONSTRUCTOR];
   if (Ctor === Object)
     return true;
-  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+  if (!isFunction$1(Ctor))
+    return false;
+  let ctorString = cachedCtorStrings.get(Ctor);
+  if (ctorString === void 0) {
+    ctorString = Function.toString.call(Ctor);
+    cachedCtorStrings.set(Ctor, ctorString);
+  }
+  return ctorString === objectCtorString;
 }
 function original(value) {
   if (!isDraft(value))
     die(15, value);
   return value[DRAFT_STATE].base_;
 }
-function each(obj, iter) {
+function each(obj, iter, strict = true) {
   if (getArchtype(obj) === 0 /* Object */) {
-    Reflect.ownKeys(obj).forEach((key) => {
+    const keys = strict ? Reflect.ownKeys(obj) : O.keys(obj);
+    keys.forEach((key) => {
       iter(key, obj[key], obj);
     });
   } else {
@@ -92,23 +105,21 @@ function each(obj, iter) {
 }
 function getArchtype(thing) {
   const state = thing[DRAFT_STATE];
-  return state ? state.type_ : Array.isArray(thing) ? 1 /* Array */ : isMap(thing) ? 2 /* Map */ : isSet(thing) ? 3 /* Set */ : 0 /* Object */;
-}
-function has(thing, prop) {
-  return getArchtype(thing) === 2 /* Map */ ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
-}
-function get(thing, prop) {
-  return getArchtype(thing) === 2 /* Map */ ? thing.get(prop) : thing[prop];
+  return state ? state.type_ : isArray(thing) ? 1 /* Array */ : isMap(thing) ? 2 /* Map */ : isSet(thing) ? 3 /* Set */ : 0 /* Object */;
 }
-function set(thing, propOrOldValue, value) {
-  const t = getArchtype(thing);
-  if (t === 2 /* Map */)
+var has = (thing, prop, type = getArchtype(thing)) => type === 2 /* Map */ ? thing.has(prop) : O[PROTOTYPE].hasOwnProperty.call(thing, prop);
+var get = (thing, prop, type = getArchtype(thing)) => (
+  // @ts-ignore
+  type === 2 /* Map */ ? thing.get(prop) : thing[prop]
+);
+var set = (thing, propOrOldValue, value, type = getArchtype(thing)) => {
+  if (type === 2 /* Map */)
     thing.set(propOrOldValue, value);
-  else if (t === 3 /* Set */) {
+  else if (type === 3 /* Set */) {
     thing.add(value);
   } else
     thing[propOrOldValue] = value;
-}
+};
 function is(x, y) {
   if (x === y) {
     return x !== 0 || 1 / x === 1 / y;
@@ -116,15 +127,23 @@ function is(x, y) {
     return x !== x && y !== y;
   }
 }
-function isMap(target) {
-  return target instanceof Map;
-}
-function isSet(target) {
-  return target instanceof Set;
-}
-function latest(state) {
-  return state.copy_ || state.base_;
+var isArray = Array.isArray;
+var isMap = (target) => target instanceof Map;
+var isSet = (target) => target instanceof Set;
+var isObjectish = (target) => typeof target === "object";
+var isFunction$1 = (target) => typeof target === "function";
+var isBoolean = (target) => typeof target === "boolean";
+function isArrayIndex(value) {
+  const n = +value;
+  return Number.isInteger(n) && String(n) === value;
 }
+var getProxyDraft = (value) => {
+  if (!isObjectish(value))
+    return null;
+  return value?.[DRAFT_STATE];
+};
+var latest = (state) => state.copy_ || state.base_;
+var getFinalValue = (state) => state.modified_ ? state.copy_ : state.base_;
 function shallowCopy(base, strict) {
   if (isMap(base)) {
     return new Map(base);
@@ -132,58 +151,77 @@ function shallowCopy(base, strict) {
   if (isSet(base)) {
     return new Set(base);
   }
-  if (Array.isArray(base))
-    return Array.prototype.slice.call(base);
+  if (isArray(base))
+    return Array[PROTOTYPE].slice.call(base);
   const isPlain = isPlainObject(base);
   if (strict === true || strict === "class_only" && !isPlain) {
-    const descriptors = Object.getOwnPropertyDescriptors(base);
+    const descriptors = O.getOwnPropertyDescriptors(base);
     delete descriptors[DRAFT_STATE];
     let keys = Reflect.ownKeys(descriptors);
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i];
       const desc = descriptors[key];
-      if (desc.writable === false) {
-        desc.writable = true;
-        desc.configurable = true;
+      if (desc[WRITABLE] === false) {
+        desc[WRITABLE] = true;
+        desc[CONFIGURABLE] = true;
       }
       if (desc.get || desc.set)
         descriptors[key] = {
-          configurable: true,
-          writable: true,
+          [CONFIGURABLE]: true,
+          [WRITABLE]: true,
           // could live with !!desc.set as well here...
-          enumerable: desc.enumerable,
-          value: base[key]
+          [ENUMERABLE]: desc[ENUMERABLE],
+          [VALUE]: base[key]
         };
     }
-    return Object.create(getPrototypeOf(base), descriptors);
+    return O.create(getPrototypeOf(base), descriptors);
   } else {
     const proto = getPrototypeOf(base);
     if (proto !== null && isPlain) {
       return { ...base };
     }
-    const obj = Object.create(proto);
-    return Object.assign(obj, base);
+    const obj = O.create(proto);
+    return O.assign(obj, base);
   }
 }
 function freeze(obj, deep = false) {
   if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
     return obj;
   if (getArchtype(obj) > 1) {
-    obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;
+    O.defineProperties(obj, {
+      set: dontMutateMethodOverride,
+      add: dontMutateMethodOverride,
+      clear: dontMutateMethodOverride,
+      delete: dontMutateMethodOverride
+    });
   }
-  Object.freeze(obj);
+  O.freeze(obj);
   if (deep)
-    Object.entries(obj).forEach(([key, value]) => freeze(value, true));
+    each(
+      obj,
+      (_key, value) => {
+        freeze(value, true);
+      },
+      false
+    );
   return obj;
 }
 function dontMutateFrozenCollections() {
   die(2);
 }
+var dontMutateMethodOverride = {
+  [VALUE]: dontMutateFrozenCollections
+};
 function isFrozen(obj) {
-  return Object.isFrozen(obj);
+  if (obj === null || !isObjectish(obj))
+    return true;
+  return O.isFrozen(obj);
 }
 
 // src/utils/plugins.ts
+var PluginMapSet = "MapSet";
+var PluginPatches = "Patches";
+var PluginArrayMethods = "ArrayMethods";
 var plugins = {};
 function getPlugin(pluginKey) {
   const plugin = plugins[pluginKey];
@@ -192,6 +230,7 @@ function getPlugin(pluginKey) {
   }
   return plugin;
 }
+var isPluginLoaded = (pluginKey) => !!plugins[pluginKey];
 function loadPlugin(pluginKey, implementation) {
   if (!plugins[pluginKey])
     plugins[pluginKey] = implementation;
@@ -199,23 +238,23 @@ function loadPlugin(pluginKey, implementation) {
 
 // src/core/scope.ts
 var currentScope;
-function getCurrentScope() {
-  return currentScope;
-}
-function createScope(parent_, immer_) {
-  return {
-    drafts_: [],
-    parent_,
-    immer_,
-    // Whenever the modified draft contains a draft from another scope, we
-    // need to prevent auto-freezing so the unowned draft can be finalized.
-    canAutoFreeze_: true,
-    unfinalizedDrafts_: 0
-  };
-}
+var getCurrentScope = () => currentScope;
+var createScope = (parent_, immer_) => ({
+  drafts_: [],
+  parent_,
+  immer_,
+  // Whenever the modified draft contains a draft from another scope, we
+  // need to prevent auto-freezing so the unowned draft can be finalized.
+  canAutoFreeze_: true,
+  unfinalizedDrafts_: 0,
+  handledSet_: /* @__PURE__ */ new Set(),
+  processedForPatches_: /* @__PURE__ */ new Set(),
+  mapSetPlugin_: isPluginLoaded(PluginMapSet) ? getPlugin(PluginMapSet) : void 0,
+  arrayMethodsPlugin_: isPluginLoaded(PluginArrayMethods) ? getPlugin(PluginArrayMethods) : void 0
+});
 function usePatchesInScope(scope, patchListener) {
   if (patchListener) {
-    getPlugin("Patches");
+    scope.patchPlugin_ = getPlugin(PluginPatches);
     scope.patches_ = [];
     scope.inversePatches_ = [];
     scope.patchListener_ = patchListener;
@@ -231,9 +270,7 @@ function leaveScope(scope) {
     currentScope = scope.parent_;
   }
 }
-function enterScope(immer2) {
-  return currentScope = createScope(currentScope, immer2);
-}
+var enterScope = (immer2) => currentScope = createScope(currentScope, immer2);
 function revokeDraft(draft) {
   const state = draft[DRAFT_STATE];
   if (state.type_ === 0 /* Object */ || state.type_ === 1 /* Array */)
@@ -254,105 +291,166 @@ function processResult(result, scope) {
     }
     if (isDraftable(result)) {
       result = finalize(scope, result);
-      if (!scope.parent_)
-        maybeFreeze(scope, result);
     }
-    if (scope.patches_) {
-      getPlugin("Patches").generateReplacementPatches_(
+    const { patchPlugin_ } = scope;
+    if (patchPlugin_) {
+      patchPlugin_.generateReplacementPatches_(
         baseDraft[DRAFT_STATE].base_,
         result,
-        scope.patches_,
-        scope.inversePatches_
+        scope
       );
     }
   } else {
-    result = finalize(scope, baseDraft, []);
+    result = finalize(scope, baseDraft);
   }
+  maybeFreeze(scope, result, true);
   revokeScope(scope);
   if (scope.patches_) {
     scope.patchListener_(scope.patches_, scope.inversePatches_);
   }
   return result !== NOTHING ? result : void 0;
 }
-function finalize(rootScope, value, path) {
+function finalize(rootScope, value) {
   if (isFrozen(value))
     return value;
   const state = value[DRAFT_STATE];
   if (!state) {
-    each(
-      value,
-      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path)
-    );
-    return value;
+    const finalValue = handleValue(value, rootScope.handledSet_, rootScope);
+    return finalValue;
   }
-  if (state.scope_ !== rootScope)
+  if (!isSameScope(state, rootScope)) {
     return value;
+  }
   if (!state.modified_) {
-    maybeFreeze(rootScope, state.base_, true);
     return state.base_;
   }
   if (!state.finalized_) {
-    state.finalized_ = true;
-    state.scope_.unfinalizedDrafts_--;
-    const result = state.copy_;
-    let resultEach = result;
-    let isSet2 = false;
-    if (state.type_ === 3 /* Set */) {
-      resultEach = new Set(result);
-      result.clear();
-      isSet2 = true;
-    }
-    each(
-      resultEach,
-      (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2)
-    );
-    maybeFreeze(rootScope, result, false);
-    if (path && rootScope.patches_) {
-      getPlugin("Patches").generatePatches_(
-        state,
-        path,
-        rootScope.patches_,
-        rootScope.inversePatches_
-      );
+    const { callbacks_ } = state;
+    if (callbacks_) {
+      while (callbacks_.length > 0) {
+        const callback = callbacks_.pop();
+        callback(rootScope);
+      }
     }
+    generatePatchesAndFinalize(state, rootScope);
   }
   return state.copy_;
 }
-function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
-  if (process.env.NODE_ENV !== "production" && childValue === targetObject)
-    die(5);
-  if (isDraft(childValue)) {
-    const path = rootPath && parentState && parentState.type_ !== 3 /* Set */ && // Set objects are atomic since they have no keys.
-    !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
-    const res = finalize(rootScope, childValue, path);
-    set(targetObject, prop, res);
-    if (isDraft(res)) {
-      rootScope.canAutoFreeze_ = false;
-    } else
+function maybeFreeze(scope, value, deep = false) {
+  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
+    freeze(value, deep);
+  }
+}
+function markStateFinalized(state) {
+  state.finalized_ = true;
+  state.scope_.unfinalizedDrafts_--;
+}
+var isSameScope = (state, rootScope) => state.scope_ === rootScope;
+var EMPTY_LOCATIONS_RESULT = [];
+function updateDraftInParent(parent, draftValue, finalizedValue, originalKey) {
+  const parentCopy = latest(parent);
+  const parentType = parent.type_;
+  if (originalKey !== void 0) {
+    const currentValue = get(parentCopy, originalKey, parentType);
+    if (currentValue === draftValue) {
+      set(parentCopy, originalKey, finalizedValue, parentType);
       return;
-  } else if (targetIsSet) {
-    targetObject.add(childValue);
+    }
+  }
+  if (!parent.draftLocations_) {
+    const draftLocations = parent.draftLocations_ = /* @__PURE__ */ new Map();
+    each(parentCopy, (key, value) => {
+      if (isDraft(value)) {
+        const keys = draftLocations.get(value) || [];
+        keys.push(key);
+        draftLocations.set(value, keys);
+      }
+    });
+  }
+  const locations = parent.draftLocations_.get(draftValue) ?? EMPTY_LOCATIONS_RESULT;
+  for (const location of locations) {
+    set(parentCopy, location, finalizedValue, parentType);
   }
-  if (isDraftable(childValue) && !isFrozen(childValue)) {
-    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+}
+function registerChildFinalizationCallback(parent, child, key) {
+  parent.callbacks_.push(function childCleanup(rootScope) {
+    const state = child;
+    if (!state || !isSameScope(state, rootScope)) {
       return;
     }
-    finalize(rootScope, childValue);
-    if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && Object.prototype.propertyIsEnumerable.call(targetObject, prop))
-      maybeFreeze(rootScope, childValue);
+    rootScope.mapSetPlugin_?.fixSetContents(state);
+    const finalizedValue = getFinalValue(state);
+    updateDraftInParent(parent, state.draft_ ?? state, finalizedValue, key);
+    generatePatchesAndFinalize(state, rootScope);
+  });
+}
+function generatePatchesAndFinalize(state, rootScope) {
+  const shouldFinalize = state.modified_ && !state.finalized_ && (state.type_ === 3 /* Set */ || state.type_ === 1 /* Array */ && state.allIndicesReassigned_ || (state.assigned_?.size ?? 0) > 0);
+  if (shouldFinalize) {
+    const { patchPlugin_ } = rootScope;
+    if (patchPlugin_) {
+      const basePath = patchPlugin_.getPath(state);
+      if (basePath) {
+        patchPlugin_.generatePatches_(state, basePath, rootScope);
+      }
+    }
+    markStateFinalized(state);
   }
 }
-function maybeFreeze(scope, value, deep = false) {
-  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
-    freeze(value, deep);
+function handleCrossReference(target, key, value) {
+  const { scope_ } = target;
+  if (isDraft(value)) {
+    const state = value[DRAFT_STATE];
+    if (isSameScope(state, scope_)) {
+      state.callbacks_.push(function crossReferenceCleanup() {
+        prepareCopy(target);
+        const finalizedValue = getFinalValue(state);
+        updateDraftInParent(target, value, finalizedValue, key);
+      });
+    }
+  } else if (isDraftable(value)) {
+    target.callbacks_.push(function nestedDraftCleanup() {
+      const targetCopy = latest(target);
+      if (get(targetCopy, key, target.type_) === value) {
+        if (scope_.drafts_.length > 1 && (target.assigned_.get(key) ?? false) === true && target.copy_) {
+          handleValue(
+            get(target.copy_, key, target.type_),
+            scope_.handledSet_,
+            scope_
+          );
+        }
+      }
+    });
   }
 }
+function handleValue(target, handledSet, rootScope) {
+  if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
+    return target;
+  }
+  if (isDraft(target) || handledSet.has(target) || !isDraftable(target) || isFrozen(target)) {
+    return target;
+  }
+  handledSet.add(target);
+  each(target, (key, value) => {
+    if (isDraft(value)) {
+      const state = value[DRAFT_STATE];
+      if (isSameScope(state, rootScope)) {
+        const updatedValue = getFinalValue(state);
+        set(target, key, updatedValue, target.type_);
+        markStateFinalized(state);
+      }
+    } else if (isDraftable(value)) {
+      handleValue(value, handledSet, rootScope);
+    }
+  });
+  return target;
+}
 
 // src/core/proxy.ts
 function createProxyProxy(base, parent) {
-  const isArray = Array.isArray(base);
+  const baseIsArray = isArray(base);
   const state = {
-    type_: isArray ? 1 /* Array */ : 0 /* Object */,
+    type_: baseIsArray ? 1 /* Array */ : 0 /* Object */,
     // Track which produce call this is associated with.
     scope_: parent ? parent.scope_ : getCurrentScope(),
     // True for both shallow and deep changes.
@@ -360,7 +458,8 @@ function createProxyProxy(base, parent) {
     // Used during finalization.
     finalized_: false,
     // Track which properties have been assigned (true) or deleted (false).
-    assigned_: {},
+    // actually instantiated in `prepareCopy()`
+    assigned_: void 0,
     // The parent draft state.
     parent_: parent,
     // The base state.
@@ -372,34 +471,50 @@ function createProxyProxy(base, parent) {
     copy_: null,
     // Called by the `produce` function.
     revoke_: null,
-    isManual_: false
+    isManual_: false,
+    // `callbacks` actually gets assigned in `createProxy`
+    callbacks_: void 0
   };
   let target = state;
   let traps = objectTraps;
-  if (isArray) {
+  if (baseIsArray) {
     target = [state];
     traps = arrayTraps;
   }
   const { revoke, proxy } = Proxy.revocable(target, traps);
   state.draft_ = proxy;
   state.revoke_ = revoke;
-  return proxy;
+  return [proxy, state];
 }
 var objectTraps = {
   get(state, prop) {
     if (prop === DRAFT_STATE)
       return state;
+    let arrayPlugin = state.scope_.arrayMethodsPlugin_;
+    const isArrayWithStringProp = state.type_ === 1 /* Array */ && typeof prop === "string";
+    if (isArrayWithStringProp) {
+      if (arrayPlugin?.isArrayOperationMethod(prop)) {
+        return arrayPlugin.createMethodInterceptor(state, prop);
+      }
+    }
     const source = latest(state);
-    if (!has(source, prop)) {
+    if (!has(source, prop, state.type_)) {
       return readPropFromProto(state, source, prop);
     }
     const value = source[prop];
     if (state.finalized_ || !isDraftable(value)) {
       return value;
     }
+    if (isArrayWithStringProp && state.operationMethod && arrayPlugin?.isMutatingArrayMethod(
+      state.operationMethod
+    ) && isArrayIndex(prop)) {
+      return value;
+    }
     if (value === peek(state.base_, prop)) {
       prepareCopy(state);
-      return state.copy_[prop] = createProxy(value, state);
+      const childKey = state.type_ === 1 /* Array */ ? +prop : prop;
+      const childDraft = createProxy(state.scope_, value, state, childKey);
+      return state.copy_[childKey] = childDraft;
     }
     return value;
   },
@@ -420,10 +535,10 @@ var objectTraps = {
       const currentState = current2?.[DRAFT_STATE];
       if (currentState && currentState.base_ === value) {
         state.copy_[prop] = value;
-        state.assigned_[prop] = false;
+        state.assigned_.set(prop, false);
         return true;
       }
-      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))
+      if (is(value, current2) && (value !== void 0 || has(state.base_, prop, state.type_)))
         return true;
       prepareCopy(state);
       markChanged(state);
@@ -433,16 +548,17 @@ var objectTraps = {
     Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
       return true;
     state.copy_[prop] = value;
-    state.assigned_[prop] = true;
+    state.assigned_.set(prop, true);
+    handleCrossReference(state, prop, value);
     return true;
   },
   deleteProperty(state, prop) {
+    prepareCopy(state);
     if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
-      state.assigned_[prop] = false;
-      prepareCopy(state);
+      state.assigned_.set(prop, false);
       markChanged(state);
     } else {
-      delete state.assigned_[prop];
+      state.assigned_.delete(prop);
     }
     if (state.copy_) {
       delete state.copy_[prop];
@@ -457,10 +573,10 @@ var objectTraps = {
     if (!desc)
       return desc;
     return {
-      writable: true,
-      configurable: state.type_ !== 1 /* Array */ || prop !== "length",
-      enumerable: desc.enumerable,
-      value: owner[prop]
+      [WRITABLE]: true,
+      [CONFIGURABLE]: state.type_ !== 1 /* Array */ || prop !== "length",
+      [ENUMERABLE]: desc[ENUMERABLE],
+      [VALUE]: owner[prop]
     };
   },
   defineProperty() {
@@ -476,8 +592,9 @@ var objectTraps = {
 var arrayTraps = {};
 each(objectTraps, (key, fn) => {
   arrayTraps[key] = function() {
-    arguments[0] = arguments[0][0];
-    return fn.apply(this, arguments);
+    const args = arguments;
+    args[0] = args[0][0];
+    return fn.apply(this, args);
   };
 });
 arrayTraps.deleteProperty = function(state, prop) {
@@ -497,7 +614,7 @@ function peek(draft, prop) {
 }
 function readPropFromProto(state, source, prop) {
   const desc = getDescriptorFromProto(source, prop);
-  return desc ? `value` in desc ? desc.value : (
+  return desc ? VALUE in desc ? desc[VALUE] : (
     // This is a very special case, if the prop is a getter defined by the
     // prototype, we should invoke it with the draft as context!
     desc.get?.call(state.draft_)
@@ -525,6 +642,7 @@ function markChanged(state) {
 }
 function prepareCopy(state) {
   if (!state.copy_) {
+    state.assigned_ = /* @__PURE__ */ new Map();
     state.copy_ = shallowCopy(
       state.base_,
       state.scope_.immer_.useStrictShallowCopy_
@@ -537,6 +655,7 @@ var Immer2 = class {
   constructor(config) {
     this.autoFreeze_ = true;
     this.useStrictShallowCopy_ = false;
+    this.useStrictIteration_ = false;
     /**
      * The `produce` function takes a value and a "recipe function" (whose
      * return value often depends on the base state). The recipe function is
@@ -557,7 +676,7 @@ var Immer2 = class {
      * @returns {any} a new state, or the initial state if nothing was modified
      */
     this.produce = (base, recipe, patchListener) => {
-      if (typeof base === "function" && typeof recipe !== "function") {
+      if (isFunction$1(base) && !isFunction$1(recipe)) {
         const defaultBase = recipe;
         recipe = base;
         const self = this;
@@ -565,14 +684,14 @@ var Immer2 = class {
           return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
         };
       }
-      if (typeof recipe !== "function")
+      if (!isFunction$1(recipe))
         die(6);
-      if (patchListener !== void 0 && typeof patchListener !== "function")
+      if (patchListener !== void 0 && !isFunction$1(patchListener))
         die(7);
       let result;
       if (isDraftable(base)) {
         const scope = enterScope(this);
-        const proxy = createProxy(base, void 0);
+        const proxy = createProxy(scope, base, void 0);
         let hasError = true;
         try {
           result = recipe(proxy);
@@ -585,7 +704,7 @@ var Immer2 = class {
         }
         usePatchesInScope(scope, patchListener);
         return processResult(result, scope);
-      } else if (!base || typeof base !== "object") {
+      } else if (!base || !isObjectish(base)) {
         result = recipe(base);
         if (result === void 0)
           result = base;
@@ -596,7 +715,10 @@ var Immer2 = class {
         if (patchListener) {
           const p = [];
           const ip = [];
-          getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
+          getPlugin(PluginPatches).generateReplacementPatches_(base, result, {
+            patches_: p,
+            inversePatches_: ip
+          });
           patchListener(p, ip);
         }
         return result;
@@ -604,7 +726,7 @@ var Immer2 = class {
         die(1, base);
     };
     this.produceWithPatches = (base, recipe) => {
-      if (typeof base === "function") {
+      if (isFunction$1(base)) {
         return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
       }
       let patches, inversePatches;
@@ -614,10 +736,12 @@ var Immer2 = class {
       });
       return [result, patches, inversePatches];
     };
-    if (typeof config?.autoFreeze === "boolean")
+    if (isBoolean(config?.autoFreeze))
       this.setAutoFreeze(config.autoFreeze);
-    if (typeof config?.useStrictShallowCopy === "boolean")
+    if (isBoolean(config?.useStrictShallowCopy))
       this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+    if (isBoolean(config?.useStrictIteration))
+      this.setUseStrictIteration(config.useStrictIteration);
   }
   createDraft(base) {
     if (!isDraftable(base))
@@ -625,7 +749,7 @@ var Immer2 = class {
     if (isDraft(base))
       base = current(base);
     const scope = enterScope(this);
-    const proxy = createProxy(base, void 0);
+    const proxy = createProxy(scope, base, void 0);
     proxy[DRAFT_STATE].isManual_ = true;
     leaveScope(scope);
     return proxy;
@@ -654,6 +778,18 @@ var Immer2 = class {
   setUseStrictShallowCopy(value) {
     this.useStrictShallowCopy_ = value;
   }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(value) {
+    this.useStrictIteration_ = value;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
   applyPatches(base, patches) {
     let i;
     for (i = patches.length - 1; i >= 0; i--) {
@@ -666,7 +802,7 @@ var Immer2 = class {
     if (i > -1) {
       patches = patches.slice(i + 1);
     }
-    const applyPatchesImpl = getPlugin("Patches").applyPatches_;
+    const applyPatchesImpl = getPlugin(PluginPatches).applyPatches_;
     if (isDraft(base)) {
       return applyPatchesImpl(base, patches);
     }
@@ -676,10 +812,23 @@ var Immer2 = class {
     );
   }
 };
-function createProxy(value, parent) {
-  const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
-  const scope = parent ? parent.scope_ : getCurrentScope();
+function createProxy(rootScope, value, parent, key) {
+  const [draft, state] = isMap(value) ? getPlugin(PluginMapSet).proxyMap_(value, parent) : isSet(value) ? getPlugin(PluginMapSet).proxySet_(value, parent) : createProxyProxy(value, parent);
+  const scope = parent?.scope_ ?? getCurrentScope();
   scope.drafts_.push(draft);
+  state.callbacks_ = parent?.callbacks_ ?? [];
+  state.key_ = key;
+  if (parent && key !== void 0) {
+    registerChildFinalizationCallback(parent, state, key);
+  } else {
+    state.callbacks_.push(function rootDraftCleanup(rootScope2) {
+      rootScope2.mapSetPlugin_?.fixSetContents(state);
+      const { patchPlugin_ } = rootScope2;
+      if (state.modified_ && patchPlugin_) {
+        patchPlugin_.generatePatches_(state, [], rootScope2);
+      }
+    });
+  }
   return draft;
 }
 
@@ -694,17 +843,23 @@ function currentImpl(value) {
     return value;
   const state = value[DRAFT_STATE];
   let copy;
+  let strict = true;
   if (state) {
     if (!state.modified_)
       return state.base_;
     state.finalized_ = true;
     copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+    strict = state.scope_.immer_.shouldUseStrictIteration();
   } else {
     copy = shallowCopy(value, true);
   }
-  each(copy, (key, childValue) => {
-    set(copy, key, currentImpl(childValue));
-  });
+  each(
+    copy,
+    (key, childValue) => {
+      set(copy, key, currentImpl(childValue));
+    },
+    strict
+  );
   if (state) {
     state.finalized_ = false;
   }
@@ -726,27 +881,86 @@ function enablePatches() {
       "Patching reserved attributes like __proto__, prototype and constructor is not allowed"
     );
   }
+  function getPath(state, path = []) {
+    if ("key_" in state && state.key_ !== void 0) {
+      const parentCopy = state.parent_.copy_ ?? state.parent_.base_;
+      const proxyDraft = getProxyDraft(get(parentCopy, state.key_));
+      const valueAtKey = get(parentCopy, state.key_);
+      if (valueAtKey === void 0) {
+        return null;
+      }
+      if (valueAtKey !== state.draft_ && valueAtKey !== state.base_ && valueAtKey !== state.copy_) {
+        return null;
+      }
+      if (proxyDraft != null && proxyDraft.base_ !== state.base_) {
+        return null;
+      }
+      const isSet2 = state.parent_.type_ === 3 /* Set */;
+      let key;
+      if (isSet2) {
+        const setParent = state.parent_;
+        key = Array.from(setParent.drafts_.keys()).indexOf(state.key_);
+      } else {
+        key = state.key_;
+      }
+      if (!(isSet2 && parentCopy.size > key || has(parentCopy, key))) {
+        return null;
+      }
+      path.push(key);
+    }
+    if (state.parent_) {
+      return getPath(state.parent_, path);
+    }
+    path.reverse();
+    try {
+      resolvePath(state.copy_, path);
+    } catch (e) {
+      return null;
+    }
+    return path;
+  }
+  function resolvePath(base, path) {
+    let current2 = base;
+    for (let i = 0; i < path.length - 1; i++) {
+      const key = path[i];
+      current2 = get(current2, key);
+      if (!isObjectish(current2) || current2 === null) {
+        throw new Error(`Cannot resolve path at '${path.join("/")}'`);
+      }
+    }
+    return current2;
+  }
   const REPLACE = "replace";
   const ADD = "add";
   const REMOVE = "remove";
-  function generatePatches_(state, basePath, patches, inversePatches) {
+  function generatePatches_(state, basePath, scope) {
+    if (state.scope_.processedForPatches_.has(state)) {
+      return;
+    }
+    state.scope_.processedForPatches_.add(state);
+    const { patches_, inversePatches_ } = scope;
     switch (state.type_) {
       case 0 /* Object */:
       case 2 /* Map */:
         return generatePatchesFromAssigned(
           state,
           basePath,
-          patches,
-          inversePatches
+          patches_,
+          inversePatches_
         );
       case 1 /* Array */:
-        return generateArrayPatches(state, basePath, patches, inversePatches);
+        return generateArrayPatches(
+          state,
+          basePath,
+          patches_,
+          inversePatches_
+        );
       case 3 /* Set */:
         return generateSetPatches(
           state,
           basePath,
-          patches,
-          inversePatches
+          patches_,
+          inversePatches_
         );
     }
   }
@@ -757,20 +971,28 @@ function enablePatches() {
       [base_, copy_] = [copy_, base_];
       [patches, inversePatches] = [inversePatches, patches];
     }
+    const allReassigned = state.allIndicesReassigned_ === true;
     for (let i = 0; i < base_.length; i++) {
-      if (assigned_[i] && copy_[i] !== base_[i]) {
+      const copiedItem = copy_[i];
+      const baseItem = base_[i];
+      const isAssigned = allReassigned || assigned_?.get(i.toString());
+      if (isAssigned && copiedItem !== baseItem) {
+        const childState = copiedItem?.[DRAFT_STATE];
+        if (childState && childState.modified_) {
+          continue;
+        }
         const path = basePath.concat([i]);
         patches.push({
           op: REPLACE,
           path,
           // Need to maybe clone it, as it can in fact be the original value
           // due to the base/copy inversion at the start of this function
-          value: clonePatchValueIfNeeded(copy_[i])
+          value: clonePatchValueIfNeeded(copiedItem)
         });
         inversePatches.push({
           op: REPLACE,
           path,
-          value: clonePatchValueIfNeeded(base_[i])
+          value: clonePatchValueIfNeeded(baseItem)
         });
       }
     }
@@ -793,15 +1015,17 @@ function enablePatches() {
     }
   }
   function generatePatchesFromAssigned(state, basePath, patches, inversePatches) {
-    const { base_, copy_ } = state;
+    const { base_, copy_, type_ } = state;
     each(state.assigned_, (key, assignedValue) => {
-      const origValue = get(base_, key);
-      const value = get(copy_, key);
+      const origValue = get(base_, key, type_);
+      const value = get(copy_, key, type_);
       const op = !assignedValue ? REMOVE : has(base_, key) ? REPLACE : ADD;
       if (origValue === value && op === REPLACE)
         return;
       const path = basePath.concat(key);
-      patches.push(op === REMOVE ? { op, path } : { op, path, value });
+      patches.push(
+        op === REMOVE ? { op, path } : { op, path, value: clonePatchValueIfNeeded(value) }
+      );
       inversePatches.push(
         op === ADD ? { op: REMOVE, path } : op === REMOVE ? { op: ADD, path, value: clonePatchValueIfNeeded(origValue) } : { op: REPLACE, path, value: clonePatchValueIfNeeded(origValue) }
       );
@@ -844,13 +1068,14 @@ function enablePatches() {
       i++;
     });
   }
-  function generateReplacementPatches_(baseValue, replacement, patches, inversePatches) {
-    patches.push({
+  function generateReplacementPatches_(baseValue, replacement, scope) {
+    const { patches_, inversePatches_ } = scope;
+    patches_.push({
       op: REPLACE,
       path: [],
       value: replacement === NOTHING ? void 0 : replacement
     });
-    inversePatches.push({
+    inversePatches_.push({
       op: REPLACE,
       path: [],
       value: baseValue
@@ -866,12 +1091,12 @@ function enablePatches() {
         if (typeof p !== "string" && typeof p !== "number") {
           p = "" + p;
         }
-        if ((parentType === 0 /* Object */ || parentType === 1 /* Array */) && (p === "__proto__" || p === "constructor"))
+        if ((parentType === 0 /* Object */ || parentType === 1 /* Array */) && (p === "__proto__" || p === CONSTRUCTOR))
           die(errorOffset + 3);
-        if (typeof base === "function" && p === "prototype")
+        if (isFunction$1(base) && p === PROTOTYPE)
           die(errorOffset + 3);
         base = get(base, p);
-        if (typeof base !== "object")
+        if (!isObjectish(base))
           die(errorOffset + 2, path.join("/"));
       }
       const type = getArchtype(base);
@@ -918,7 +1143,7 @@ function enablePatches() {
   function deepClonePatchValue(obj) {
     if (!isDraftable(obj))
       return obj;
-    if (Array.isArray(obj))
+    if (isArray(obj))
       return obj.map(deepClonePatchValue);
     if (isMap(obj))
       return new Map(
@@ -939,24 +1164,21 @@ function enablePatches() {
     } else
       return obj;
   }
-  loadPlugin("Patches", {
+  loadPlugin(PluginPatches, {
     applyPatches_,
     generatePatches_,
-    generateReplacementPatches_
+    generateReplacementPatches_,
+    getPath
   });
 }
 
 // src/immer.ts
 var immer = new Immer2();
 immer.produce;
-var produceWithPatches = immer.produceWithPatches.bind(
+var produceWithPatches = /* @__PURE__ */ immer.produceWithPatches.bind(
   immer
 );
-immer.setAutoFreeze.bind(immer);
-immer.setUseStrictShallowCopy.bind(immer);
-var applyPatches = immer.applyPatches.bind(immer);
-immer.createDraft.bind(immer);
-immer.finishDraft.bind(immer);
+var applyPatches = /* @__PURE__ */ immer.applyPatches.bind(immer);
 
 // src/getDotPath/getDotPath.ts
 
@@ -1299,20 +1521,24 @@ var createStructuredSelector = Object.assign(
 );
 
 // src/query/core/apiState.ts
-var QueryStatus = /* @__PURE__ */ ((QueryStatus2) => {
-  QueryStatus2["uninitialized"] = "uninitialized";
-  QueryStatus2["pending"] = "pending";
-  QueryStatus2["fulfilled"] = "fulfilled";
-  QueryStatus2["rejected"] = "rejected";
-  return QueryStatus2;
+var QueryStatus = /* @__PURE__ */ ((QueryStatus7) => {
+  QueryStatus7["uninitialized"] = "uninitialized";
+  QueryStatus7["pending"] = "pending";
+  QueryStatus7["fulfilled"] = "fulfilled";
+  QueryStatus7["rejected"] = "rejected";
+  return QueryStatus7;
 })(QueryStatus || {});
+var STATUS_UNINITIALIZED = "uninitialized" /* uninitialized */;
+var STATUS_PENDING = "pending" /* pending */;
+var STATUS_FULFILLED = "fulfilled" /* fulfilled */;
+var STATUS_REJECTED = "rejected" /* rejected */;
 function getRequestStatusFlags(status) {
   return {
     status,
-    isUninitialized: status === "uninitialized" /* uninitialized */,
-    isLoading: status === "pending" /* pending */,
-    isSuccess: status === "fulfilled" /* fulfilled */,
-    isError: status === "rejected" /* rejected */
+    isUninitialized: status === STATUS_UNINITIALIZED,
+    isLoading: status === STATUS_PENDING,
+    isSuccess: status === STATUS_FULFILLED,
+    isError: status === STATUS_REJECTED
   };
 }
 
@@ -1333,8 +1559,15 @@ function copyWithStructuralSharing(oldObj, newObj) {
   return isSameObject ? oldObj : mergeObj;
 }
 
-// src/query/utils/flatten.ts
-var flatten = (arr) => [].concat(...arr);
+// src/query/utils/filterMap.ts
+function filterMap(array, predicate, mapper) {
+  return array.reduce((acc, item, i) => {
+    if (predicate(item, i)) {
+      acc.push(mapper(item, i));
+    }
+    return acc;
+  }, []).flat();
+}
 
 // src/query/utils/isAbsoluteUrl.ts
 function isAbsoluteUrl(url) {
@@ -1388,6 +1621,33 @@ function getOrInsertComputed(map, key, compute) {
 }
 var createNewMap = () => /* @__PURE__ */ new Map();
 
+// src/query/utils/signals.ts
+var timeoutSignal = (milliseconds) => {
+  const abortController = new AbortController();
+  setTimeout(() => {
+    const message = "signal timed out";
+    const name = "TimeoutError";
+    abortController.abort(
+      // some environments (React Native, Node) don't have DOMException
+      typeof DOMException !== "undefined" ? new DOMException(message, name) : Object.assign(new Error(message), {
+        name
+      })
+    );
+  }, milliseconds);
+  return abortController.signal;
+};
+var anySignal = (...signals) => {
+  for (const signal of signals) if (signal.aborted) return AbortSignal.abort(signal.reason);
+  const abortController = new AbortController();
+  for (const signal of signals) {
+    signal.addEventListener("abort", () => abortController.abort(signal.reason), {
+      signal: abortController.signal,
+      once: true
+    });
+  }
+  return abortController.signal;
+};
+
 // src/query/fetchBaseQuery.ts
 var defaultFetchFn = (...args) => fetch(...args);
 var defaultValidateStatus = (response) => response.status >= 200 && response.status <= 299;
@@ -1444,15 +1704,9 @@ function fetchBaseQuery({
     } = typeof arg == "string" ? {
       url: arg
     } : arg;
-    let abortController, signal = api.signal;
-    if (timeout) {
-      abortController = new AbortController();
-      api.signal.addEventListener("abort", abortController.abort);
-      signal = abortController.signal;
-    }
     let config = {
       ...baseFetchOptions,
-      signal,
+      signal: timeout ? anySignal(api.signal, timeoutSignal(timeout)) : api.signal,
       ...rest
     };
     headers = new Headers(stripUndefined(headers));
@@ -1493,23 +1747,17 @@ function fetchBaseQuery({
     meta = {
       request: requestClone
     };
-    let response, timedOut = false, timeoutId = abortController && setTimeout(() => {
-      timedOut = true;
-      abortController.abort();
-    }, timeout);
+    let response;
     try {
       response = await fetchFn(request);
     } catch (e) {
       return {
         error: {
-          status: timedOut ? "TIMEOUT_ERROR" : "FETCH_ERROR",
+          status: (e instanceof Error || typeof DOMException !== "undefined" && e instanceof DOMException) && e.name === "TimeoutError" ? "TIMEOUT_ERROR" : "FETCH_ERROR",
           error: String(e)
         },
         meta
       };
-    } finally {
-      if (timeoutId) clearTimeout(timeoutId);
-      abortController?.signal.removeEventListener("abort", abortController.abort);
     }
     const responseClone = response.clone();
     meta.response = responseClone;
@@ -1571,30 +1819,35 @@ var HandledError = class {
 };
 
 // src/query/core/setupListeners.ts
-var onFocus = /* @__PURE__ */ createAction("__rtkq/focused");
-var onFocusLost = /* @__PURE__ */ createAction("__rtkq/unfocused");
-var onOnline = /* @__PURE__ */ createAction("__rtkq/online");
-var onOffline = /* @__PURE__ */ createAction("__rtkq/offline");
+var INTERNAL_PREFIX = "__rtkq/";
+var ONLINE = "online";
+var OFFLINE = "offline";
+var FOCUSED = "focused";
+var onFocus = /* @__PURE__ */ createAction(`${INTERNAL_PREFIX}${FOCUSED}`);
+var onFocusLost = /* @__PURE__ */ createAction(`${INTERNAL_PREFIX}un${FOCUSED}`);
+var onOnline = /* @__PURE__ */ createAction(`${INTERNAL_PREFIX}${ONLINE}`);
+var onOffline = /* @__PURE__ */ createAction(`${INTERNAL_PREFIX}${OFFLINE}`);
 
 // src/query/endpointDefinitions.ts
+var ENDPOINT_QUERY$1 = "query" /* query */;
+var ENDPOINT_MUTATION$1 = "mutation" /* mutation */;
+var ENDPOINT_INFINITEQUERY$1 = "infinitequery" /* infinitequery */;
 function isQueryDefinition$1(e) {
-  return e.type === "query" /* query */;
+  return e.type === ENDPOINT_QUERY$1;
 }
 function isMutationDefinition$1(e) {
-  return e.type === "mutation" /* mutation */;
+  return e.type === ENDPOINT_MUTATION$1;
 }
 function isInfiniteQueryDefinition$1(e) {
-  return e.type === "infinitequery" /* infinitequery */;
+  return e.type === ENDPOINT_INFINITEQUERY$1;
 }
 function isAnyQueryDefinition(e) {
   return isQueryDefinition$1(e) || isInfiniteQueryDefinition$1(e);
 }
 function calculateProvidedBy(description, result, error, queryArg, meta, assertTagTypes) {
-  if (isFunction(description)) {
-    return description(result, error, queryArg, meta).filter(isNotNullish).map(expandTagDescription).map(assertTagTypes);
-  }
-  if (Array.isArray(description)) {
-    return description.map(expandTagDescription).map(assertTagTypes);
+  const finalDescription = isFunction(description) ? description(result, error, queryArg, meta) : description;
+  if (finalDescription) {
+    return filterMap(finalDescription, isNotNullish, (tag) => assertTagTypes(expandTagDescription(tag)));
   }
   return [];
 }
@@ -1612,6 +1865,9 @@ function asSafePromise(promise, fallback) {
   return promise.catch(fallback);
 }
 
+// src/query/apiTypes.ts
+var getEndpointDefinition = (context, endpointName) => context.endpointDefinitions[endpointName];
+
 // src/query/core/buildInitiate.ts
 var forceQueryFnSymbol = Symbol("forceQueryFn");
 var isUpsertQuery = (arg) => typeof arg[forceQueryFnSymbol] === "function";
@@ -1642,7 +1898,7 @@ function buildInitiate({
   };
   function getRunningQueryThunk(endpointName, queryArgs) {
     return (dispatch) => {
-      const endpointDefinition = context.endpointDefinitions[endpointName];
+      const endpointDefinition = getEndpointDefinition(context, endpointName);
       const queryCacheKey = serializeQueryArgs({
         queryArgs,
         endpointDefinition,
@@ -1689,7 +1945,7 @@ You must add the middleware for RTK-Query to function correctly!`);
       let thunk;
       const commonThunkArgs = {
         ...rest,
-        type: "query",
+        type: ENDPOINT_QUERY$1,
         subscribe,
         forceRefetch,
         subscriptionOptions,
@@ -1703,14 +1959,16 @@ You must add the middleware for RTK-Query to function correctly!`);
       } else {
         const {
           direction,
-          initialPageParam
+          initialPageParam,
+          refetchCachedPages
         } = rest;
         thunk = infiniteQueryThunk({
           ...commonThunkArgs,
           // Supply these even if undefined. This helps with a field existence
           // check over in `buildSlice.ts`
           direction,
-          initialPageParam
+          initialPageParam,
+          refetchCachedPages
         });
       }
       const selector = api.endpoints[endpointName].select(arg);
@@ -1749,9 +2007,10 @@ You must add the middleware for RTK-Query to function correctly!`);
           }
           return result.data;
         },
-        refetch: () => dispatch(queryAction(arg, {
+        refetch: (options) => dispatch(queryAction(arg, {
           subscribe: false,
-          forceRefetch: true
+          forceRefetch: true,
+          ...options
         })),
         unsubscribe() {
           if (subscribe) dispatch(unsubscribeQueryResult({
@@ -1926,7 +2185,7 @@ function buildThunks({
       inversePatches: [],
       undo: () => dispatch(api.util.patchQueryData(endpointName, arg, ret.inversePatches, updateProvided))
     };
-    if (currentState.status === "uninitialized" /* uninitialized */) {
+    if (currentState.status === STATUS_UNINITIALIZED) {
       return ret;
     }
     let newValue;
@@ -1983,6 +2242,7 @@ function buildThunks({
       metaSchema,
       skipSchemaValidation = globalSkipSchemaValidation
     } = endpointDefinition;
+    const isQuery = arg.type === ENDPOINT_QUERY$1;
     try {
       let transformResponse = defaultTransformResponse;
       const baseQueryApi = {
@@ -1993,10 +2253,10 @@ function buildThunks({
         extra,
         endpoint: arg.endpointName,
         type: arg.type,
-        forced: arg.type === "query" ? isForcedQuery(arg, getState()) : void 0,
-        queryCacheKey: arg.type === "query" ? arg.queryCacheKey : void 0
+        forced: isQuery ? isForcedQuery(arg, getState()) : void 0,
+        queryCacheKey: isQuery ? arg.queryCacheKey : void 0
       };
-      const forceQueryFn = arg.type === "query" ? arg[forceQueryFnSymbol] : void 0;
+      const forceQueryFn = isQuery ? arg[forceQueryFnSymbol] : void 0;
       let finalQueryReturnValue;
       const fetchPage = async (data, param, maxPages, previous) => {
         if (param == null && data.pages.length) {
@@ -2085,13 +2345,14 @@ function buildThunks({
           data: transformedResponse
         };
       }
-      if (arg.type === "query" && "infiniteQueryOptions" in endpointDefinition) {
+      if (isQuery && "infiniteQueryOptions" in endpointDefinition) {
         const {
           infiniteQueryOptions
         } = endpointDefinition;
         const {
           maxPages = Infinity
         } = infiniteQueryOptions;
+        const refetchCachedPages = arg.refetchCachedPages ?? infiniteQueryOptions.refetchCachedPages ?? true;
         let result;
         const blankData = {
           pages: [],
@@ -2121,9 +2382,11 @@ function buildThunks({
               data: result.data.pages[0]
             };
           }
-          for (let i = 1; i < totalPages; i++) {
-            const param = getNextPageParam(infiniteQueryOptions, result.data, arg.originalArgs);
-            result = await fetchPage(result.data, param, maxPages);
+          if (refetchCachedPages) {
+            for (let i = 1; i < totalPages; i++) {
+              const param = getNextPageParam(infiniteQueryOptions, result.data, arg.originalArgs);
+              result = await fetchPage(result.data, param, maxPages);
+            }
           }
         }
         finalQueryReturnValue = result;
@@ -2173,7 +2436,7 @@ function buildThunks({
             endpoint: arg.endpointName,
             arg: arg.originalArgs,
             type: arg.type,
-            queryCacheKey: arg.type === "query" ? arg.queryCacheKey : void 0
+            queryCacheKey: isQuery ? arg.queryCacheKey : void 0
           };
           endpointDefinition.onSchemaFailure?.(caughtError, info);
           onSchemaFailure?.(caughtError, info);
@@ -2332,6 +2595,13 @@ function getPreviousPageParam(options, {
 function calculateProvidedByThunk(action, type, endpointDefinitions, assertTagType) {
   return calculateProvidedBy(endpointDefinitions[action.meta.arg.endpointName][type], isFulfilled(action) ? action.payload : void 0, isRejectedWithValue(action) ? action.payload : void 0, action.meta.arg.originalArgs, "baseQueryMeta" in action.meta ? action.meta.baseQueryMeta : void 0, assertTagType);
 }
+
+// src/query/utils/getCurrent.ts
+function getCurrent(value) {
+  return isDraft(value) ? current(value) : value;
+}
+
+// src/query/core/buildSlice.ts
 function updateQuerySubstateIfExists(state, queryCacheKey, update) {
   const substate = state[queryCacheKey];
   if (substate) {
@@ -2365,11 +2635,11 @@ function buildSlice({
   const resetApiState = createAction(`${reducerPath}/resetApiState`);
   function writePendingCacheEntry(draft, arg, upserting, meta) {
     draft[arg.queryCacheKey] ??= {
-      status: "uninitialized" /* uninitialized */,
+      status: STATUS_UNINITIALIZED,
       endpointName: arg.endpointName
     };
     updateQuerySubstateIfExists(draft, arg.queryCacheKey, (substate) => {
-      substate.status = "pending" /* pending */;
+      substate.status = STATUS_PENDING;
       substate.requestId = upserting && substate.requestId ? (
         // for `upsertQuery` **updates**, keep the current `requestId`
         substate.requestId
@@ -2393,7 +2663,7 @@ function buildSlice({
       const {
         merge
       } = definitions[meta.arg.endpointName];
-      substate.status = "fulfilled" /* fulfilled */;
+      substate.status = STATUS_FULFILLED;
       if (merge) {
         if (substate.data !== void 0) {
           const {
@@ -2470,7 +2740,7 @@ function buildSlice({
             } = entry;
             const endpointDefinition = definitions[endpointName];
             const queryDescription = {
-              type: "query",
+              type: ENDPOINT_QUERY$1,
               endpointName,
               originalArgs: entry.arg,
               queryCacheKey: serializeQueryArgs({
@@ -2536,7 +2806,7 @@ function buildSlice({
         updateQuerySubstateIfExists(draft, arg.queryCacheKey, (substate) => {
           if (condition) ; else {
             if (substate.requestId !== requestId) return;
-            substate.status = "rejected" /* rejected */;
+            substate.status = STATUS_REJECTED;
             substate.error = payload ?? error;
           }
         });
@@ -2547,7 +2817,7 @@ function buildSlice({
         for (const [key, entry] of Object.entries(queries)) {
           if (
             // do not rehydrate entries that were currently in flight.
-            entry?.status === "fulfilled" /* fulfilled */ || entry?.status === "rejected" /* rejected */
+            entry?.status === STATUS_FULFILLED || entry?.status === STATUS_REJECTED
           ) {
             draft[key] = entry;
           }
@@ -2583,7 +2853,7 @@ function buildSlice({
         if (!arg.track) return;
         draft[getMutationCacheKey(meta)] = {
           requestId,
-          status: "pending" /* pending */,
+          status: STATUS_PENDING,
           endpointName: arg.endpointName,
           startedTimeStamp
         };
@@ -2594,7 +2864,7 @@ function buildSlice({
         if (!meta.arg.track) return;
         updateMutationSubstateIfExists(draft, meta, (substate) => {
           if (substate.requestId !== meta.requestId) return;
-          substate.status = "fulfilled" /* fulfilled */;
+          substate.status = STATUS_FULFILLED;
           substate.data = payload;
           substate.fulfilledTimeStamp = meta.fulfilledTimeStamp;
         });
@@ -2606,7 +2876,7 @@ function buildSlice({
         if (!meta.arg.track) return;
         updateMutationSubstateIfExists(draft, meta, (substate) => {
           if (substate.requestId !== meta.requestId) return;
-          substate.status = "rejected" /* rejected */;
+          substate.status = STATUS_REJECTED;
           substate.error = payload ?? error;
         });
       }).addMatcher(hasRehydrationInfo, (draft, action) => {
@@ -2616,7 +2886,7 @@ function buildSlice({
         for (const [key, entry] of Object.entries(mutations)) {
           if (
             // do not rehydrate entries that were currently in flight.
-            (entry?.status === "fulfilled" /* fulfilled */ || entry?.status === "rejected" /* rejected */) && // only rehydrate endpoints that were persisted using a `fixedCacheKey`
+            (entry?.status === STATUS_FULFILLED || entry?.status === STATUS_REJECTED) && // only rehydrate endpoints that were persisted using a `fixedCacheKey`
             key !== entry?.requestId
           ) {
             draft[key] = entry;
@@ -2701,19 +2971,19 @@ function buildSlice({
     }
   });
   function removeCacheKeyFromTags(draft, queryCacheKey) {
-    const existingTags = draft.keys[queryCacheKey] ?? [];
+    const existingTags = getCurrent(draft.keys[queryCacheKey] ?? []);
     for (const tag of existingTags) {
       const tagType = tag.type;
       const tagId = tag.id ?? "__internal_without_id";
       const tagSubscriptions = draft.tags[tagType]?.[tagId];
       if (tagSubscriptions) {
-        draft.tags[tagType][tagId] = tagSubscriptions.filter((qc) => qc !== queryCacheKey);
+        draft.tags[tagType][tagId] = getCurrent(tagSubscriptions).filter((qc) => qc !== queryCacheKey);
       }
     }
     delete draft.keys[queryCacheKey];
   }
-  function writeProvidedTagsForQueries(draft, actions2) {
-    const providedByEntries = actions2.map((action) => {
+  function writeProvidedTagsForQueries(draft, actions3) {
+    const providedByEntries = actions3.map((action) => {
       const providedTags = calculateProvidedByThunk(action, "providesTags", definitions, assertTagType);
       const {
         queryCacheKey
@@ -2786,7 +3056,7 @@ function buildSlice({
     config: configSlice.reducer
   });
   const reducer = (state, action) => combinedReducer(resetApiState.match(action) ? void 0 : state, action);
-  const actions = {
+  const actions2 = {
     ...configSlice.actions,
     ...querySlice.actions,
     ...subscriptionSlice.actions,
@@ -2797,14 +3067,14 @@ function buildSlice({
   };
   return {
     reducer,
-    actions
+    actions: actions2
   };
 }
 
 // src/query/core/buildSelectors.ts
 var skipToken = /* @__PURE__ */ Symbol.for("RTKQ/skipToken");
 var initialSubState = {
-  status: "uninitialized" /* uninitialized */
+  status: STATUS_UNINITIALIZED
 };
 var defaultQuerySubState = /* @__PURE__ */ createNextState(initialSubState, () => {
 });
@@ -2919,7 +3189,8 @@ function buildSelectors({
   function selectInvalidatedBy(state, tags) {
     const apiState = state[reducerPath];
     const toInvalidate = /* @__PURE__ */ new Set();
-    for (const tag of tags.filter(isNotNullish).map(expandTagDescription)) {
+    const finalTags = filterMap(tags, isNotNullish, expandTagDescription);
+    for (const tag of finalTags) {
       const provided = apiState.provided.tags[tag.type];
       if (!provided) {
         continue;
@@ -2929,23 +3200,23 @@ function buildSelectors({
         provided[tag.id]
       ) : (
         // no id: invalidate all queries that provide this type
-        flatten(Object.values(provided))
+        Object.values(provided).flat()
       )) ?? [];
       for (const invalidate of invalidateSubscriptions) {
         toInvalidate.add(invalidate);
       }
     }
-    return flatten(Array.from(toInvalidate.values()).map((queryCacheKey) => {
+    return Array.from(toInvalidate.values()).flatMap((queryCacheKey) => {
       const querySubState = apiState.queries[queryCacheKey];
-      return querySubState ? [{
+      return querySubState ? {
         queryCacheKey,
         endpointName: querySubState.endpointName,
         originalArgs: querySubState.originalArgs
-      }] : [];
-    }));
+      } : [];
+    });
   }
   function selectCachedArgsForQuery(state, queryName) {
-    return Object.values(selectQueries(state)).filter((entry) => entry?.endpointName === queryName && entry.status !== "uninitialized" /* uninitialized */).map((entry) => entry.originalArgs);
+    return filterMap(Object.values(selectQueries(state)), (entry) => entry?.endpointName === queryName && entry.status !== STATUS_UNINITIALIZED, (entry) => entry.originalArgs);
   }
   function getHasNextPage(options, data, queryArg) {
     if (!data) return false;
@@ -3046,9 +3317,9 @@ function buildCreateApi(...modules) {
         if (endpoints) {
           for (const [endpointName, partialDefinition] of Object.entries(endpoints)) {
             if (typeof partialDefinition === "function") {
-              partialDefinition(context.endpointDefinitions[endpointName]);
+              partialDefinition(getEndpointDefinition(context, endpointName));
             } else {
-              Object.assign(context.endpointDefinitions[endpointName] || {}, partialDefinition);
+              Object.assign(getEndpointDefinition(context, endpointName) || {}, partialDefinition);
             }
           }
         }
@@ -3060,15 +3331,15 @@ function buildCreateApi(...modules) {
       const evaluatedEndpoints = inject.endpoints({
         query: (x) => ({
           ...x,
-          type: "query" /* query */
+          type: ENDPOINT_QUERY$1
         }),
         mutation: (x) => ({
           ...x,
-          type: "mutation" /* mutation */
+          type: ENDPOINT_MUTATION$1
         }),
         infiniteQuery: (x) => ({
           ...x,
-          type: "infinitequery" /* infinitequery */
+          type: ENDPOINT_INFINITEQUERY$1
         })
       });
       for (const [endpointName, definition] of Object.entries(evaluatedEndpoints)) {
@@ -3114,6 +3385,8 @@ function buildCreateApi(...modules) {
 function safeAssign$1(target, ...args) {
   return Object.assign(target, ...args);
 }
+
+// src/query/core/buildMiddleware/batchActions.ts
 var buildBatchedActionsHandler = ({
   api,
   queryThunk,
@@ -3314,7 +3587,7 @@ var buildCacheCollectionHandler = ({
     }
   }
   function handleUnsubscribe(queryCacheKey, endpointName, api2, config) {
-    const endpointDefinition = context.endpointDefinitions[endpointName];
+    const endpointDefinition = getEndpointDefinition(context, endpointName);
     const keepUnusedDataFor = endpointDefinition?.keepUnusedDataFor ?? config.keepUnusedDataFor;
     if (keepUnusedDataFor === Infinity) {
       return;
@@ -3361,6 +3634,11 @@ var buildCacheLifecycleHandler = ({
   const isMutationThunk = isAsyncThunkAction(mutationThunk);
   const isFulfilledThunk = isFulfilled(queryThunk, mutationThunk);
   const lifecycleMap = {};
+  const {
+    removeQueryResult,
+    removeMutationResult,
+    cacheEntriesUpserted
+  } = api.internalActions;
   function resolveLifecycleEntry(cacheKey, data, meta) {
     const lifecycle = lifecycleMap[cacheKey];
     if (lifecycle?.valueResolved) {
@@ -3378,6 +3656,17 @@ var buildCacheLifecycleHandler = ({
       lifecycle.cacheEntryRemoved();
     }
   }
+  function getActionMetaFields(action) {
+    const {
+      arg,
+      requestId
+    } = action.meta;
+    const {
+      endpointName,
+      originalArgs
+    } = arg;
+    return [endpointName, originalArgs, requestId];
+  }
   const handler = (action, mwApi, stateBefore) => {
     const cacheKey = getCacheKey(action);
     function checkForNewCacheKey(endpointName, cacheKey2, requestId, originalArgs) {
@@ -3388,8 +3677,9 @@ var buildCacheLifecycleHandler = ({
       }
     }
     if (queryThunk.pending.match(action)) {
-      checkForNewCacheKey(action.meta.arg.endpointName, cacheKey, action.meta.requestId, action.meta.arg.originalArgs);
-    } else if (api.internalActions.cacheEntriesUpserted.match(action)) {
+      const [endpointName, originalArgs, requestId] = getActionMetaFields(action);
+      checkForNewCacheKey(endpointName, cacheKey, requestId, originalArgs);
+    } else if (cacheEntriesUpserted.match(action)) {
       for (const {
         queryDescription,
         value
@@ -3405,11 +3695,12 @@ var buildCacheLifecycleHandler = ({
     } else if (mutationThunk.pending.match(action)) {
       const state = mwApi.getState()[reducerPath].mutations[cacheKey];
       if (state) {
-        handleNewKey(action.meta.arg.endpointName, action.meta.arg.originalArgs, cacheKey, mwApi, action.meta.requestId);
+        const [endpointName, originalArgs, requestId] = getActionMetaFields(action);
+        handleNewKey(endpointName, originalArgs, cacheKey, mwApi, requestId);
       }
     } else if (isFulfilledThunk(action)) {
       resolveLifecycleEntry(cacheKey, action.payload, action.meta.baseQueryMeta);
-    } else if (api.internalActions.removeQueryResult.match(action) || api.internalActions.removeMutationResult.match(action)) {
+    } else if (removeQueryResult.match(action) || removeMutationResult.match(action)) {
       removeLifecycleEntry(cacheKey);
     } else if (api.util.resetApiState.match(action)) {
       for (const cacheKey2 of Object.keys(lifecycleMap)) {
@@ -3422,12 +3713,12 @@ var buildCacheLifecycleHandler = ({
     if (isMutationThunk(action)) {
       return action.meta.arg.fixedCacheKey ?? action.meta.requestId;
     }
-    if (api.internalActions.removeQueryResult.match(action)) return action.payload.queryCacheKey;
-    if (api.internalActions.removeMutationResult.match(action)) return getMutationCacheKey(action.payload);
+    if (removeQueryResult.match(action)) return action.payload.queryCacheKey;
+    if (removeMutationResult.match(action)) return getMutationCacheKey(action.payload);
     return "";
   }
   function handleNewKey(endpointName, originalArgs, queryCacheKey, mwApi, requestId) {
-    const endpointDefinition = context.endpointDefinitions[endpointName];
+    const endpointDefinition = getEndpointDefinition(context, endpointName);
     const onCacheEntryAdded = endpointDefinition?.onCacheEntryAdded;
     if (!onCacheEntryAdded) return;
     const lifecycle = {};
@@ -3502,9 +3793,16 @@ var buildInvalidationByTagsHandler = ({
     removeQueryResult
   } = api.internalActions;
   const isThunkActionWithTags = isAnyOf(isFulfilled(mutationThunk), isRejectedWithValue(mutationThunk));
-  const isQueryEnd = isAnyOf(isFulfilled(mutationThunk, queryThunk), isRejected(mutationThunk, queryThunk));
+  const isQueryEnd = isAnyOf(isFulfilled(queryThunk, mutationThunk), isRejected(queryThunk, mutationThunk));
   let pendingTagInvalidations = [];
+  let pendingRequestCount = 0;
   const handler = (action, mwApi) => {
+    if (queryThunk.pending.match(action) || mutationThunk.pending.match(action)) {
+      pendingRequestCount++;
+    }
+    if (isQueryEnd(action)) {
+      pendingRequestCount = Math.max(0, pendingRequestCount - 1);
+    }
     if (isThunkActionWithTags(action)) {
       invalidateTags(calculateProvidedByThunk(action, "invalidatesTags", endpointDefinitions, assertTagType), mwApi);
     } else if (isQueryEnd(action)) {
@@ -3513,23 +3811,14 @@ var buildInvalidationByTagsHandler = ({
       invalidateTags(calculateProvidedBy(action.payload, void 0, void 0, void 0, void 0, assertTagType), mwApi);
     }
   };
-  function hasPendingRequests(state) {
-    const {
-      queries,
-      mutations
-    } = state;
-    for (const cacheRecord of [queries, mutations]) {
-      for (const key in cacheRecord) {
-        if (cacheRecord[key]?.status === "pending" /* pending */) return true;
-      }
-    }
-    return false;
+  function hasPendingRequests() {
+    return pendingRequestCount > 0;
   }
   function invalidateTags(newTags, mwApi) {
     const rootState = mwApi.getState();
     const state = rootState[reducerPath];
     pendingTagInvalidations.push(...newTags);
-    if (state.config.invalidationBehavior === "delayed" && hasPendingRequests(state)) {
+    if (state.config.invalidationBehavior === "delayed" && hasPendingRequests()) {
       return;
     }
     const tags = pendingTagInvalidations;
@@ -3548,7 +3837,7 @@ var buildInvalidationByTagsHandler = ({
             mwApi.dispatch(removeQueryResult({
               queryCacheKey
             }));
-          } else if (querySubState.status !== "uninitialized" /* uninitialized */) {
+          } else if (querySubState.status !== STATUS_UNINITIALIZED) {
             mwApi.dispatch(refetchQuery(querySubState));
           }
         }
@@ -3611,7 +3900,7 @@ var buildPollingHandler = ({
     const state = api2.getState()[reducerPath];
     const querySubState = state.queries[queryCacheKey];
     const subscriptions = currentSubscriptions.get(queryCacheKey);
-    if (!querySubState || querySubState.status === "uninitialized" /* uninitialized */) return;
+    if (!querySubState || querySubState.status === STATUS_UNINITIALIZED) return;
     const {
       lowestPollingInterval,
       skipPollingIfUnfocused
@@ -3642,7 +3931,7 @@ var buildPollingHandler = ({
     const state = api2.getState()[reducerPath];
     const querySubState = state.queries[queryCacheKey];
     const subscriptions = currentSubscriptions.get(queryCacheKey);
-    if (!querySubState || querySubState.status === "uninitialized" /* uninitialized */) {
+    if (!querySubState || querySubState.status === STATUS_UNINITIALIZED) {
       return;
     }
     const {
@@ -3714,7 +4003,7 @@ var buildQueryLifecycleHandler = ({
           originalArgs
         }
       } = action.meta;
-      const endpointDefinition = context.endpointDefinitions[endpointName];
+      const endpointDefinition = getEndpointDefinition(context, endpointName);
       const onQueryStarted = endpointDefinition?.onQueryStarted;
       if (onQueryStarted) {
         const lifecycle = {};
@@ -3799,7 +4088,7 @@ var buildWindowEventHandler = ({
             api2.dispatch(removeQueryResult({
               queryCacheKey
             }));
-          } else if (querySubState.status !== "uninitialized" /* uninitialized */) {
+          } else if (querySubState.status !== STATUS_UNINITIALIZED) {
             api2.dispatch(refetchQuery(querySubState));
           }
         }
@@ -3821,7 +4110,7 @@ function buildMiddleware(input) {
   const {
     apiUid
   } = context;
-  const actions = {
+  const actions2 = {
     invalidateTags: createAction(`${reducerPath}/invalidateTags`)
   };
   const isThisApiSliceAction = (action) => action.type.startsWith(`${reducerPath}/`);
@@ -3874,7 +4163,7 @@ function buildMiddleware(input) {
   };
   return {
     middleware,
-    actions
+    actions: actions2
   };
   function refetchQuery(querySubState) {
     return input.api.endpoints[querySubState.endpointName].initiate(querySubState.originalArgs, {
@@ -4076,7 +4365,7 @@ var coreModule = ({
 // src/query/core/index.ts
 /* @__PURE__ */ buildCreateApi(coreModule());
 
-// src/query/react/index.ts
+// src/query/react/rtkqImports.ts
 
 // src/query/utils/capitalize.ts
 function capitalize(str) {
@@ -4093,14 +4382,17 @@ function countObjectKeys(obj) {
 }
 
 // src/query/endpointDefinitions.ts
+var ENDPOINT_QUERY = "query" /* query */;
+var ENDPOINT_MUTATION = "mutation" /* mutation */;
+var ENDPOINT_INFINITEQUERY = "infinitequery" /* infinitequery */;
 function isQueryDefinition(e) {
-  return e.type === "query" /* query */;
+  return e.type === ENDPOINT_QUERY;
 }
 function isMutationDefinition(e) {
-  return e.type === "mutation" /* mutation */;
+  return e.type === ENDPOINT_MUTATION;
 }
 function isInfiniteQueryDefinition(e) {
-  return e.type === "infinitequery" /* infinitequery */;
+  return e.type === ENDPOINT_INFINITEQUERY;
 }
 
 // src/query/tsHelpers.ts
@@ -4110,6 +4402,8 @@ function safeAssign(target, ...args) {
 
 // src/query/react/constants.ts
 var UNINITIALIZED_VALUE = Symbol();
+
+// src/query/react/useSerializedStableValue.ts
 function useStableQueryArgs(queryArgs) {
   const cache = useRef(queryArgs);
   const copy = useMemo(() => copyWithStructuralSharing(cache.current, queryArgs), [queryArgs]);
@@ -4120,6 +4414,8 @@ function useStableQueryArgs(queryArgs) {
   }, [copy]);
   return copy;
 }
+
+// src/query/react/useShallowStableValue.ts
 function useShallowStableValue(value) {
   const cache = useRef(value);
   useEffect(() => {
@@ -4144,6 +4440,8 @@ var noPendingQueryStateSelector = (selected) => {
       isUninitialized: false,
       isFetching: true,
       isLoading: selected.data !== void 0 ? false : true,
+      // This is the one place where we still have to use `QueryStatus` as an enum,
+      // since it's the only reference in the React package and not in the core.
       status: QueryStatus.pending
     };
   }
@@ -4173,6 +4471,8 @@ function buildHooks({
   context
 }) {
   const usePossiblyImmediateEffect = unstable__sideEffectsInRender ? (cb) => cb() : useEffect;
+  const unsubscribePromiseRef = (ref) => ref.current?.unsubscribe?.();
+  const endpointDefinitions = context.endpointDefinitions;
   return {
     buildQueryHooks,
     buildInfiniteQueryHooks,
@@ -4184,7 +4484,7 @@ function buildHooks({
       const {
         endpointName
       } = lastResult;
-      const endpointDefinition = context.endpointDefinitions[endpointName];
+      const endpointDefinition = endpointDefinitions[endpointName];
       if (queryArgs !== skipToken && serializeQueryArgs({
         queryArgs: lastResult.originalArgs,
         endpointDefinition,
@@ -4215,7 +4515,7 @@ function buildHooks({
       const {
         endpointName
       } = lastResult;
-      const endpointDefinition = context.endpointDefinitions[endpointName];
+      const endpointDefinition = endpointDefinitions[endpointName];
       if (queryArgs !== skipToken && serializeQueryArgs({
         queryArgs: lastResult.originalArgs,
         endpointDefinition,
@@ -4282,6 +4582,8 @@ function buildHooks({
     });
     const initialPageParam = rest.initialPageParam;
     const stableInitialPageParam = useShallowStableValue(initialPageParam);
+    const refetchCachedPages = rest.refetchCachedPages;
+    const stableRefetchCachedPages = useShallowStableValue(refetchCachedPages);
     const promiseRef = useRef(void 0);
     let {
       queryCacheKey,
@@ -4313,15 +4615,16 @@ function buildHooks({
         const promise = dispatch(initiate(stableArg, {
           subscriptionOptions: stableSubscriptionOptions,
           forceRefetch: refetchOnMountOrArgChange,
-          ...isInfiniteQueryDefinition(context.endpointDefinitions[endpointName]) ? {
-            initialPageParam: stableInitialPageParam
+          ...isInfiniteQueryDefinition(endpointDefinitions[endpointName]) ? {
+            initialPageParam: stableInitialPageParam,
+            refetchCachedPages: stableRefetchCachedPages
           } : {}
         }));
         promiseRef.current = promise;
       } else if (stableSubscriptionOptions !== lastSubscriptionOptions) {
         lastPromise.updateSubscriptionOptions(stableSubscriptionOptions);
       }
-    }, [dispatch, initiate, refetchOnMountOrArgChange, stableArg, stableSubscriptionOptions, subscriptionRemoved, stableInitialPageParam, endpointName]);
+    }, [dispatch, initiate, refetchOnMountOrArgChange, stableArg, stableSubscriptionOptions, subscriptionRemoved, stableInitialPageParam, stableRefetchCachedPages, endpointName]);
     return [promiseRef, dispatch, initiate, stableSubscriptionOptions];
   }
   function buildUseQueryState(endpointName, preSelector) {
@@ -4368,7 +4671,7 @@ function buildHooks({
   function usePromiseRefUnsubscribeOnUnmount(promiseRef) {
     useEffect(() => {
       return () => {
-        promiseRef.current?.unsubscribe?.();
+        unsubscribePromiseRef(promiseRef);
         promiseRef.current = void 0;
       };
     }, [promiseRef]);
@@ -4419,7 +4722,7 @@ function buildHooks({
       const trigger = useCallback(function(arg2, preferCacheValue = false) {
         let promise;
         batch(() => {
-          promiseRef.current?.unsubscribe();
+          unsubscribePromiseRef(promiseRef);
           promiseRef.current = promise = dispatch(initiate(arg2, {
             subscriptionOptions: subscriptionOptionsRef.current,
             forceRefetch: !preferCacheValue
@@ -4437,7 +4740,7 @@ function buildHooks({
       }, [dispatch]);
       useEffect(() => {
         return () => {
-          promiseRef?.current?.unsubscribe();
+          unsubscribePromiseRef(promiseRef);
         };
       }, []);
       useEffect(() => {
@@ -4492,10 +4795,12 @@ function buildHooks({
       usePossiblyImmediateEffect(() => {
         subscriptionOptionsRef.current = stableSubscriptionOptions;
       }, [stableSubscriptionOptions]);
+      const hookRefetchCachedPages = options.refetchCachedPages;
+      const stableHookRefetchCachedPages = useShallowStableValue(hookRefetchCachedPages);
       const trigger = useCallback(function(arg2, direction) {
         let promise;
         batch(() => {
-          promiseRef.current?.unsubscribe();
+          unsubscribePromiseRef(promiseRef);
           promiseRef.current = promise = dispatch(initiate(arg2, {
             subscriptionOptions: subscriptionOptionsRef.current,
             direction
@@ -4505,7 +4810,13 @@ function buildHooks({
       }, [promiseRef, dispatch, initiate]);
       usePromiseRefUnsubscribeOnUnmount(promiseRef);
       const stableArg = useStableQueryArgs(options.skip ? skipToken : arg);
-      const refetch = useCallback(() => refetchOrErrorIfUnmounted(promiseRef), [promiseRef]);
+      const refetch = useCallback((options2) => {
+        if (!promiseRef.current) throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(38) : "Cannot refetch a query that has not been started yet.");
+        const mergedOptions = {
+          refetchCachedPages: options2?.refetchCachedPages ?? stableHookRefetchCachedPages
+        };
+        return promiseRef.current.refetch(mergedOptions);
+      }, [promiseRef, stableHookRefetchCachedPages]);
       return useMemo(() => {
         const fetchNextPage = () => {
           return trigger(stableArg, "forward");
@@ -5932,7 +6243,7 @@ const contentApi = createApi({
 const { useGetDataQuery, useLazyGetDataQuery, useGetDataByIdQuery, useLazyGetDataByIdQuery, } = contentApi;
 
 // Dynamic baseQuery that resolves URL at request time and unwraps standard responses
-const dynamicBaseQuery = async (args, api, extraOptions) => {
+const dynamicBaseQuery$1 = async (args, api, extraOptions) => {
     // Resolve base URL at request time, not module load time
     const baseUrl = typeof process !== 'undefined' && process.env?.NEXT_PUBLIC_API_PAYMENTS_PREFIX
         ? process.env.NEXT_PUBLIC_API_PAYMENTS_PREFIX
@@ -5958,7 +6269,7 @@ const dynamicBaseQuery = async (args, api, extraOptions) => {
 };
 const paymentApi = createApi({
     reducerPath: 'paymentApi',
-    baseQuery: dynamicBaseQuery,
+    baseQuery: dynamicBaseQuery$1,
     tagTypes: ['UserSubscription', 'Plans', 'TaxRates', 'PromoCodes'],
     // keepUnusedDataFor: 300,
     endpoints: (builder) => ({
@@ -6000,6 +6311,73 @@ const paymentApi = createApi({
 // Export hooks for usage in functional components.
 const { useCheckUserSubscriptionQuery, useLazyCheckUserSubscriptionQuery, useGetPaymentPlansQuery, useLazyGetPaymentPlansQuery, useGetTaxRatesQuery, useLazyGetTaxRatesQuery, useCheckPromoCodeQuery, useLazyCheckPromoCodeQuery, } = paymentApi;
 
+// Dynamic baseQuery that resolves URL at request time and unwraps standard responses
+const dynamicBaseQuery = async (args, api, extraOptions) => {
+    // Resolve base URL at request time, not module load time
+    const baseUrl = typeof process !== 'undefined' && process.env?.NEXT_PUBLIC_API_PAYMENTS_PREFIX
+        ? process.env.NEXT_PUBLIC_API_PAYMENTS_PREFIX
+        : (API_PAYMENTS_PREFIX || '');
+    const baseQuery = createUnwrappingBaseQuery({
+        baseUrl,
+        prepareHeaders: async (headers) => {
+            headers.set('Content-Type', 'application/json');
+            // Try to add accessToken to headers, but don't fail if unavailable
+            try {
+                const session = await Auth.currentSession();
+                const idToken = session.getIdToken().getJwtToken(); // ID token
+                const accessToken = session.getAccessToken().getJwtToken(); // Access token
+                if (accessToken && idToken) {
+                    headers.set('accesstoken', accessToken);
+                    headers.set('idtoken', idToken);
+                }
+            }
+            catch (error) {
+                // Authentication not available - this is OK for public endpoints like getProducts
+                console.log('Auth not available for products API request');
+            }
+            return headers;
+        },
+        credentials: 'include',
+    });
+    return baseQuery(args, api, extraOptions);
+};
+const productsApi = createApi({
+    reducerPath: 'productsApi',
+    baseQuery: dynamicBaseQuery,
+    tagTypes: ['Products', 'Product'],
+    endpoints: (builder) => ({
+        /**
+         * Get all products
+         * Optional partnerId parameter for filtering
+         */
+        getProducts: builder.query({
+            query: (params) => {
+                const queryString = params?.partnerId ? `?partnerId=${params.partnerId}` : '';
+                return `/payment/products${queryString}`;
+            },
+            providesTags: (result) => result
+                ? [
+                    ...result.products.map(({ id }) => ({ type: 'Product', id })),
+                    { type: 'Products', id: 'LIST' },
+                ]
+                : [{ type: 'Products', id: 'LIST' }],
+        }),
+        /**
+         * Purchase a product
+         */
+        purchaseProduct: builder.mutation({
+            query: (body) => ({
+                url: '/payment/product-purchase',
+                method: 'POST',
+                body,
+            }),
+            invalidatesTags: [{ type: 'Products', id: 'LIST' }],
+        }),
+    }),
+});
+// Export hooks for usage in functional components
+const { useGetProductsQuery, useLazyGetProductsQuery, usePurchaseProductMutation, } = productsApi;
+
 // Create dynamic baseQuery that resolves URL at request time
 const createOrdersBaseQuery = () => {
     const baseUrl = typeof process !== 'undefined' && process.env?.NEXT_PUBLIC_API_ORDERS_PREFIX
@@ -6225,5 +6603,5 @@ const selectCartItemsIds = createSelector$1([selectMediaInCart], (items) => {
 });
 cartSlice.reducer;
 
-export { formatAuthSession as $, emptyCart as A, toggleCart as B, selectMediaInCart as C, selectCartTotal as D, selectCartNetTotal as E, selectCartTaxRate as F, selectCartTaxAmount as G, selectCartCount as H, selectCartStatus as I, selectPromoCode as J, selectCartItems as K, selectCartItemsIds as L, formatUserPayload as M, formatPromos as N, formatWorkout as O, formatShortform as P, formatFaqs as Q, formatPages as R, formatSettings as S, formatPress as T, formatGuests as U, formatVideos as V, formatSections as W, formatSchedule as X, formatChallenges as Y, formatChallengeDays as Z, formatSecondsToISO8601Duration as _, authApi as a, formatFedaratedSession as a0, formatSocialAuthSession as a1, formatConfig as a2, formatSectionPanels as a3, formatSectionItems as a4, formatTaxonomies as a5, formatSeries as a6, formatSeasons as a7, formatLongform as a8, formatMediaItem as a9, isWeb as aa, isReactNative as ab, getPlatform as ac, runOnPlatform as ad, onlyUnique as ae, applyCoupon as af, applyTax as ag, toCamelCaseObject as ah, createUnwrappingBaseQuery as ai, useResetPasswordAuthMutation as b, contentApi as c, useRegisterMutation as d, useVerifyUserQuery as e, useLazyVerifyUserQuery as f, useGetUserInfoQuery as g, useLazyGetUserInfoQuery as h, useUpdateUserInfoMutation as i, useForgottenPasswordMutation as j, useVerifyUserAttributesQuery as k, useLazyVerifyUserAttributesQuery as l, useVerifyUserResendQuery as m, useLazyVerifyUserResendQuery as n, ordersApi as o, paymentApi as p, useUpdateUserMutation as q, cartSlice as r, setTaxRate as s, resetTaxRate as t, useResetPasswordMutation as u, setPromoCode as v, removePromoCode as w, addToCart as x, updateCart as y, removeFromCart as z };
-//# sourceMappingURL=slice-DpwJIX84.js.map
+export { formatSchedule as $, removePromoCode as A, addToCart as B, updateCart as C, removeFromCart as D, emptyCart as E, toggleCart as F, selectMediaInCart as G, selectCartTotal as H, selectCartNetTotal as I, selectCartTaxRate as J, selectCartTaxAmount as K, selectCartCount as L, selectCartStatus as M, selectPromoCode as N, selectCartItems as O, selectCartItemsIds as P, formatUserPayload as Q, formatPromos as R, formatWorkout as S, formatShortform as T, formatFaqs as U, formatPages as V, formatSettings as W, formatPress as X, formatGuests as Y, formatVideos as Z, formatSections as _, authApi as a, formatChallenges as a0, formatChallengeDays as a1, formatSecondsToISO8601Duration as a2, formatAuthSession as a3, formatFedaratedSession as a4, formatSocialAuthSession as a5, formatConfig as a6, formatSectionPanels as a7, formatSectionItems as a8, formatTaxonomies as a9, formatSeries as aa, formatSeasons as ab, formatLongform as ac, formatMediaItem as ad, isWeb as ae, isReactNative as af, getPlatform as ag, runOnPlatform as ah, onlyUnique as ai, applyCoupon as aj, applyTax as ak, toCamelCaseObject as al, createUnwrappingBaseQuery as am, productsApi as b, contentApi as c, useResetPasswordAuthMutation as d, useRegisterMutation as e, useVerifyUserQuery as f, useLazyVerifyUserQuery as g, useGetUserInfoQuery as h, useLazyGetUserInfoQuery as i, useUpdateUserInfoMutation as j, useForgottenPasswordMutation as k, useVerifyUserAttributesQuery as l, useLazyVerifyUserAttributesQuery as m, useVerifyUserResendQuery as n, ordersApi as o, paymentApi as p, useLazyVerifyUserResendQuery as q, useUpdateUserMutation as r, useGetProductsQuery as s, useLazyGetProductsQuery as t, useResetPasswordMutation as u, usePurchaseProductMutation as v, cartSlice as w, setTaxRate as x, resetTaxRate as y, setPromoCode as z };
+//# sourceMappingURL=slice-B4QZ6txZ.js.map