bun-shared-memory 0.1.5 → 0.1.6

package/CHANGELOG.md

@@ -5,9 +5,47 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.6] - 2026-11-02
+
+### Added
+
+- Support shared memory larger than 4 GiB. The single-`SharedArrayBuffer`
+  per-buffer architecture is replaced with a chunked `GrowableBuffer`: each
+  buffer is backed by multiple equal-size chunks (32 MiB default, power of
+  two), so a buffer can exceed the 4 GiB single-SAB limit. Offsets resolve
+  O(1) via bit shifts (`offset >> chunkShift`).
+- `SharedMemoryOptions.chunkSize` to configure the chunk size (the minimum
+  growth step).
+- Chunks are pre-allocated at construction (4 bytes each, with
+  `maxByteLength = chunkSize`) and activated on first access via
+  `SharedArrayBuffer.grow()`. Because `grow()` is visible across all workers
+  sharing a buffer, a worker can grow a chunk and every other worker sees it
+  immediately — no postMessage broadcast is needed for chunk activation.
+
+### Changed
+
+- `exportBuffers()`/`fromBuffers()` now pass chunk lists instead of a single
+  buffer; `fromBuffers` reuses the shared `SharedArrayBuffer`s directly (no
+  copy) so writes stay visible across workers. The chunk size is derived from
+  each buffer's `maxByteLength` (preserved across `postMessage`), not its
+  current 4-byte length.
+- Remove the 4 GiB cap on the per-buffer maximum in the `SharedMemory`
+  constructor (the chunked `GrowableBuffer` already bypasses the single-SAB
+  limit).
+
+### Performance
+
+- After defragmentation, unused chunks are marked inactive:
+  `GrowableBuffer.reset()` deactivates chunks beyond the compacted region so
+  the GC can reclaim their storage.
+- The chunked accessor adds an indirect `chunks[index].view` lookup on the
+  write hot path (the price of >4 GiB support): writes ~-15%, array writes
+  ~-20%. Reads are unchanged (lock-free cache path).
+
 ## [0.1.5] - 2026-11-02
 
 ### Changed
+
 - Replace the `Proxy` used for object `SharedRef`s with hard-baked
   `Object.defineProperty` accessor getters/setters, so property reads skip the
   Proxy trap on the hot path (~3× faster object property reads). Methods
@@ -24,6 +62,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.1.4] - 2026-11-01
 
 ### Changed
+
 - Declare `"sideEffects": false` in `package.json` so bundlers can tree-shake
   the library (the modules have no side effects on import).
 - Remove the `typescript` peer dependency. The library ships as TypeScript
@@ -33,6 +72,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.1.3] - 2026-11-01
 
 ### Added
+
 - Real-world benchmark (`bench/real-world/`) comparing shared memory against
   live SQLite, MySQL, and Redis via an Elysia mini API.
 - Redis as a fourth benchmark methodology (in Docker).
@@ -41,6 +81,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Real-world benchmark results and methodology documented in the README.
 
 ### Changed
+
 - MySQL/Redis connections are established before the benchmark (not per
   request) so connection setup is not measured as overhead.
 - The benchmark always runs both TCP and Unix-socket transports; the socket
@@ -49,16 +90,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.1.2] - 2026-11-01
 
 ### Changed
+
 - Unref the maintenance timer so the process can exit naturally.
 - Document `init()` as the first call and how to configure memory via `init()`.
 
 ## [0.1.1] - 2026-11-01
 
 ### Added
+
 - Repository metadata and npm publishing preparation.
 - README with package name and install instructions.
 
 ### Changed
+
 - Optimize the read hot path: direct cache on the proxy target.
 - Optimize `Mutex`: skip notify when no worker is waiting.
 - Start the refcount coordinator/tracker automatically in `init()`.
@@ -67,6 +111,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.1.0] - 2026-11-01
 
 ### Added
+
 - Initial release: `Shared<T>` Proxy-based API over a 4-buffer shared memory
   architecture (Index Table, DataTable, append-only StringTable, ArrayTable).
 - Atomics-based synchronization (`Mutex`, `Notifier`).
