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

package/dist/cjs/chunks/{slice-CNrOPYxy.js → slice-CUaXwIIK.js}

@@ -47,7 +47,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(
@@ -56,36 +56,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 {
@@ -94,23 +107,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;
@@ -118,15 +129,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);
@@ -134,58 +153,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];
@@ -194,6 +232,7 @@ function getPlugin(pluginKey) {
   }
   return plugin;
 }
+var isPluginLoaded = (pluginKey) => !!plugins[pluginKey];
 function loadPlugin(pluginKey, implementation) {
   if (!plugins[pluginKey])
     plugins[pluginKey] = implementation;
@@ -201,23 +240,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;
@@ -233,9 +272,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 */)
@@ -256,105 +293,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.
@@ -362,7 +460,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.
@@ -374,34 +473,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;
   },
@@ -422,10 +537,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);
@@ -435,16 +550,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];
@@ -459,10 +575,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() {
@@ -478,8 +594,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) {
@@ -499,7 +616,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_)
@@ -527,6 +644,7 @@ function markChanged(state) {
 }
 function prepareCopy(state) {
   if (!state.copy_) {
+    state.assigned_ = /* @__PURE__ */ new Map();
     state.copy_ = shallowCopy(
       state.base_,
       state.scope_.immer_.useStrictShallowCopy_
@@ -539,6 +657,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
@@ -559,7 +678,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;
@@ -567,14 +686,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);
@@ -587,7 +706,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;
@@ -598,7 +717,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;
@@ -606,7 +728,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;
@@ -616,10 +738,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))
@@ -627,7 +751,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;
@@ -656,6 +780,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--) {
@@ -668,7 +804,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);
     }
@@ -678,10 +814,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;
 }
 
@@ -696,17 +845,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;
   }
@@ -728,27 +883,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_
         );
     }
   }
@@ -759,20 +973,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)
         });
       }
     }
@@ -795,15 +1017,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) }
       );
@@ -846,13 +1070,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
@@ -868,12 +1093,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);
@@ -920,7 +1145,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(
@@ -941,24 +1166,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
 
@@ -1301,20 +1523,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
   };
 }
 
@@ -1335,8 +1561,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) {
@@ -1390,6 +1623,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;
@@ -1446,15 +1706,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));
@@ -1495,23 +1749,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;
@@ -1573,30 +1821,35 @@ var HandledError = class {
 };
 
 // src/query/core/setupListeners.ts
-var onFocus = /* @__PURE__ */ toolkit.createAction("__rtkq/focused");
-var onFocusLost = /* @__PURE__ */ toolkit.createAction("__rtkq/unfocused");
-var onOnline = /* @__PURE__ */ toolkit.createAction("__rtkq/online");
-var onOffline = /* @__PURE__ */ toolkit.createAction("__rtkq/offline");
+var INTERNAL_PREFIX = "__rtkq/";
+var ONLINE = "online";
+var OFFLINE = "offline";
+var FOCUSED = "focused";
+var onFocus = /* @__PURE__ */ toolkit.createAction(`${INTERNAL_PREFIX}${FOCUSED}`);
+var onFocusLost = /* @__PURE__ */ toolkit.createAction(`${INTERNAL_PREFIX}un${FOCUSED}`);
+var onOnline = /* @__PURE__ */ toolkit.createAction(`${INTERNAL_PREFIX}${ONLINE}`);
+var onOffline = /* @__PURE__ */ toolkit.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 [];
 }
