bun-shared-memory 0.1.5 → 0.1.7

package/src/memory.ts

@@ -1,4 +1,8 @@
-import { GrowableBuffer, SharedBudget } from "./growable-buffer.ts";
+import {
+  GrowableBuffer,
+  SharedBudget,
+  nextPowerOfTwo,
+} from "./growable-buffer.ts";
 import { Mutex } from "./mutex.ts";
 
 /**
@@ -30,10 +34,11 @@ import { Mutex } from "./mutex.ts";
  *   [12..15] reserved
  *   then propertyCount * (nameRef(8 bytes) + valueSlot(16 bytes))
  *
- * Index Table entry (12 bytes):
+ * Index Table entry (16 bytes):
  *   [0..3]   key string offset
  *   [4..7]   key string length
  *   [8..11]  data offset (into DataTable)
+ *   [12..15] key version
  */
 
 export const TYPE_NUMBER = 0;
@@ -51,11 +56,19 @@ const INDEX_ENTRY_SIZE = 16;
 const INDEX_HEADER = 4;
 /** Byte offset of the version field within an index entry. */
 const INDEX_VERSION_OFFSET = 12;
+const MAX_INDEX_TABLE_BYTES = 4 * 1024 * 1024 * 1024;
 /** Size of the objectId header at the start of each array block. */
 const ARRAY_HEADER = 4;
 
 const DEFAULT_INITIAL = 1024;
 const DEFAULT_MAX = 64 * 1024 * 1024; // 64 MiB
+const DEFAULT_CHUNK_SIZE = 32 * 1024 * 1024; // 32 MiB per chunk
+/** Minimum size of a single chunk (a chunk is the minimum growth step). */
+const MIN_CHUNK_SIZE = 4 * 1024 * 1024; // 4 MiB
+/** Minimum combined memory budget (maxTotalBytes / maxByteLength). */
+const MIN_MAX_MEMORY = 32 * 1024 * 1024; // 32 MiB
+/** Maximum number of chunks per table (chunkSize must be large enough). */
+const MAX_CHUNKS_PER_TABLE = 1024;
 const DEFAULT_INTERN_CAPACITY = 256;
 const DEFAULT_INTERN_MAX = 1 << 16; // 65536 entries
 