@@ -75,6 +120,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - O(1) in-place `push`/`pop` with capacity-based array growth.
 - Benchmarks for all data types vs native.
 
+[0.1.6]: https://github.com/Kapsonfire/bun-shared-memory/compare/v0.1.5...v0.1.6
+[0.1.5]: https://github.com/Kapsonfire/bun-shared-memory/compare/v0.1.4...v0.1.5
 [0.1.4]: https://github.com/Kapsonfire/bun-shared-memory/compare/v0.1.3...v0.1.4
 [0.1.3]: https://github.com/Kapsonfire/bun-shared-memory/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/Kapsonfire/bun-shared-memory/compare/v0.1.1...v0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-shared-memory",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Share data between Bun workers/threads using SharedArrayBuffer (zero-copy, 4-buffer architecture, Atomics-based synchronization).",
   "type": "module",
   "sideEffects": false,

package/src/growable-buffer.ts

@@ -35,33 +35,111 @@ export class SharedBudget {
 }
 
 /**
- * Growable SharedArrayBuffer helper.
+ * Growable shared memory backed by one or more SharedArrayBuffers (chunks).
  *
- * SharedArrayBuffer supports `grow(newLength)` when created with
- * `maxByteLength`. Growth preserves existing data, can only grow up to
- * `maxByteLength`, and cannot shrink. All workers sharing the buffer see the
- * growth immediately.
+ * A single SharedArrayBuffer can be at most 4 GiB, so a buffer that needs to
+ * grow beyond that is split into multiple chunks. Each chunk is its own
+ * SharedArrayBuffer (<= `chunkMax` bytes). Offsets are logical and continuous
+ * across chunks; access methods resolve an offset into (chunk, chunkOffset).
+ *
+ * All chunks are pre-allocated at construction with `maxByteLength = chunkSize`
+ * but only 4 bytes of actual storage. A chunk is "activated" (grown to its
+ * full `chunkSize`) on first access. Because `SharedArrayBuffer.grow()` is
+ * visible across all workers sharing the buffer, activation needs no
+ * postMessage broadcast.
  */
