enhance(normalizr,endpoint): Reduce allocations in hot cache paths (#3879)

* enhance(normalizr,endpoint): Reduce allocations in hot cache paths

Inline getCacheKey in GlobalCache to avoid eagerly creating both
localCache and cycleCache Maps per entity type. Replace push(...spread)
with an indexed for-loop when copying cached entity dependencies.

Pre-create _removeSchema in Collection.CreateMover so normalizeMove
no longer calls Object.create on every invocation, eliminating hidden
class polymorphism that caused V8 "wrong call target" deoptimizations.

Made-with: Cursor

* docs: Add optimization rationale comments

Made-with: Cursor

* refactor: Extract getOrCreateLocalCache for readability

Made-with: Cursor

Author: ntucker

packages/endpoint/src/schemas/Collection.ts

@@ -396,7 +396,7 @@ function CreateMover<C extends CollectionSchema<any, any>>(
   addMerge: (existing: any, incoming: any) => any,
   removeMerge: (existing: any, incoming: any) => any,
 ) {
-  return Object.create(
+  const mover = Object.create(
     collection,
     derivedProperties(
       collection,
@@ -412,8 +412,7 @@ function CreateMover<C extends CollectionSchema<any, any>>(
       ) {
         return normalizeMove.call(
           this,
-          addMerge,
-          removeMerge,
+          (this as any)._removeSchema,
           input,
           parent,
           key,
@@ -424,12 +423,17 @@ function CreateMover<C extends CollectionSchema<any, any>>(
       },
     ),
   );
+  // Pre-create the remove schema once so normalizeMove avoids
+  // per-call Object.create (which causes V8 hidden-class polymorphism).
+  mover._removeSchema = Object.create(mover, {
+    merge: { value: removeMerge },
+  });
+  return mover;
 }
 
 function normalizeMove(
   this: CollectionSchema<any, any>,
-  addMerge: (existing: any, incoming: any) => any,
-  removeMergeFunc: (existing: any, incoming: any) => any,
+  removeSchema: CollectionSchema<any, any>,
   input: any,
   parent: any,
   key: string,
@@ -470,10 +474,6 @@ function normalizeMove(
   );
 
   const lastArg = args[args.length - 1];
-  const addSchema = Object.create(this, { merge: { value: addMerge } });
-  const removeSchema = Object.create(this, {
-    merge: { value: removeMergeFunc },
-  });
   const collections = delegate.getEntities(this.key);
 
   // Process each entity's collection membership individually
@@ -507,7 +507,8 @@ function normalizeMove(
         if (shouldRemove && !shouldAdd) {
           delegate.mergeEntity(removeSchema, collectionKey, value);
         } else if (shouldAdd && !shouldRemove) {
-          delegate.mergeEntity(addSchema, collectionKey, value);
+          // this.merge is already the addMerge function
+          delegate.mergeEntity(this, collectionKey, value);
         }
       }
     }

packages/normalizr/src/memo/globalCache.ts

@@ -39,7 +39,9 @@ export default class GlobalCache implements Cache {
     computeValue: (localCacheKey: Map<string, any>) => void,
   ): object | undefined | typeof INVALID {
     const key = schema.key;
-    const { localCacheKey, cycleCacheKey } = this.getCacheKey(key);
+    // cycleCache is deferred to the branch that actually needs it
+    // to avoid unnecessary allocations.
+    const localCacheKey = this.getOrCreateLocalCache(key);
 
     if (!localCacheKey.get(pk)) {
       const globalCache: WeakDependencyMap<
@@ -54,12 +56,17 @@ export default class GlobalCache implements Cache {
         localCacheKey.set(pk, cacheValue.value);
         // TODO: can we store the cache values instead of tracking *all* their sources?
         // this is only used for setting endpoints cache correctly. if we got this far we will def need to set as we would have already tried getting it
-        this.dependencies.push(...cacheValue.dependencies);
+        // Indexed loop avoids spread-into-push overhead for large dep arrays
+        const cdeps = cacheValue.dependencies;
+        for (let i = 0; i < cdeps.length; i++) {
+          this.dependencies.push(cdeps[i]);
+        }
         return cacheValue.value;
       }
       // if we don't find in denormalize cache then do full denormalize
       else {
         const trackingIndex = this.dependencies.length;
+        const cycleCacheKey = this.getOrCreateCycleCache(key);
         cycleCacheKey.set(pk, trackingIndex);
         this.dependencies.push({ path: { key, pk }, entity });
 
@@ -85,8 +92,9 @@ export default class GlobalCache implements Cache {
         }
       }
     } else {
+      const cycleCacheKey = this.cycleCache.get(key);
       // cycle detected
-      if (cycleCacheKey.has(pk)) {
+      if (cycleCacheKey?.has(pk)) {
         this.cycleIndex = cycleCacheKey.get(pk)!;
       } else {
         // with no cycle, globalCacheEntry will have already been set
@@ -96,16 +104,22 @@ export default class GlobalCache implements Cache {
     return localCacheKey.get(pk);
   }
 
-  private getCacheKey(key: string) {
-    if (!this.localCache.has(key)) {
-      this.localCache.set(key, new Map());
+  private getOrCreateLocalCache(key: string): Map<string, any> {
+    let localCacheKey = this.localCache.get(key);
+    if (!localCacheKey) {
+      localCacheKey = new Map();
+      this.localCache.set(key, localCacheKey);
     }
-    if (!this.cycleCache.has(key)) {
-      this.cycleCache.set(key, new Map());
+    return localCacheKey;
+  }
+
+  private getOrCreateCycleCache(key: string): Map<string, number> {
+    let cycleCacheKey = this.cycleCache.get(key);
+    if (!cycleCacheKey) {
+      cycleCacheKey = new Map();
+      this.cycleCache.set(key, cycleCacheKey);
     }
-    const localCacheKey = this.localCache.get(key)!;
-    const cycleCacheKey = this.cycleCache.get(key)!;
-    return { localCacheKey, cycleCacheKey };
+    return cycleCacheKey;
   }
 
   /** Cache varies based on input (=== aka reference) */