@@ -1614,6 +1867,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";
@@ -1644,7 +1900,7 @@ function buildInitiate({
   };
   function getRunningQueryThunk(endpointName, queryArgs) {
     return (dispatch) => {
-      const endpointDefinition = context.endpointDefinitions[endpointName];
+      const endpointDefinition = getEndpointDefinition(context, endpointName);
       const queryCacheKey = serializeQueryArgs({
         queryArgs,
         endpointDefinition,
@@ -1691,7 +1947,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,
@@ -1705,14 +1961,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);
@@ -1751,9 +2009,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({
@@ -1928,7 +2187,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;
@@ -1985,6 +2244,7 @@ function buildThunks({
       metaSchema,
       skipSchemaValidation = globalSkipSchemaValidation
     } = endpointDefinition;
+    const isQuery = arg.type === ENDPOINT_QUERY$1;
     try {
       let transformResponse = defaultTransformResponse;
       const baseQueryApi = {
@@ -1995,10 +2255,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) {
@@ -2087,13 +2347,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: [],
@@ -2123,9 +2384,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;
@@ -2175,7 +2438,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);
@@ -2334,6 +2597,13 @@ function getPreviousPageParam(options, {
 function calculateProvidedByThunk(action, type, endpointDefinitions, assertTagType) {
   return calculateProvidedBy(endpointDefinitions[action.meta.arg.endpointName][type], toolkit.isFulfilled(action) ? action.payload : void 0, toolkit.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) {
@@ -2367,11 +2637,11 @@ function buildSlice({
   const resetApiState = toolkit.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
@@ -2395,7 +2665,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 {
@@ -2472,7 +2742,7 @@ function buildSlice({
             } = entry;
             const endpointDefinition = definitions[endpointName];
             const queryDescription = {
-              type: "query",
+              type: ENDPOINT_QUERY$1,
               endpointName,
               originalArgs: entry.arg,
               queryCacheKey: serializeQueryArgs({
@@ -2538,7 +2808,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;
           }
         });
@@ -2549,7 +2819,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;
           }
@@ -2585,7 +2855,7 @@ function buildSlice({
         if (!arg.track) return;
         draft[getMutationCacheKey(meta)] = {
           requestId,
-          status: "pending" /* pending */,
+          status: STATUS_PENDING,
           endpointName: arg.endpointName,
           startedTimeStamp
         };
@@ -2596,7 +2866,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;
         });
@@ -2608,7 +2878,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) => {
@@ -2618,7 +2888,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;
@@ -2703,19 +2973,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
@@ -2788,7 +3058,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,
@@ -2799,14 +3069,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__ */ toolkit.createNextState(initialSubState, () => {
 });
@@ -2921,7 +3191,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;
@@ -2931,23 +3202,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;
@@ -3048,9 +3319,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);
             }
           }
         }
@@ -3062,15 +3333,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)) {
@@ -3116,6 +3387,8 @@ function buildCreateApi(...modules) {
 function safeAssign$1(target, ...args) {
   return Object.assign(target, ...args);
 }
+
+// src/query/core/buildMiddleware/batchActions.ts
 var buildBatchedActionsHandler = ({
   api,
   queryThunk,
@@ -3316,7 +3589,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;
@@ -3363,6 +3636,11 @@ var buildCacheLifecycleHandler = ({
   const isMutationThunk = toolkit.isAsyncThunkAction(mutationThunk);
   const isFulfilledThunk = toolkit.isFulfilled(queryThunk, mutationThunk);
   const lifecycleMap = {};
+  const {
+    removeQueryResult,
+    removeMutationResult,
+    cacheEntriesUpserted
+  } = api.internalActions;
   function resolveLifecycleEntry(cacheKey, data, meta) {
     const lifecycle = lifecycleMap[cacheKey];
     if (lifecycle?.valueResolved) {
@@ -3380,6 +3658,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) {
@@ -3390,8 +3679,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
@@ -3407,11 +3697,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)) {
@@ -3424,12 +3715,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 = {};
@@ -3504,9 +3795,16 @@ var buildInvalidationByTagsHandler = ({
     removeQueryResult
   } = api.internalActions;
   const isThunkActionWithTags = toolkit.isAnyOf(toolkit.isFulfilled(mutationThunk), toolkit.isRejectedWithValue(mutationThunk));
-  const isQueryEnd = toolkit.isAnyOf(toolkit.isFulfilled(mutationThunk, queryThunk), toolkit.isRejected(mutationThunk, queryThunk));
+  const isQueryEnd = toolkit.isAnyOf(toolkit.isFulfilled(queryThunk, mutationThunk), toolkit.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)) {
@@ -3515,23 +3813,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;
@@ -3550,7 +3839,7 @@ var buildInvalidationByTagsHandler = ({
             mwApi.dispatch(removeQueryResult({
               queryCacheKey
             }));
-          } else if (querySubState.status !== "uninitialized" /* uninitialized */) {
+          } else if (querySubState.status !== STATUS_UNINITIALIZED) {
             mwApi.dispatch(refetchQuery(querySubState));
           }
         }
@@ -3613,7 +3902,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
@@ -3644,7 +3933,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 {
@@ -3716,7 +4005,7 @@ var buildQueryLifecycleHandler = ({
           originalArgs
         }
       } = action.meta;
-      const endpointDefinition = context.endpointDefinitions[endpointName];
+      const endpointDefinition = getEndpointDefinition(context, endpointName);
       const onQueryStarted = endpointDefinition?.onQueryStarted;
       if (onQueryStarted) {
         const lifecycle = {};
@@ -3801,7 +4090,7 @@ var buildWindowEventHandler = ({
             api2.dispatch(removeQueryResult({
               queryCacheKey
             }));
-          } else if (querySubState.status !== "uninitialized" /* uninitialized */) {
+          } else if (querySubState.status !== STATUS_UNINITIALIZED) {
             api2.dispatch(refetchQuery(querySubState));
           }
         }
@@ -3823,7 +4112,7 @@ function buildMiddleware(input) {
   const {
     apiUid
   } = context;
-  const actions = {
+  const actions2 = {
     invalidateTags: toolkit.createAction(`${reducerPath}/invalidateTags`)
   };
   const isThisApiSliceAction = (action) => action.type.startsWith(`${reducerPath}/`);
@@ -3876,7 +4165,7 @@ function buildMiddleware(input) {
   };
   return {
     middleware,
-    actions
+    actions: actions2
   };
   function refetchQuery(querySubState) {
     return input.api.endpoints[querySubState.endpointName].initiate(querySubState.originalArgs, {
@@ -4078,7 +4367,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) {
@@ -4095,14 +4384,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
@@ -4112,6 +4404,8 @@ function safeAssign(target, ...args) {
 
 // src/query/react/constants.ts
 var UNINITIALIZED_VALUE = Symbol();
+
+// src/query/react/useSerializedStableValue.ts
 function useStableQueryArgs(queryArgs) {
   const cache = React.useRef(queryArgs);
   const copy = React.useMemo(() => copyWithStructuralSharing(cache.current, queryArgs), [queryArgs]);
@@ -4122,6 +4416,8 @@ function useStableQueryArgs(queryArgs) {
   }, [copy]);
   return copy;
 }
+
+// src/query/react/useShallowStableValue.ts
 function useShallowStableValue(value) {
   const cache = React.useRef(value);
   React.useEffect(() => {
@@ -4146,6 +4442,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
     };
   }
@@ -4175,6 +4473,8 @@ function buildHooks({
   context
 }) {
   const usePossiblyImmediateEffect = unstable__sideEffectsInRender ? (cb) => cb() : React.useEffect;
+  const unsubscribePromiseRef = (ref) => ref.current?.unsubscribe?.();
+  const endpointDefinitions = context.endpointDefinitions;
   return {
     buildQueryHooks,
     buildInfiniteQueryHooks,
@@ -4186,7 +4486,7 @@ function buildHooks({
       const {
         endpointName
       } = lastResult;
-      const endpointDefinition = context.endpointDefinitions[endpointName];
+      const endpointDefinition = endpointDefinitions[endpointName];
       if (queryArgs !== skipToken && serializeQueryArgs({
         queryArgs: lastResult.originalArgs,
         endpointDefinition,
@@ -4217,7 +4517,7 @@ function buildHooks({
       const {
         endpointName
       } = lastResult;
-      const endpointDefinition = context.endpointDefinitions[endpointName];
+      const endpointDefinition = endpointDefinitions[endpointName];
       if (queryArgs !== skipToken && serializeQueryArgs({
         queryArgs: lastResult.originalArgs,
         endpointDefinition,
@@ -4284,6 +4584,8 @@ function buildHooks({
     });
     const initialPageParam = rest.initialPageParam;
     const stableInitialPageParam = useShallowStableValue(initialPageParam);
+    const refetchCachedPages = rest.refetchCachedPages;
+    const stableRefetchCachedPages = useShallowStableValue(refetchCachedPages);
     const promiseRef = React.useRef(void 0);
     let {
       queryCacheKey,
@@ -4315,15 +4617,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) {
@@ -4370,7 +4673,7 @@ function buildHooks({
   function usePromiseRefUnsubscribeOnUnmount(promiseRef) {
     React.useEffect(() => {
       return () => {
-        promiseRef.current?.unsubscribe?.();
+        unsubscribePromiseRef(promiseRef);
         promiseRef.current = void 0;
       };
     }, [promiseRef]);
@@ -4421,7 +4724,7 @@ function buildHooks({
       const trigger = React.useCallback(function(arg2, preferCacheValue = false) {
         let promise;
         batch(() => {
-          promiseRef.current?.unsubscribe();
+          unsubscribePromiseRef(promiseRef);
           promiseRef.current = promise = dispatch(initiate(arg2, {
             subscriptionOptions: subscriptionOptionsRef.current,
             forceRefetch: !preferCacheValue
@@ -4439,7 +4742,7 @@ function buildHooks({
       }, [dispatch]);
       React.useEffect(() => {
         return () => {
-          promiseRef?.current?.unsubscribe();
+          unsubscribePromiseRef(promiseRef);
         };
       }, []);
       React.useEffect(() => {
@@ -4494,10 +4797,12 @@ function buildHooks({
       usePossiblyImmediateEffect(() => {
         subscriptionOptionsRef.current = stableSubscriptionOptions;
       }, [stableSubscriptionOptions]);
+      const hookRefetchCachedPages = options.refetchCachedPages;
+      const stableHookRefetchCachedPages = useShallowStableValue(hookRefetchCachedPages);
       const trigger = React.useCallback(function(arg2, direction) {
         let promise;
         batch(() => {
-          promiseRef.current?.unsubscribe();
+          unsubscribePromiseRef(promiseRef);
           promiseRef.current = promise = dispatch(initiate(arg2, {
             subscriptionOptions: subscriptionOptionsRef.current,
             direction
@@ -4507,7 +4812,13 @@ function buildHooks({
       }, [promiseRef, dispatch, initiate]);
       usePromiseRefUnsubscribeOnUnmount(promiseRef);
       const stableArg = useStableQueryArgs(options.skip ? skipToken : arg);
-      const refetch = React.useCallback(() => refetchOrErrorIfUnmounted(promiseRef), [promiseRef]);
+      const refetch = React.useCallback((options2) => {
+        if (!promiseRef.current) throw new Error(process.env.NODE_ENV === "production" ? toolkit.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 React.useMemo(() => {
         const fetchNextPage = () => {
           return trigger(stableArg, "forward");
@@ -5934,7 +6245,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
@@ -5960,7 +6271,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) => ({
@@ -6002,6 +6313,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 awsAmplify.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
@@ -6267,6 +6645,7 @@ exports.isWeb = isWeb;
 exports.onlyUnique = onlyUnique;
 exports.ordersApi = ordersApi;
 exports.paymentApi = paymentApi;
+exports.productsApi = productsApi;
 exports.removeFromCart = removeFromCart;
 exports.removePromoCode = removePromoCode;
 exports.resetTaxRate = resetTaxRate;
@@ -6287,11 +6666,14 @@ exports.toCamelCaseObject = toCamelCaseObject;
 exports.toggleCart = toggleCart;
 exports.updateCart = updateCart;
 exports.useForgottenPasswordMutation = useForgottenPasswordMutation;
+exports.useGetProductsQuery = useGetProductsQuery;
 exports.useGetUserInfoQuery = useGetUserInfoQuery;
+exports.useLazyGetProductsQuery = useLazyGetProductsQuery;
 exports.useLazyGetUserInfoQuery = useLazyGetUserInfoQuery;
 exports.useLazyVerifyUserAttributesQuery = useLazyVerifyUserAttributesQuery;
 exports.useLazyVerifyUserQuery = useLazyVerifyUserQuery;
 exports.useLazyVerifyUserResendQuery = useLazyVerifyUserResendQuery;
+exports.usePurchaseProductMutation = usePurchaseProductMutation;
 exports.useRegisterMutation = useRegisterMutation;
 exports.useResetPasswordAuthMutation = useResetPasswordAuthMutation;
 exports.useResetPasswordMutation = useResetPasswordMutation;
@@ -6300,4 +6682,4 @@ exports.useUpdateUserMutation = useUpdateUserMutation;
 exports.useVerifyUserAttributesQuery = useVerifyUserAttributesQuery;
 exports.useVerifyUserQuery = useVerifyUserQuery;
 exports.useVerifyUserResendQuery = useVerifyUserResendQuery;
-//# sourceMappingURL=slice-CNrOPYxy.js.map
+//# sourceMappingURL=slice-CUaXwIIK.js.map