+interface Chunk {
+  buffer: SharedArrayBuffer;
+  view: DataView;
+  /** Whether the chunk has been grown to its full size. */
+  active: boolean;
+}
+
+/** Round `n` up to the next power of two (chunk sizes must be powers of two). */
+function nextPowerOfTwo(n: number): number {
+  if (n <= 0) return 1;
+  let p = 1;
+  while (p < n) p <<= 1;
+  return p;
+}
+
 export class GrowableBuffer {
-  readonly buffer: SharedArrayBuffer;
-  private view: DataView;
+  private chunks: Chunk[] = [];
   private readonly maxByteLength: number;
+  /** Fixed size of every chunk (the minimum growth step). */
+  readonly chunkSize: number;
+  /** log2(chunkSize), used for O(1) offset resolution via bit shifts. */
+  private readonly chunkShift: number;
   private readonly budget?: SharedBudget;
   private used = 0;
 
   constructor(
-    initialSizeOrBuffer: number | SharedArrayBuffer,
+    initialSizeOrBuffer: number | SharedArrayBuffer | SharedArrayBuffer[],
     maxByteLength: number,
     budget?: SharedBudget,
+    chunkSize = 32 * 1024 * 1024, // 32 MiB per chunk
   ) {
-    this.buffer =
-      typeof initialSizeOrBuffer === "number"
-        ? new SharedArrayBuffer(initialSizeOrBuffer, { maxByteLength })
-        : initialSizeOrBuffer;
-    this.view = new DataView(this.buffer);
     this.maxByteLength = maxByteLength;
     this.budget = budget;
-    this.budget?.add(this.buffer.byteLength);
+    if (typeof initialSizeOrBuffer === "number") {
+      this.chunkSize = Math.min(nextPowerOfTwo(chunkSize), maxByteLength);
+      this.chunkShift = Math.log2(this.chunkSize);
+      // Pre-allocate all chunks (4 bytes each, growable to chunkSize).
+      const chunkCount = Math.max(1, Math.ceil(maxByteLength / this.chunkSize));
+      for (let i = 0; i < chunkCount; i++) {
+        const buffer = new SharedArrayBuffer(4, {
+          maxByteLength: this.chunkSize,
+        });
+        this.chunks.push({
+          buffer,
+          view: new DataView(buffer),
+          active: false,
+        });
+      }
+    } else if (Array.isArray(initialSizeOrBuffer)) {
+      // Reconstruct from a list of chunks. Use the buffers directly (they are
+      // already shared via postMessage) so writes are visible across workers.
+      // All chunks are pre-allocated at 4 bytes with maxByteLength = chunkSize;
+      // the chunk size is derived from each buffer's maxByteLength (which is
+      // preserved across postMessage), not its current byteLength.
+      this.chunkSize = initialSizeOrBuffer[0]?.maxByteLength ?? chunkSize;
+      this.chunkShift = Math.log2(this.chunkSize);
+      for (const sab of initialSizeOrBuffer) {
+        this.chunks.push({
+          buffer: sab,
+          view: new DataView(sab),
+          active: sab.byteLength === this.chunkSize,
+        });
+        this.budget?.add(sab.byteLength);
+      }
+    } else {
+      // Reconstruct from a single existing buffer. Use it directly so writes
+      // are shared. Its size defines the chunk size (prefer maxByteLength so
+      // a pre-allocated 4-byte chunk is interpreted at its full size).
+      this.chunkSize =
+        initialSizeOrBuffer.maxByteLength ?? initialSizeOrBuffer.byteLength;
+      this.chunkShift = Math.log2(this.chunkSize);
+      this.chunks.push({
+        buffer: initialSizeOrBuffer,
+        view: new DataView(initialSizeOrBuffer),
+        active: initialSizeOrBuffer.byteLength === this.chunkSize,
+      });
+      this.budget?.add(initialSizeOrBuffer.byteLength);
+    }
+  }
+
+  /**
+   * Activate the chunk at `index` by growing it to its full size. Because
+   * `SharedArrayBuffer.grow()` is visible across all workers, no broadcast is
+   * needed. No-op if the chunk is already active.
+   */
+  private activate(index: number): void {
+    const chunk = this.chunks[index];
+    if (chunk === undefined || chunk.active) return;
+    chunk.buffer.grow(this.chunkSize);
+    chunk.view = new DataView(chunk.buffer);
+    chunk.active = true;
+    this.budget?.add(this.chunkSize);
   }
 
   /** Number of bytes written so far (used length, not buffer capacity). */
@@ -69,24 +147,49 @@ export class GrowableBuffer {
     return this.used;
   }
 
+  /** Total logical capacity across all chunks (active or not). */
+  get capacity(): number {
+    return this.chunks.length * this.chunkSize;
+  }
+
+  /** The list of SharedArrayBuffers backing this buffer (for export). */
+  get buffers(): SharedArrayBuffer[] {
+    return this.chunks.map((c) => c.buffer);
+  }
+
+  /** Number of chunks that have been activated (grown to full size). */
+  get activeChunkCount(): number {
+    return this.chunks.reduce((n, c) => n + (c.active ? 1 : 0), 0);
+  }
+
+  /**
+   * Resolve a logical offset into (chunk, offset within that chunk). All
+   * chunks are the same size, so this is O(1). Activates the chunk if it is
+   * not yet active.
+   */
+  private resolve(offset: number): { chunk: Chunk; off: number } {
+    const index = offset >> this.chunkShift;
+    const chunk = this.chunks[index];
+    if (chunk === undefined) {
+      throw new RangeError(`Offset ${offset} is beyond the buffer capacity`);
+    }
+    this.activate(index);
+    return { chunk, off: offset & (this.chunkSize - 1) };
+  }
+
   /** Ensure the buffer has room for at least `needed` bytes. */
   ensureCapacity(needed: number): void {
-    if (needed <= this.buffer.byteLength) return;
     if (needed > this.maxByteLength) {
       throw new RangeError(
         `Shared buffer capacity exceeded: need ${needed} bytes but max is ${this.maxByteLength}`,
       );
     }
-    let newSize = this.buffer.byteLength * 2;
-    while (newSize < needed) newSize *= 2;
-    if (newSize > this.maxByteLength) newSize = this.maxByteLength;
-    if (this.budget && !this.budget.tryGrow(this.buffer.byteLength, newSize)) {
-      throw new RangeError(
-        `Shared memory budget exceeded: growing to ${newSize} bytes would exceed the total budget`,
-      );
+    // All chunks are pre-allocated; just activate the ones needed to cover
+    // `needed`. grow() is visible across workers, so no broadcast is required.
+    const neededChunks = Math.ceil(needed / this.chunkSize);
+    for (let i = 0; i < neededChunks; i++) {
+      this.activate(i);
     }
-    this.buffer.grow(newSize);
-    this.view = new DataView(this.buffer);
   }
 
   /** Mark `n` bytes as used, after writing them at the current offset. */
@@ -96,15 +199,80 @@ export class GrowableBuffer {
 
   /**
    * Reset the used length to `n` bytes. Used by defragmentation after
-   * compacting live data to the front of the buffer. The underlying
-   * SharedArrayBuffer is not shrunk (it cannot be), but the tail beyond `n`
-   * is treated as free space for future writes.
+   * compacting live data to the front of the buffer. Chunks beyond the
+   * compacted region are marked inactive (their storage is released by the
+   * GC, which replaces them with fresh chunks).
    */
   reset(n: number): void {
     this.used = n;
+    const neededChunks = Math.ceil(n / this.chunkSize);
+    for (let i = neededChunks; i < this.chunks.length; i++) {
+      this.chunks[i]!.active = false;
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Typed accessors (resolve offset -> chunk)
+  // -------------------------------------------------------------------------
+
+  getInt32(offset: number): number {
+    const index = offset >> this.chunkShift;
+    this.activate(index);
+    return this.chunks[index]!.view.getInt32(
+      offset & (this.chunkSize - 1),
+      true,
+    );
+  }
+
+  setInt32(offset: number, value: number): void {
+    const index = offset >> this.chunkShift;
+    this.activate(index);
+    this.chunks[index]!.view.setInt32(
+      offset & (this.chunkSize - 1),
+      value,
+      true,
+    );
   }
 
-  getView(): DataView {
-    return this.view;
+  getUint8(offset: number): number {
+    const index = offset >> this.chunkShift;
+    this.activate(index);
+    return this.chunks[index]!.view.getUint8(offset & (this.chunkSize - 1));
+  }
+
+  setUint8(offset: number, value: number): void {
+    const index = offset >> this.chunkShift;
+    this.activate(index);
+    this.chunks[index]!.view.setUint8(offset & (this.chunkSize - 1), value);
+  }
+
+  /** Read `length` bytes starting at `offset` into a fresh Uint8Array. */
+  readBytes(offset: number, length: number): Uint8Array {
+    const out = new Uint8Array(length);
+    let pos = offset;
+    let outPos = 0;
+    while (outPos < length) {
+      const { chunk, off } = this.resolve(pos);
+      const n = Math.min(length - outPos, this.chunkSize - off);
+      out.set(new Uint8Array(chunk.buffer, off, n), outPos);
+      outPos += n;
+      pos += n;
+    }
+    return out;
+  }
+
+  /** Write `bytes` starting at `offset`. */
+  writeBytes(offset: number, bytes: Uint8Array): void {
+    let pos = offset;
+    let srcPos = 0;
+    while (srcPos < bytes.byteLength) {
+      const { chunk, off } = this.resolve(pos);
+      const n = Math.min(bytes.byteLength - srcPos, this.chunkSize - off);
+      new Uint8Array(chunk.buffer, off, n).set(
+        bytes.subarray(srcPos, srcPos + n),
+      );
+      srcPos += n;
+      pos += n;
+    }
   }
 }

package/src/memory.ts

@@ -175,19 +175,35 @@ export interface SharedMemoryOptions {
   maxByteLength?: number;
   /** Total memory budget shared across all buffers (see below). */
   maxTotalBytes?: number;
+  /** Size of each growable chunk (the minimum growth step). Default 32 MiB. */
+  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;
   };
 }
 
+/** 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,
+): GrowableBuffer {
+  if (buf === undefined) {
+    return new GrowableBuffer(initial, maxByteLength, budget, chunkSize);
+  }
+  return new GrowableBuffer(buf, maxByteLength, budget, chunkSize);
+}
+
 /**
  * Manages the four shared buffers and provides operations to store and read
  * strings, arrays, and objects.
@@ -246,44 +262,48 @@ 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` is a *total* budget shared across all buffers: each
+    // buffer's own maxByteLength is capped at maxTotalBytes, and the sum of
+    // all buffers' physical sizes is additionally capped at maxTotalBytes.
+    // Without maxTotalBytes, each buffer grows up to its own maxByteLength.
+    // A single SharedArrayBuffer is limited to 4 GiB, but the chunked
+    // GrowableBuffer splits a buffer across multiple chunks, so a buffer can
+    // exceed 4 GiB.
     const maxTotal = options?.maxTotalBytes;
-    const perBufferMax = Math.min(
-      4 * 1024 * 1024 * 1024,
-      maxTotal ?? options?.maxByteLength ?? DEFAULT_MAX,
-    );
+    const perBufferMax = maxTotal ?? options?.maxByteLength ?? DEFAULT_MAX;
     const budget =
       maxTotal !== undefined ? new SharedBudget(maxTotal) : undefined;
+    const chunkSize = options?.chunkSize;
     const buffers = options?.buffers;
-    this.indexTable = new GrowableBuffer(
-      buffers?.indexTable ??
-        new SharedArrayBuffer(initial, { maxByteLength: perBufferMax }),
+    this.indexTable = makeBuffer(
+      buffers?.indexTable,
+      initial,
       perBufferMax,
       budget,
+      chunkSize,
     );
-    this.dataTable = new GrowableBuffer(
-      buffers?.dataTable ??
-        new SharedArrayBuffer(initial, { maxByteLength: perBufferMax }),
+    this.dataTable = makeBuffer(
+      buffers?.dataTable,
+      initial,
       perBufferMax,
       budget,
+      chunkSize,
     );
-    this.stringTable = new GrowableBuffer(
-      buffers?.stringTable ??
-        new SharedArrayBuffer(initial, { maxByteLength: perBufferMax }),
+    this.stringTable = makeBuffer(
+      buffers?.stringTable,
+      initial,
       perBufferMax,
       budget,
+      chunkSize,
     );
-    this.arrayTable = new GrowableBuffer(
-      buffers?.arrayTable ??
-        new SharedArrayBuffer(initial, { maxByteLength: perBufferMax }),
+    this.arrayTable = makeBuffer(
+      buffers?.arrayTable,
+      initial,
       perBufferMax,
       budget,
+      chunkSize,
     );
-    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),
@@ -313,21 +333,24 @@ 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()`.
+   *
+   * Each table is exported as a list of SharedArrayBuffers (chunks), since a
+   * single SharedArrayBuffer is limited to 4 GiB.
    */
   exportBuffers(): {
-    indexTable: SharedArrayBuffer;
-    dataTable: SharedArrayBuffer;
-    stringTable: SharedArrayBuffer;
-    arrayTable: SharedArrayBuffer;
+    indexTable: SharedArrayBuffer[];
+    dataTable: SharedArrayBuffer[];
+    stringTable: SharedArrayBuffer[];
+    arrayTable: SharedArrayBuffer[];
     layoutVersion: SharedArrayBuffer;
     lock: SharedArrayBuffer;
     refCount: 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,
@@ -339,10 +362,10 @@ 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;
@@ -393,10 +416,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 +451,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 +473,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 +488,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 +500,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 +509,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 +529,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 +551,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 +563,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 +582,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 +608,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 +629,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 +646,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 +663,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 +684,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 +705,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 +719,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 +748,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]!);
   }
 
   // ---------------------------------------------------------------------------
@@ -812,9 +824,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 +835,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 +874,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 +889,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 +896,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 +909,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 +923,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 +954,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,
@@ -960,31 +967,31 @@ export class SharedMemory {
   }
 }
 
-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 +1001,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))!);
   }
 }