@@ -172,22 +185,65 @@ export function decodeSlot(slot: ValueSlot): unknown {
 
 export interface SharedMemoryOptions {
   initialSize?: number;
+  /** Per-buffer maximum byte length (clamped to at least 32 MiB). */
   maxByteLength?: number;
-  /** Total memory budget shared across all buffers (see below). */
+  /**
+   * Total physical memory budget shared by DataTable, StringTable, and
+   * ArrayTable (clamped to at least 32 MiB).
+   */
   maxTotalBytes?: number;
+  /** Internal worker reconstruction option; normally inferred from buffers. */
+  indexTableMaxByteLength?: number;
+  /**
+   * Size of each growable chunk (the minimum growth step). Default 32 MiB,
+   * clamped to at least 4 MiB and raised as needed so no table needs more
+   * than 1024 chunks.
+   */
+  chunkSize?: number;
   lock?: Mutex;
   internCapacity?: number;
   internMax?: number;
   buffers?: {
-    indexTable?: SharedArrayBuffer;
-    dataTable?: SharedArrayBuffer;
-    stringTable?: SharedArrayBuffer;
-    arrayTable?: SharedArrayBuffer;
+    indexTable?: SharedArrayBuffer | SharedArrayBuffer[];
+    dataTable?: SharedArrayBuffer | SharedArrayBuffer[];
+    stringTable?: SharedArrayBuffer | SharedArrayBuffer[];
+    arrayTable?: SharedArrayBuffer | SharedArrayBuffer[];
     layoutVersion?: SharedArrayBuffer;
     refCount?: SharedArrayBuffer;
+    budget?: SharedArrayBuffer;
   };
 }
 
+/** Build a GrowableBuffer from an optional single SAB, chunk list, or nothing. */
+function makeBuffer(
+  buf: SharedArrayBuffer | SharedArrayBuffer[] | undefined,
+  initial: number,
+  maxByteLength: number,
+  budget?: SharedBudget,
+  chunkSize?: number,
+  singleBuffer = false,
+  chargeInitial = true,
+): GrowableBuffer {
+  if (buf === undefined) {
+    return new GrowableBuffer(
+      initial,
+      maxByteLength,
+      budget,
+      chunkSize,
+      singleBuffer,
+      chargeInitial,
+    );
+  }
+  return new GrowableBuffer(
+    buf,
+    maxByteLength,
+    budget,
+    chunkSize,
+    singleBuffer,
+    chargeInitial,
+  );
+}
+
 /**
  * Manages the four shared buffers and provides operations to store and read
  * strings, arrays, and objects.
@@ -197,6 +253,12 @@ export class SharedMemory {
   readonly dataTable: GrowableBuffer;
   readonly stringTable: GrowableBuffer;
   readonly arrayTable: GrowableBuffer;
+  /** Per-buffer maximum byte length (clamped to at least 32 MiB). */
+  readonly maxByteLength: number;
+  private readonly indexTableMaxByteLength: number;
+  /** Combined memory budget for Data/String/Array tables, or null if unset. */
+  readonly maxTotalBytes: number | null;
+  private readonly budgetBuffer: SharedArrayBuffer | null;
   /**
    * Cached Int32Array view over the Index Table, used to read/increment each
    * key's version cell (stored as the 4th field of each index entry). Rebuilt
@@ -246,44 +308,86 @@ export class SharedMemory {
 
   constructor(options?: SharedMemoryOptions) {
     const initial = options?.initialSize ?? DEFAULT_INITIAL;
-    // A single SharedArrayBuffer can be at most 4 GiB. `maxTotalBytes` is a
-    // *total* budget shared across all buffers: each buffer's own maxByteLength
-    // is capped at min(4 GiB, maxTotalBytes), and the sum of all buffers'
-    // physical sizes is additionally capped at maxTotalBytes. Without
-    // maxTotalBytes, each buffer simply grows up to its own maxByteLength.
+    // `maxTotalBytes` caps the combined physical size of DataTable,
+    // StringTable, and ArrayTable. IndexTable has its independent 4 GiB cap.
+    // Without maxTotalBytes, each buffer grows up to its own maxByteLength.
+    // The Index Table remains a single growable SharedArrayBuffer and is
+    // capped at 4 GiB. The other tables use chunks and can exceed that limit.
     const maxTotal = options?.maxTotalBytes;
-    const perBufferMax = Math.min(
-      4 * 1024 * 1024 * 1024,
+    if (
+      maxTotal !== undefined &&
+      (!Number.isSafeInteger(maxTotal) || maxTotal < 0)
+    ) {
+      throw new RangeError("maxTotalBytes must be a non-negative safe integer");
+    }
+    // Enforce the minimum memory budget: maxTotalBytes / maxByteLength are
+    // never below 32 MiB.
+    const perBufferMax = Math.max(
       maxTotal ?? options?.maxByteLength ?? DEFAULT_MAX,
+      MIN_MAX_MEMORY,
+    );
+    const indexTableMax = Math.min(
+      options?.indexTableMaxByteLength ?? options?.maxByteLength ?? DEFAULT_MAX,
+      MAX_INDEX_TABLE_BYTES,
+    );
+    // Enforce the chunk-size limits: at least 4 MiB, and large enough that no
+    // table needs more than MAX_CHUNKS_PER_TABLE chunks.
+    const userChunkSize = options?.chunkSize ?? DEFAULT_CHUNK_SIZE;
+    const chunkSize = Math.max(
+      userChunkSize,
+      MIN_CHUNK_SIZE,
+      nextPowerOfTwo(perBufferMax / MAX_CHUNKS_PER_TABLE),
     );
-    const budget =
-      maxTotal !== undefined ? new SharedBudget(maxTotal) : undefined;
     const buffers = options?.buffers;
-    this.indexTable = new GrowableBuffer(
-      buffers?.indexTable ??
-        new SharedArrayBuffer(initial, { maxByteLength: perBufferMax }),
-      perBufferMax,
-      budget,
+    // The budget is the clamped maxTotalBytes (never below MIN_MAX_MEMORY), so
+    // it stays consistent with perBufferMax.
+    const budgetMax = maxTotal !== undefined ? perBufferMax : undefined;
+    const budgetBuffer = buffers?.budget;
+    const budget =
+      budgetMax !== undefined
+        ? new SharedBudget(budgetMax, budgetBuffer)
+        : undefined;
+    const chargeInitial = budgetBuffer === undefined;
+    this.maxByteLength = perBufferMax;
+    this.indexTableMaxByteLength = indexTableMax;
+    this.maxTotalBytes = budgetMax ?? null;
+    this.budgetBuffer = budget?.buffer ?? null;
+    this.indexTable = makeBuffer(
+      buffers?.indexTable,
+      initial,
+      indexTableMax,
+      undefined,
+      chunkSize,
+      true,
     );
-    this.dataTable = new GrowableBuffer(
-      buffers?.dataTable ??
-        new SharedArrayBuffer(initial, { maxByteLength: perBufferMax }),
+    this.dataTable = makeBuffer(
+      buffers?.dataTable,
+      initial,
       perBufferMax,
       budget,
+      chunkSize,
+      false,
+      chargeInitial,
     );
-    this.stringTable = new GrowableBuffer(
-      buffers?.stringTable ??
-        new SharedArrayBuffer(initial, { maxByteLength: perBufferMax }),
+    this.stringTable = makeBuffer(
+      buffers?.stringTable,
+      initial,
       perBufferMax,
       budget,
+      chunkSize,
+      false,
+      chargeInitial,
     );
-    this.arrayTable = new GrowableBuffer(
-      buffers?.arrayTable ??
-        new SharedArrayBuffer(initial, { maxByteLength: perBufferMax }),
+    this.arrayTable = makeBuffer(
+      buffers?.arrayTable,
+      initial,
       perBufferMax,
       budget,
+      chunkSize,
+      false,
+      chargeInitial,
     );
-    this.versionView = new Int32Array(this.indexTable.buffer);
+    this.versionView = new Int32Array(this.indexTable.buffers[0]!);
     this.layoutVersion = new Int32Array(
       buffers?.layoutVersion ??
         new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT),
@@ -299,6 +403,24 @@ export class SharedMemory {
     return this.lock.withLock(fn);
   }
 
+  /**
+   * Apply a buffer update received from the main thread after a
+   * defragmentation pass. Replaces each table's buffers and rebuilds the
+   * version view. Called by workers on the `__chunkUpdate` message.
+   */
+  applyChunkUpdate(buffers: {
+    indexTable: SharedArrayBuffer[];
+    dataTable: SharedArrayBuffer[];
+    stringTable: SharedArrayBuffer[];
+    arrayTable: SharedArrayBuffer[];
+  }): void {
+    this.indexTable.applyChunks(buffers.indexTable);
+    this.dataTable.applyChunks(buffers.dataTable);
+    this.stringTable.applyChunks(buffers.stringTable);
+    this.arrayTable.applyChunks(buffers.arrayTable);
+    this.versionView = new Int32Array(this.indexTable.buffers[0]!);
+  }
+
   /**
    * Attach the reference-counting buffer (5th SAB) to this memory so it is
    * included in `exportBuffers()`. No-op if a buffer is already attached.
@@ -313,24 +435,37 @@ export class SharedMemory {
   /**
    * Export all shared buffers (including the lock) so they can be sent to a
    * worker via `postMessage` and reconstructed there with `fromBuffers()`.
+   *
+   * Tables are exported as lists for the chunked buffers. The Index Table is
+   * a single growable SharedArrayBuffer, exported as a one-element list. The
+   * optional shared budget counter is included so workers reserve atomically
+   * against the same three-table limit.
    */
   exportBuffers(): {
-    indexTable: SharedArrayBuffer;
-    dataTable: SharedArrayBuffer;
-    stringTable: SharedArrayBuffer;
-    arrayTable: SharedArrayBuffer;
+    indexTable: SharedArrayBuffer[];
+    dataTable: SharedArrayBuffer[];
+    stringTable: SharedArrayBuffer[];
+    arrayTable: SharedArrayBuffer[];
     layoutVersion: SharedArrayBuffer;
     lock: SharedArrayBuffer;
     refCount: SharedArrayBuffer | null;
+    maxByteLength: number;
+    indexTableMaxByteLength: number;
+    maxTotalBytes: number | null;
+    budget: SharedArrayBuffer | null;
   } {
     return {
-      indexTable: this.indexTable.buffer,
-      dataTable: this.dataTable.buffer,
-      stringTable: this.stringTable.buffer,
-      arrayTable: this.arrayTable.buffer,
+      indexTable: this.indexTable.buffers,
+      dataTable: this.dataTable.buffers,
+      stringTable: this.stringTable.buffers,
+      arrayTable: this.arrayTable.buffers,
       layoutVersion: this.layoutVersion.buffer as SharedArrayBuffer,
       lock: this.lock.buffer as SharedArrayBuffer,
       refCount: this.refCountBuffer,
+      maxByteLength: this.maxByteLength,
+      indexTableMaxByteLength: this.indexTableMaxByteLength,
+      maxTotalBytes: this.maxTotalBytes,
+      budget: this.budgetBuffer,
     };
   }
 
@@ -339,15 +474,29 @@ export class SharedMemory {
    * `exportBuffers()` (e.g. received from the main thread in a worker).
    */
   static fromBuffers(buffers: {
-    indexTable: SharedArrayBuffer;
-    dataTable: SharedArrayBuffer;
-    stringTable: SharedArrayBuffer;
-    arrayTable: SharedArrayBuffer;
+    indexTable: SharedArrayBuffer | SharedArrayBuffer[];
+    dataTable: SharedArrayBuffer | SharedArrayBuffer[];
+    stringTable: SharedArrayBuffer | SharedArrayBuffer[];
+    arrayTable: SharedArrayBuffer | SharedArrayBuffer[];
     layoutVersion: SharedArrayBuffer;
     lock: SharedArrayBuffer;
     refCount?: SharedArrayBuffer | null;
+    maxByteLength?: number;
+    indexTableMaxByteLength?: number;
+    maxTotalBytes?: number | null;
+    budget?: SharedArrayBuffer | null;
   }): SharedMemory {
+    const indexBuffer = Array.isArray(buffers.indexTable)
+      ? buffers.indexTable[0]
+      : buffers.indexTable;
     return new SharedMemory({
+      maxByteLength: buffers.maxByteLength ?? DEFAULT_MAX,
+      indexTableMaxByteLength:
+        buffers.indexTableMaxByteLength ??
+        indexBuffer?.maxByteLength ??
+        indexBuffer?.byteLength ??
+        DEFAULT_MAX,
+      maxTotalBytes: buffers.maxTotalBytes ?? undefined,
       buffers: {
         indexTable: buffers.indexTable,
         dataTable: buffers.dataTable,
@@ -355,6 +504,7 @@ export class SharedMemory {
         arrayTable: buffers.arrayTable,
         layoutVersion: buffers.layoutVersion,
         refCount: buffers.refCount ?? undefined,
+        budget: buffers.budget ?? undefined,
       },
       lock: new Mutex(buffers.lock),
     });
@@ -393,10 +543,7 @@ export class SharedMemory {
     const bytes = this.encoder.encode(value);
     const offset = this.stringTable.byteLength;
     this.stringTable.ensureCapacity(offset + bytes.byteLength);
-    const view = this.stringTable.getView();
-    for (let i = 0; i < bytes.byteLength; i++) {
-      view.setUint8(offset + i, bytes[i]!);
-    }
+    this.stringTable.writeBytes(offset, bytes);
     this.stringTable.advance(bytes.byteLength);
     const ref: StringRef = { offset, length: bytes.byteLength };
 
@@ -431,12 +578,7 @@ export class SharedMemory {
 
   /** Read a string from the StringTable by reference. */
   readString(ref: StringRef): string {
-    const view = this.stringTable.getView();
-    const bytes = new Uint8Array(
-      this.stringTable.buffer,
-      ref.offset,
-      ref.length,
-    );
+    const bytes = this.stringTable.readBytes(ref.offset, ref.length);
     return this.decoder.decode(bytes);
   }
 
@@ -458,11 +600,14 @@ export class SharedMemory {
     const cap = Math.max(capacity ?? 0, count, 1);
     const offset = this.arrayTable.byteLength;
     this.arrayTable.ensureCapacity(offset + ARRAY_HEADER + cap * SLOT_SIZE);
-    const view = this.arrayTable.getView();
     const objectId = this.nextObjectId++;
-    view.setInt32(offset, objectId, true);
+    this.arrayTable.setInt32(offset, objectId);
     for (let i = 0; i < count; i++) {
-      writeSlot(view, offset + ARRAY_HEADER + i * SLOT_SIZE, slots[i]!);
+      writeSlot(
+        this.arrayTable,
+        offset + ARRAY_HEADER + i * SLOT_SIZE,
+        slots[i]!,
+      );
     }
     this.arrayTable.advance(ARRAY_HEADER + cap * SLOT_SIZE);
     return { offset, count, capacity: cap };
@@ -470,10 +615,11 @@ export class SharedMemory {
 
   /** Read an array of value slots from the ArrayTable by reference. */
   readArray(ref: ArrayRef): ValueSlot[] {
-    const view = this.arrayTable.getView();
     const slots: ValueSlot[] = [];
     for (let i = 0; i < ref.count; i++) {
-      slots.push(readSlot(view, ref.offset + ARRAY_HEADER + i * SLOT_SIZE));
+      slots.push(
+        readSlot(this.arrayTable, ref.offset + ARRAY_HEADER + i * SLOT_SIZE),
+      );
     }
     return slots;
   }
@@ -481,7 +627,7 @@ export class SharedMemory {
   /** Update a single value slot of an array in the ArrayTable in place. */
   updateArraySlot(ref: ArrayRef, index: number, slot: ValueSlot): void {
     writeSlot(
-      this.arrayTable.getView(),
+      this.arrayTable,
       ref.offset + ARRAY_HEADER + index * SLOT_SIZE,
       slot,
     );
@@ -490,14 +636,14 @@ export class SharedMemory {
   /** Read a single value slot of an array from the ArrayTable. */
   readArraySlot(ref: ArrayRef, index: number): ValueSlot {
     return readSlot(
-      this.arrayTable.getView(),
+      this.arrayTable,
       ref.offset + ARRAY_HEADER + index * SLOT_SIZE,
     );
   }
 
   /** Read the stable objectId of an array block in the ArrayTable. */
   getArrayObjectId(offset: number): number {
-    return this.arrayTable.getView().getInt32(offset, true);
+    return this.arrayTable.getInt32(offset);
   }
 
   /**
@@ -510,14 +656,13 @@ export class SharedMemory {
     this.arrayTable.ensureCapacity(
       newOffset + ARRAY_HEADER + newCapacity * SLOT_SIZE,
     );
-    const view = this.arrayTable.getView();
     const objectId = this.getArrayObjectId(ref.offset);
-    view.setInt32(newOffset, objectId, true);
+    this.arrayTable.setInt32(newOffset, objectId);
     for (let i = 0; i < ref.count; i++) {
       writeSlot(
-        view,
+        this.arrayTable,
         newOffset + ARRAY_HEADER + i * SLOT_SIZE,
-        readSlot(view, ref.offset + ARRAY_HEADER + i * SLOT_SIZE),
+        readSlot(this.arrayTable, ref.offset + ARRAY_HEADER + i * SLOT_SIZE),
       );
     }
     this.arrayTable.advance(ARRAY_HEADER + newCapacity * SLOT_SIZE);
@@ -533,7 +678,7 @@ export class SharedMemory {
   appendArraySlot(ref: ArrayRef, slot: ValueSlot): ArrayRef {
     if (ref.count < ref.capacity) {
       writeSlot(
-        this.arrayTable.getView(),
+        this.arrayTable,
         ref.offset + ARRAY_HEADER + ref.count * SLOT_SIZE,
         slot,
       );
@@ -545,7 +690,7 @@ export class SharedMemory {
     }
     const moved = this.moveArray(ref, Math.max(ref.capacity * 2, 1));
     writeSlot(
-      this.arrayTable.getView(),
+      this.arrayTable,
       moved.offset + ARRAY_HEADER + moved.count * SLOT_SIZE,
       slot,
     );
@@ -564,19 +709,19 @@ export class SharedMemory {
   storeValueSlot(slot: ValueSlot): number {
     const offset = this.dataTable.byteLength;
     this.dataTable.ensureCapacity(offset + SLOT_SIZE);
-    writeSlot(this.dataTable.getView(), offset, slot);
+    writeSlot(this.dataTable, offset, slot);
     this.dataTable.advance(SLOT_SIZE);
     return offset;
   }
 
   /** Read a single value slot from the DataTable. */
   readValueSlot(offset: number): ValueSlot {
-    return readSlot(this.dataTable.getView(), offset);
+    return readSlot(this.dataTable, offset);
   }
 
   /** Update a single value slot in the DataTable. */
   updateValueSlot(offset: number, slot: ValueSlot): void {
-    writeSlot(this.dataTable.getView(), offset, slot);
+    writeSlot(this.dataTable, offset, slot);
   }
 
   /**
@@ -590,20 +735,19 @@ export class SharedMemory {
       OBJECT_HEADER + properties.length * (NAME_REF_SIZE + SLOT_SIZE);
     const offset = this.dataTable.byteLength;
     this.dataTable.ensureCapacity(offset + blockSize);
-    const view = this.dataTable.getView();
 
     const objectId = this.nextObjectId++;
-    view.setInt32(offset, TYPE_OBJECT, true);
-    view.setInt32(offset + 4, properties.length, true);
-    view.setInt32(offset + 8, objectId, true);
+    this.dataTable.setInt32(offset, TYPE_OBJECT);
+    this.dataTable.setInt32(offset + 4, properties.length);
+    this.dataTable.setInt32(offset + 8, objectId);
 
     let cursor = offset + OBJECT_HEADER;
     for (const [name, slot] of properties) {
       const nameRef = this.storeString(name);
-      view.setInt32(cursor, nameRef.offset, true);
-      view.setInt32(cursor + 4, nameRef.length, true);
+      this.dataTable.setInt32(cursor, nameRef.offset);
+      this.dataTable.setInt32(cursor + 4, nameRef.length);
       cursor += NAME_REF_SIZE;
-      writeSlot(view, cursor, slot);
+      writeSlot(this.dataTable, cursor, slot);
       cursor += SLOT_SIZE;
     }
     this.dataTable.advance(blockSize);
@@ -612,16 +756,15 @@ export class SharedMemory {
 
   /** Read an object's properties from the DataTable. */
   readObject(offset: number): Array<[string, ValueSlot]> {
-    const view = this.dataTable.getView();
-    const count = view.getInt32(offset + 4, true);
+    const count = this.dataTable.getInt32(offset + 4);
     const properties: Array<[string, ValueSlot]> = [];
     let cursor = offset + OBJECT_HEADER;
     for (let i = 0; i < count; i++) {
-      const nameOffset = view.getInt32(cursor, true);
-      const nameLength = view.getInt32(cursor + 4, true);
+      const nameOffset = this.dataTable.getInt32(cursor);
+      const nameLength = this.dataTable.getInt32(cursor + 4);
       const name = this.readString({ offset: nameOffset, length: nameLength });
       cursor += NAME_REF_SIZE;
-      const slot = readSlot(view, cursor);
+      const slot = readSlot(this.dataTable, cursor);
       cursor += SLOT_SIZE;
       properties.push([name, slot]);
     }
@@ -630,7 +773,7 @@ export class SharedMemory {
 
   /** Read the stable objectId of an object block in the DataTable. */
   getObjectId(offset: number): number {
-    return this.dataTable.getView().getInt32(offset + 8, true);
+    return this.dataTable.getInt32(offset + 8);
   }
 
   /**
@@ -647,14 +790,13 @@ export class SharedMemory {
   getObjectLayout(key: string): ObjectLayout | null {
     const offset = this.lookup(key);
     if (offset === null) return null;
-    const view = this.dataTable.getView();
-    if (view.getInt32(offset, true) !== TYPE_OBJECT) return null;
-    const count = view.getInt32(offset + 4, true);
+    if (this.dataTable.getInt32(offset) !== TYPE_OBJECT) return null;
+    const count = this.dataTable.getInt32(offset + 4);
     const properties = new Map<string, number>();
     let cursor = offset + OBJECT_HEADER;
     for (let i = 0; i < count; i++) {
-      const nameOffset = view.getInt32(cursor, true);
-      const nameLength = view.getInt32(cursor + 4, true);
+      const nameOffset = this.dataTable.getInt32(cursor);
+      const nameLength = this.dataTable.getInt32(cursor + 4);
       const name = this.readString({ offset: nameOffset, length: nameLength });
       cursor += NAME_REF_SIZE;
       properties.set(name, cursor);
@@ -669,13 +811,12 @@ export class SharedMemory {
     propertyIndex: number,
     slot: ValueSlot,
   ): void {
-    const view = this.dataTable.getView();
     const slotOffset =
       offset +
       OBJECT_HEADER +
       propertyIndex * (NAME_REF_SIZE + SLOT_SIZE) +
       NAME_REF_SIZE;
-    writeSlot(view, slotOffset, slot);
+    writeSlot(this.dataTable, slotOffset, slot);
   }
 
   // ---------------------------------------------------------------------------
@@ -691,11 +832,10 @@ export class SharedMemory {
 
   /** Read the DataTable offset for a known stable index, or null if absent. */
   lookupByIndex(index: number): number | null {
-    const view = this.indexTable.getView();
-    const count = view.getInt32(0, true);
+    const count = this.indexTable.getInt32(0);
     if (index >= count) return null;
     const entryOffset = INDEX_HEADER + index * INDEX_ENTRY_SIZE;
-    return view.getInt32(entryOffset + 8, true);
+    return this.indexTable.getInt32(entryOffset + 8);
   }
 
   /**
@@ -706,12 +846,11 @@ export class SharedMemory {
    * used to address the key's version cell.
    */
   lookupIndex(key: string): number | null {
-    const view = this.indexTable.getView();
-    const count = view.getInt32(0, true);
+    const count = this.indexTable.getInt32(0);
     for (let i = 0; i < count; i++) {
       const entryOffset = INDEX_HEADER + i * INDEX_ENTRY_SIZE;
-      const keyOffset = view.getInt32(entryOffset, true);
-      const keyLength = view.getInt32(entryOffset + 4, true);
+      const keyOffset = this.indexTable.getInt32(entryOffset);
+      const keyLength = this.indexTable.getInt32(entryOffset + 4);
       const storedKey = this.readString({
         offset: keyOffset,
         length: keyLength,
@@ -736,21 +875,21 @@ export class SharedMemory {
   /** Insert a key → dataOffset mapping into the Index Table. */
   insert(key: string, dataOffset: number): void {
     const keyRef = this.storeString(key);
-    const view = this.indexTable.getView();
-    const count = view.getInt32(0, true);
+    const count = this.indexTable.getInt32(0);
     const entryOffset = INDEX_HEADER + count * INDEX_ENTRY_SIZE;
     this.indexTable.ensureCapacity(entryOffset + INDEX_ENTRY_SIZE);
-    view.setInt32(entryOffset, keyRef.offset, true);
-    view.setInt32(entryOffset + 4, keyRef.length, true);
-    view.setInt32(entryOffset + 8, dataOffset, true);
+    this.indexTable.setInt32(entryOffset, keyRef.offset);
+    this.indexTable.setInt32(entryOffset + 4, keyRef.length);
+    this.indexTable.setInt32(entryOffset + 8, dataOffset);
     // The 4th field is the key's version cell, initialized to 0.
-    view.setInt32(entryOffset + INDEX_VERSION_OFFSET, 0, true);
-    view.setInt32(0, count + 1, true);
+    this.indexTable.setInt32(entryOffset + INDEX_VERSION_OFFSET, 0);
+    this.indexTable.setInt32(0, count + 1);
     this.indexTable.advance(INDEX_ENTRY_SIZE);
 
-    // Rebuild the version view if the buffer grew (grow preserves the SAB in
-    // place, but the Int32Array view must be recreated over the new buffer).
-    this.versionView = new Int32Array(this.indexTable.buffer);
+    // Rebuild the version view over the first chunk (the Index Table is small
+    // and stays within the first chunk for typical workloads; version cells
+    // beyond the first chunk are not addressable via the single Int32Array).
+    this.versionView = new Int32Array(this.indexTable.buffers[0]!);
   }
 
   // ---------------------------------------------------------------------------
@@ -786,7 +925,12 @@ export class SharedMemory {
    *
    * Must be called under the shared lock (or on a single thread).
    */
-  defragment(): void {
+  defragment(): {
+    indexTable: SharedArrayBuffer[];
+    dataTable: SharedArrayBuffer[];
+    stringTable: SharedArrayBuffer[];
+    arrayTable: SharedArrayBuffer[];
+  } {
     const stringRemap = new Map<number, number>();
     const arrayRemap = new Map<number, number>();
     const objectRemap = new Map<number, number>();
@@ -812,9 +956,10 @@ export class SharedMemory {
     const markArray = (offset: number, count: number) => {
       if (liveArrays.has(offset)) return;
       liveArrays.add(offset);
-      const view = this.arrayTable.getView();
       for (let i = 0; i < count; i++) {
-        markValueSlot(readSlot(view, offset + ARRAY_HEADER + i * SLOT_SIZE));
+        markValueSlot(
+          readSlot(this.arrayTable, offset + ARRAY_HEADER + i * SLOT_SIZE),
+        );
       }
     };
 
@@ -822,40 +967,37 @@ export class SharedMemory {
       if (liveObjects.has(offset)) return;
       liveObjects.add(offset);
       liveDataOffsets.add(offset);
-      const view = this.dataTable.getView();
-      const count = view.getInt32(offset + 4, true);
+      const count = this.dataTable.getInt32(offset + 4);
       let cursor = offset + OBJECT_HEADER;
       for (let i = 0; i < count; i++) {
-        const nameOffset = view.getInt32(cursor, true);
-        const nameLength = view.getInt32(cursor + 4, true);
+        const nameOffset = this.dataTable.getInt32(cursor);
+        const nameLength = this.dataTable.getInt32(cursor + 4);
         liveStrings.add(nameOffset);
         cursor += NAME_REF_SIZE;
-        markValueSlot(readSlot(view, cursor));
+        markValueSlot(readSlot(this.dataTable, cursor));
         cursor += SLOT_SIZE;
       }
     };
 
     const markValue = (dataOffset: number) => {
-      const view = this.dataTable.getView();
-      if (view.getInt32(dataOffset, true) === TYPE_OBJECT) {
+      if (this.dataTable.getInt32(dataOffset) === TYPE_OBJECT) {
         markObject(dataOffset);
       } else {
         liveDataOffsets.add(dataOffset);
-        markValueSlot(readSlot(view, dataOffset));
+        markValueSlot(readSlot(this.dataTable, dataOffset));
       }
     };
 
     // Phase 1: Mark live data by walking the Index Table.
-    const indexView = this.indexTable.getView();
-    const indexCount = indexView.getInt32(0, true);
+    const indexCount = this.indexTable.getInt32(0);
     const indexEntries: Array<{ keyRef: StringRef; dataOffset: number }> = [];
     for (let i = 0; i < indexCount; i++) {
       const entryOffset = INDEX_HEADER + i * INDEX_ENTRY_SIZE;
       const keyRef = {
-        offset: indexView.getInt32(entryOffset, true),
-        length: indexView.getInt32(entryOffset + 4, true),
+        offset: this.indexTable.getInt32(entryOffset),
+        length: this.indexTable.getInt32(entryOffset + 4),
       };
-      const dataOffset = indexView.getInt32(entryOffset + 8, true);
+      const dataOffset = this.indexTable.getInt32(entryOffset + 8);
       indexEntries.push({ keyRef, dataOffset });
       liveStrings.add(keyRef.offset);
       markValue(dataOffset);
@@ -864,14 +1006,13 @@ export class SharedMemory {
     // Phase 2: Compact the DataTable (objects and single value slots).
     const sortedData = [...liveDataOffsets].sort((a, b) => a - b);
     let newDataOffset = 0;
-    const dataView = this.dataTable.getView();
     for (const oldOffset of sortedData) {
       const size =
-        dataView.getInt32(oldOffset, true) === TYPE_OBJECT
+        this.dataTable.getInt32(oldOffset) === TYPE_OBJECT
           ? OBJECT_HEADER +
-            dataView.getInt32(oldOffset + 4, true) * (NAME_REF_SIZE + SLOT_SIZE)
+            this.dataTable.getInt32(oldOffset + 4) * (NAME_REF_SIZE + SLOT_SIZE)
           : SLOT_SIZE;
-      copyBytes(dataView, newDataOffset, oldOffset, size);
+      copyBytes(this.dataTable, newDataOffset, oldOffset, size);
       objectRemap.set(oldOffset, newDataOffset);
       newDataOffset += size;
     }
@@ -880,7 +1021,6 @@ export class SharedMemory {
     // Phase 3: Compact the ArrayTable.
     const sortedArrays = [...liveArrays].sort((a, b) => a - b);
     let newArrayOffset = 0;
-    const arrayView = this.arrayTable.getView();
     for (const oldOffset of sortedArrays) {
       // Determine the array's capacity by scanning forward to the next live
       // array or the end of the used region.
@@ -888,7 +1028,7 @@ export class SharedMemory {
       const end = next !== undefined ? next : this.arrayTable.byteLength;
       const capacity = (end - oldOffset - ARRAY_HEADER) / SLOT_SIZE;
       copyBytes(
-        arrayView,
+        this.arrayTable,
         newArrayOffset,
         oldOffset,
         ARRAY_HEADER + capacity * SLOT_SIZE,
@@ -901,12 +1041,11 @@ export class SharedMemory {
     // Phase 4: Compact the StringTable.
     const sortedStrings = [...liveStrings].sort((a, b) => a - b);
     let newStringOffset = 0;
-    const stringView = this.stringTable.getView();
     for (const oldOffset of sortedStrings) {
       const next = sortedStrings[sortedStrings.indexOf(oldOffset) + 1];
       const end = next !== undefined ? next : this.stringTable.byteLength;
       const length = end - oldOffset;
-      copyBytes(stringView, newStringOffset, oldOffset, length);
+      copyBytes(this.stringTable, newStringOffset, oldOffset, length);
       stringRemap.set(oldOffset, newStringOffset);
       newStringOffset += length;
     }
@@ -916,29 +1055,29 @@ export class SharedMemory {
     for (let i = 0; i < indexCount; i++) {
       const entryOffset = INDEX_HEADER + i * INDEX_ENTRY_SIZE;
       const { keyRef, dataOffset } = indexEntries[i]!;
-      indexView.setInt32(entryOffset, stringRemap.get(keyRef.offset)!, true);
-      indexView.setInt32(entryOffset + 4, keyRef.length, true);
-      indexView.setInt32(entryOffset + 8, objectRemap.get(dataOffset)!, true);
+      this.indexTable.setInt32(entryOffset, stringRemap.get(keyRef.offset)!);
+      this.indexTable.setInt32(entryOffset + 4, keyRef.length);
+      this.indexTable.setInt32(entryOffset + 8, objectRemap.get(dataOffset)!);
     }
 
     // Phase 6: Rewrite object property names and value slots, and array slots.
     for (const oldOffset of sortedData) {
-      if (dataView.getInt32(oldOffset, true) !== TYPE_OBJECT) continue;
+      if (this.dataTable.getInt32(oldOffset) !== TYPE_OBJECT) continue;
       const newOff = objectRemap.get(oldOffset)!;
-      const count = dataView.getInt32(newOff + 4, true);
+      const count = this.dataTable.getInt32(newOff + 4);
       let cursor = newOff + OBJECT_HEADER;
       for (let i = 0; i < count; i++) {
-        const nameOffset = dataView.getInt32(cursor, true);
-        dataView.setInt32(cursor, stringRemap.get(nameOffset)!, true);
+        const nameOffset = this.dataTable.getInt32(cursor);
+        this.dataTable.setInt32(cursor, stringRemap.get(nameOffset)!);
         cursor += NAME_REF_SIZE;
-        remapSlot(dataView, cursor, stringRemap, arrayRemap);
+        remapSlot(this.dataTable, cursor, stringRemap, arrayRemap);
         cursor += SLOT_SIZE;
       }
     }
     for (const oldOffset of sortedData) {
-      if (dataView.getInt32(oldOffset, true) === TYPE_OBJECT) continue;
+      if (this.dataTable.getInt32(oldOffset) === TYPE_OBJECT) continue;
       const newOff = objectRemap.get(oldOffset)!;
-      remapSlot(dataView, newOff, stringRemap, arrayRemap);
+      remapSlot(this.dataTable, newOff, stringRemap, arrayRemap);
     }
     for (const oldOffset of sortedArrays) {
       const newOff = arrayRemap.get(oldOffset)!;
@@ -947,7 +1086,7 @@ export class SharedMemory {
       const capacity = (end - oldOffset - ARRAY_HEADER) / SLOT_SIZE;
       for (let i = 0; i < capacity; i++) {
         remapSlot(
-          arrayView,
+          this.arrayTable,
           newOff + ARRAY_HEADER + i * SLOT_SIZE,
           stringRemap,
           arrayRemap,
@@ -957,34 +1096,43 @@ export class SharedMemory {
 
     // Phase 7: Invalidate all per-worker caches.
     this.bumpLayoutVersion();
+
+    // Phase 8: Reclaim memory from inactive chunks (beyond the compacted
+    // region). The Index Table is a single growable SAB and is never replaced.
+    return {
+      indexTable: this.indexTable.releaseInactiveChunks(),
+      dataTable: this.dataTable.releaseInactiveChunks(),
+      stringTable: this.stringTable.releaseInactiveChunks(),
+      arrayTable: this.arrayTable.releaseInactiveChunks(),
+    };
   }
 }
 
-function writeSlot(view: DataView, offset: number, slot: ValueSlot): void {
-  view.setInt32(offset, slot.type, true);
-  view.setInt32(offset + 4, slot.a, true);
-  view.setInt32(offset + 8, slot.b, true);
-  view.setInt32(offset + 12, slot.c, true);
+function writeSlot(buf: GrowableBuffer, offset: number, slot: ValueSlot): void {
+  buf.setInt32(offset, slot.type);
+  buf.setInt32(offset + 4, slot.a);
+  buf.setInt32(offset + 8, slot.b);
+  buf.setInt32(offset + 12, slot.c);
 }
 
-function readSlot(view: DataView, offset: number): ValueSlot {
+function readSlot(buf: GrowableBuffer, offset: number): ValueSlot {
   return {
-    type: view.getInt32(offset, true),
-    a: view.getInt32(offset + 4, true),
-    b: view.getInt32(offset + 8, true),
-    c: view.getInt32(offset + 12, true),
+    type: buf.getInt32(offset),
+    a: buf.getInt32(offset + 4),
+    b: buf.getInt32(offset + 8),
+    c: buf.getInt32(offset + 12),
   };
 }
 
 /** Copy `len` bytes from `src` to `dst` in the same buffer (dst <= src). */
 function copyBytes(
-  view: DataView,
+  buf: GrowableBuffer,
   dst: number,
   src: number,
   len: number,
 ): void {
   for (let i = 0; i < len; i++) {
-    view.setUint8(dst + i, view.getUint8(src + i));
+    buf.setUint8(dst + i, buf.getUint8(src + i));
   }
 }
 
@@ -994,23 +1142,15 @@ function copyBytes(
  * via `arrayRemap`.
  */
 function remapSlot(
-  view: DataView,
+  buf: GrowableBuffer,
   offset: number,
   stringRemap: Map<number, number>,
   arrayRemap: Map<number, number>,
 ): void {
-  const type = view.getInt32(offset, true);
+  const type = buf.getInt32(offset);
   if (type === TYPE_STRING_REF || type === TYPE_BIGINT_STR) {
-    view.setInt32(
-      offset + 4,
-      stringRemap.get(view.getInt32(offset + 4, true))!,
-      true,
-    );
+    buf.setInt32(offset + 4, stringRemap.get(buf.getInt32(offset + 4))!);
   } else if (type === TYPE_ARRAY_REF) {
-    view.setInt32(
-      offset + 4,
-      arrayRemap.get(view.getInt32(offset + 4, true))!,
-      true,
-    );
+    buf.setInt32(offset + 4, arrayRemap.get(buf.getInt32(offset + 4))!);
   }
 }