v1.9.2 reuse array elements dropped by a shrink when decoding in place

package.json

@@ -1,6 +1,6 @@
 {
   "name": "tinybuf",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "author": "Reece Como <reece.como@gmail.com>",
   "authors": [
     "Reece Como <reece.como@gmail.com>",

src/__tests__/BufferFormat.test.ts

@@ -126,7 +126,7 @@ describe("BufferFormat", () => {
 
     expect(objB2).toBe(obj.b); // longer arrays are re-used
     expect(objC1D1).toBe(obj.c![0]); // underlying object instances ARE recycled
-    expect(objC1D2).not.toBe(obj.c![1]); // ...but only when they existed in the previous instance
+    expect(objC1D2).toBe(obj.c![1]); // ...including instances dropped by a previous shrink
   });
 
   it("can decode a bools bitmask in-place", () => {

src/__tests__/allocations.test.ts

@@ -434,6 +434,49 @@ describe("allocation-free hot paths", () => {
       expect(obj).toEqual({ values: [], items: [] });
       expect(obj.values).toBe(values);
     });
+
+    it("reuses element objects dropped by a shrink when the array grows again", () => {
+      const obj: any = {};
+      ArrFormat.decodeInto(ArrFormat.encode({ values: [], items: [{ v: 1 }, { v: 2 }, { v: 3 }] }, true), obj);
+
+      const [item0, item1, item2] = obj.items;
+
+      ArrFormat.decodeInto(ArrFormat.encode({ values: [], items: [{ v: 4 }] }, true), obj);
+      expect(obj.items).toEqual([{ v: 4 }]);
+      expect(obj.items[0]).toBe(item0);
+
+      ArrFormat.decodeInto(ArrFormat.encode({ values: [], items: [{ v: 5 }, { v: 6 }, { v: 7 }] }, true), obj);
+      expect(obj.items).toEqual([{ v: 5 }, { v: 6 }, { v: 7 }]);
+      expect(new Set(obj.items)).toEqual(new Set([item0, item1, item2]));
+    });
+
+    it("creates no more element objects than the longest arrays need", () => {
+      const NestedFormat = defineFormat({
+        frames: [{ seq: Type.UInt, inputs: [{ x: Type.Scalar8, y: Type.Scalar8 }] }],
+      });
+      const make = (n: number): { frames: { seq: number; inputs: { x: number; y: number }[] }[] } => ({
+        frames: Array.from({ length: n }, (_, i) => ({ seq: i, inputs: Array.from({ length: (n + i) % 3 + 1 }, () => ({ x: 0.5, y: -0.5 })) })),
+      });
+      const encoded = [3, 9, 1, 12, 5, 0, 10, 7].map(n => NestedFormat.encode(make(n), true));
+      const obj: any = {};
+      const seen = new Set<object>();
+
+      for (let pass = 0; pass < 20; pass++) {
+        for (const bytes of encoded) {
+          NestedFormat.decodeInto(bytes, obj);
+
+          for (const frame of obj.frames) {
+            seen.add(frame);
+            seen.add(frame.inputs);
+            for (const input of frame.inputs) seen.add(input);
+          }
+        }
+      }
+
+      const maxFrames = 12;
+      const maxInputs = 3;
+      expect(seen.size).toBeLessThanOrEqual(maxFrames * (2 + maxInputs));
+    });
   });
 
   describe("peekHeader()", () => {

src/core/BufferFormat.ts

@@ -19,6 +19,8 @@ import {
 } from "./Type";
 import { cfg } from "./config";
 
+const spareArrayElements = new WeakMap<any[], any[]>();
+
 export type FormatHeader = string | number;
 
 /**
@@ -566,9 +568,23 @@ export class BufferFormat<EncoderType extends EncoderDefinition, HeaderType exte
   private _$readArray<T extends EncoderDefinition>(type: BufferFormat<T, any>, state: any, obj?: Array<T>): Array<T> {
     const len = coders.uintCoder.$read(state);
     const arr = Array.isArray(obj) ? obj : new Array(len);
+    const prevLen = Array.isArray(obj) ? arr.length : 0;
+    let spare: any[] | undefined;
+
+    if (prevLen !== len && type._$type === undefined) {
+      spare = spareArrayElements.get(arr);
+
+      if (len < prevLen) {
+        if (spare === undefined) spareArrayElements.set(arr, spare = []);
+        for (let j = len; j < prevLen; j++) {
+          if (arr[j] != null) spare.push(arr[j]);
+        }
+      }
+    }
+
     if (arr.length !== len) arr.length = len;
-    for (let j = 0; j < arr.length; j++) {
-      arr[j] = type._$read(state, obj?.[j]);
+    for (let j = 0; j < len; j++) {
+      arr[j] = type._$read(state, j < prevLen ? arr[j] : spare?.pop());
     }
     return arr;
   }