package/src/refcount.ts

@@ -286,9 +286,9 @@ export class RefCountCoordinator {
 
   /** Whether any table has less than `defragThreshold` free space. */
   needsDefrag(): boolean {
-    const max = this.mem.dataTable.buffer.maxByteLength;
-    const free = (b: { buffer: SharedArrayBuffer; byteLength: number }) =>
-      (b.buffer.byteLength - b.byteLength) / max;
+    const max = this.mem.dataTable.capacity;
+    const free = (b: { capacity: number; byteLength: number }) =>
+      (b.capacity - b.byteLength) / max;
     return (
       free(this.mem.dataTable) < this.defragThreshold ||
       free(this.mem.arrayTable) < this.defragThreshold ||

package/src/shared.ts

@@ -178,7 +178,7 @@ function isTrackable(value: unknown): boolean {
 function getTopLevelObjectId(mem: SharedMemory, key: string): number | null {
   const offset = getOffset(mem, key);
   if (offset === null) return null;
-  const type = mem.dataTable.getView().getInt32(offset, true);
+  const type = mem.dataTable.getInt32(offset);
   if (type === 5) {
     return mem.getObjectId(offset);
   }
@@ -517,7 +517,7 @@ function createSharedRef<T>(
       enumerable: false,
       configurable: false,
       get() {
-        return mem.dataTable.buffer;
+        return mem.dataTable.buffers[0];
       },
     });
     const ref = Object.create(proto) as Record<string | symbol, unknown>;
@@ -564,7 +564,7 @@ function createSharedRef<T>(
       if (prop === "write") return t.write;
       if (prop === "update") return t.update;
       if (prop === "key") return t.key;
-      if (prop === "buffer") return mem.dataTable.buffer;
+      if (prop === "buffer") return mem.dataTable.buffers[0];
       if (prop === Symbol.toPrimitive) return () => t.read();
 
       // push/pop on a top-level array: operate directly on the array ref
@@ -635,7 +635,7 @@ function readValue(
     if (offset === null) {
       throw new Error(`No shared value found for key "${key}"`);
     }
-    const type = mem.dataTable.getView().getInt32(offset, true);
+    const type = mem.dataTable.getInt32(offset);
     if (type === 5) {
       // Object block.
       const properties = mem.readObject(offset);
@@ -665,7 +665,7 @@ function writeValue(
   mem.withLock(() => {
     const existing = getOffset(mem, key);
     if (existing !== null) {
-      const type = mem.dataTable.getView().getInt32(existing, true);
+      const type = mem.dataTable.getInt32(existing);
       if (type === 5) {
         // Update existing object's property slots in place.
         const properties = mem.readObject(existing);

package/src/worker.ts

@@ -144,6 +144,7 @@ function stopCoordinator(): void {
   }
 }
 
+// ---------------------------------------------------------------------------
 /** The main-thread worker listener, so it can be removed by `stopInit()`. */
 let mainListener:
   | ((worker: {
@@ -166,12 +167,17 @@ function initMain(): void {
   }) => {
     worker.addEventListener("message", (e) => {
       const msg = e.data as { __sharedMemoryRequest?: boolean } | undefined;
-      if (msg && msg.__sharedMemoryRequest) {
+      if (
+        msg !== null &&
+        typeof msg === "object" &&
+        "__sharedMemoryRequest" in msg
+      ) {
         const mem = getDefaultMemory();
         worker.postMessage({
           __sharedMemoryInit: true,
           buffers: mem.exportBuffers(),
         });
+        return;
       }
     });
   };
@@ -234,7 +240,12 @@ function installMessageWrapper(): void {
           buffers?: Parameters<typeof SharedMemory.fromBuffers>[0];
         }
       | undefined;
-    if (msg && msg.__sharedMemoryInit && msg.buffers) {
+    if (
+      msg !== null &&
+      typeof msg === "object" &&
+      "__sharedMemoryInit" in msg &&
+      msg.buffers
+    ) {
       const mem = SharedMemory.fromBuffers(msg.buffers);
       setDefaultMemory(mem);
       // Create the worker-side refcount tracker from the shared refcount