bun-shared-memory 0.1.8 → 0.2.1

package/src/shared.ts

@@ -2,6 +2,9 @@ import {
   SharedMemory,
   TYPE_ARRAY_REF,
   TYPE_BIGINT_STR,
+  TYPE_INLINE_STRING,
+  TYPE_STRING_REF,
+  TYPE_STRING_VALUE_REF,
   arrayRefSlot,
   bigintSlot,
   bigintStrSlot,
@@ -9,6 +12,7 @@ import {
   decodeSlot,
   numberSlot,
   stringRefSlot,
+  stringValueRefSlot,
   type ArrayRef,
   type ObjectLayout,
   type StringRef,
@@ -32,6 +36,26 @@ const MUTATING_METHODS = new Set([
 
 type Primitive = number | string | boolean | bigint;
 
+/**
+ * Run a write operation. Writes are lock-free by default: they increment the
+ * in-flight write counter, and only fall back to the shared mutex if a
+ * defragmentation pass is running (rare). This keeps the hot write path free
+ * of the mutex's re-entrancy tracking while still preventing a write from
+ * racing with a defragmentation pass.
+ */
+function writeLock<T>(mem: SharedMemory, fn: () => T): T {
+  mem.beginWrite();
+  if (mem.isDefragmenting()) {
+    mem.endWrite();
+    return mem.withLock(fn);
+  }
+  try {
+    return fn();
+  } finally {
+    mem.endWrite();
+  }
+}
+
 /** Inclusive bounds of a signed 64-bit integer (stored as a fast int64 slot). */
 const MIN_INT64 = -(2n ** 63n);
 const MAX_INT64 = 2n ** 63n - 1n;
@@ -41,6 +65,7 @@ function encodeValue(
   mem: SharedMemory,
   value: unknown,
   arrayCapacity?: number,
+  oldSlot?: ValueSlot,
 ): ValueSlot {
   switch (typeof value) {
     case "number":
@@ -55,7 +80,12 @@ function encodeValue(
       }
       return bigintStrSlot(mem.storeString(value.toString()));
     case "string":
-      return stringRefSlot(mem.storeString(value));
+      // Reuse the existing string block in place when the new string fits.
+      const oldRef =
+        oldSlot?.type === TYPE_STRING_VALUE_REF
+          ? { offset: oldSlot.a, length: oldSlot.b }
+          : undefined;
+      return stringValueRefSlot(mem.storeStringValue(value, oldRef));
     default:
       if (Array.isArray(value)) {
         for (const v of value) {
@@ -77,8 +107,12 @@ function encodeValue(
 /** Decode a ValueSlot into a JS value, reading strings/arrays from tables. */
 function decodeValue(mem: SharedMemory, slot: ValueSlot): unknown {
   switch (slot.type) {
-    case 3: // string-ref
+    case TYPE_STRING_REF: // property-name/string-table ref
       return mem.readString({ offset: slot.a, length: slot.b });
+    case TYPE_STRING_VALUE_REF: // string value in the ArrayTable
+      return mem.readStringValue({ offset: slot.a, length: slot.b });
+    case TYPE_INLINE_STRING: // short string stored inline in the slot
+      return mem.readInlineString(slot.a, slot.b, slot.c);
     case TYPE_BIGINT_STR: // bigint stored as decimal string
       return BigInt(mem.readString({ offset: slot.a, length: slot.b }));
     case 4: // array-ref
@@ -90,6 +124,18 @@ function decodeValue(mem: SharedMemory, slot: ValueSlot): unknown {
   }
 }
 
+/**
+ * Free the blocks referenced by a value slot (an array block or a string),
+ * so they can be reused by the slab allocator. Called before a slot is
+ * overwritten with a new value. No-op for primitive slots.
+ *
+ * No-op: string-value/array/object blocks are no longer freed on the hot
+ * path (they are reclaimed by defragmentation instead).
+ */
+function freeSlotRefs(_mem: SharedMemory, _slot: ValueSlot): void {
+  // Intentionally a no-op; dead blocks are reclaimed by defrag.
+}
+
 /**
  * A reference to a value stored in shared memory.
  *
@@ -137,6 +183,18 @@ const readCache = new Map<
  */
 const indexCache = new Map<string, number>();
 
+/**
+ * Per-worker cache of a key's current DataTable offset, valid only for the
+ * layout version it was resolved under. The offset changes on
+ * GC/defragmentation, so it is re-validated against the global layout version
+ * on each access (a single Atomics.load). This avoids the Index-Table read on
+ * every write, which is the dominant cost of the write hot path.
+ */
+const offsetCache = new Map<
+  string,
+  { offset: number; layoutVersion: number }
+>();
+
 /** Resolve a key's stable index, caching it after the first lookup. */
 function getIndex(mem: SharedMemory, key: string): number {
   const cached = indexCache.get(key);
@@ -166,6 +224,65 @@ function getOffset(mem: SharedMemory, key: string): number | null {
   return mem.lookupByIndex(index);
 }
 
+/**
+ * The per-key cache fields on a SharedRef proxy target that the write hot
+ * paths use to skip Map lookups and DataTable reads. `__offset`/`__type` are
+ * valid only while `__layoutVersion` matches the global layout version;
+ * `__arrayRef` additionally requires `__arrayRefLayoutVersion` to match (it is
+ * bumped on defragmentation and on array growth via `moveArray`).
+ */
+interface WriteTarget {
+  __offset?: number;
+  __layoutVersion: number;
+  __type?: number;
+  __arrayRef?: { offset: number; count: number; capacity: number } | undefined;
+  __arrayRefLayoutVersion: number;
+  __index?: number | undefined;
+}
+
+/**
+ * Resolve a key's current DataTable offset, caching it across writes. The
+ * cached offset is only reused when the global layout version is unchanged
+ * (i.e. no defragmentation has moved the data since it was cached); otherwise
+ * it is re-resolved from the Index Table.
+ */
+function getCachedOffset(
+  mem: SharedMemory,
+  key: string,
+  target?: WriteTarget,
+): number | null {
+  if (target !== undefined && target.__offset !== undefined) {
+    if (target.__layoutVersion === mem.getLayoutVersion()) {
+      return target.__offset;
+    }
+    target.__offset = undefined;
+    target.__type = undefined;
+    target.__arrayRef = undefined;
+  }
+  const cached = offsetCache.get(key);
+  if (cached !== undefined) {
+    if (cached.layoutVersion === mem.getLayoutVersion()) {
+      if (target !== undefined) {
+        target.__offset = cached.offset;
+        target.__layoutVersion = cached.layoutVersion;
+      }
+      return cached.offset;
+    }
+    offsetCache.delete(key);
+  }
+  const offset = getOffset(mem, key);
+  if (offset !== null) {
+    offsetCache.set(key, { offset, layoutVersion: mem.getLayoutVersion() });
+    if (target !== undefined) {
+      target.__offset = offset;
+      target.__layoutVersion = mem.getLayoutVersion();
+      target.__type = undefined;
+      target.__arrayRef = undefined;
+    }
+  }
+  return offset;
+}
+
 /** Whether a decoded value is a reference-countable object/array. */
 function isTrackable(value: unknown): boolean {
   return value !== null && typeof value === "object";
@@ -326,8 +443,14 @@ function readProp(
   prop: string | symbol,
   arrayCapacity?: number,
 ): unknown {
-  const fast = readCachedValue(mem, key);
-  const value = fast.hit ? fast.value : readValue(mem, key);
+  // Inline the read-cache fast path (instead of calling readCachedValue, which
+  // returns a polymorphic {hit,value} union and allocates an object on every
+  // cache hit). Keeping this monomorphic lets the JIT optimize the hot read.
+  const cached = readCache.get(key);
+  const value =
+    cached !== undefined && cached.version === mem.getVersion(cached.index)
+      ? cached.value
+      : readValue(mem, key);
   if (Array.isArray(value)) {
     return getTopLevelArrayMember(mem, key, value, prop, arrayCapacity);
   }
@@ -338,6 +461,94 @@ function readProp(
   return propValue;
 }
 
+/**
+ * Read a single object property for the per-property accessor cache, decoding
+ * only the requested slot (not the whole object) and caching the decoded value
+ * in `fieldCache` under the observed version. Array properties are cached as
+ * an array proxy so subsequent reads hit the fast path.
+ *
+ * This is the miss path for the object accessor getters; the hit path returns
+ * `fieldCache.value` directly.
+ */
+function readObjectProp(
+  mem: SharedMemory,
+  key: string,
+  prop: string,
+  fieldCache: { version: number; value: unknown },
+  version: number,
+  arrayCapacity?: number,
+): unknown {
+  const layout = getObjectLayout(mem, key);
+  if (layout === null) {
+    // Not an object (shouldn't happen for an object accessor); fall back.
+    return readProp(mem, key, prop, arrayCapacity);
+  }
+  const slotOffset = layout.properties.get(prop);
+  if (slotOffset === undefined) {
+    throw new TypeError(
+      `Value for key "${key}" has a fixed shape: properties may not be added or removed`,
+    );
+  }
+  const slot = mem.readValueSlot(slotOffset);
+  let value = decodeValue(mem, slot);
+  if (Array.isArray(value)) {
+    value = createArrayProxy(mem, key, prop, arrayCapacity);
+  }
+  fieldCache.version = version;
+  fieldCache.value = value;
+  return value;
+}
+
+/**
+ * Write a single object-property slot whose offset is already resolved
+ * (cached by the caller, e.g. the accessor setter). Avoids the
+ * `getObjectLayout` Map lookup + `properties.get` per write on the hot path.
+ */
+function writeObjectSlot(
+  mem: SharedMemory,
+  key: string,
+  slotOffset: number,
+  val: unknown,
+  arrayCapacity?: number,
+  target?: WriteTarget,
+): void {
+  if (typeof val === "number") {
+    // Fast path: numbers need no old-slot read (freeSlotRefs is a no-op)
+    // and no in-place string reuse; write the float64 directly.
+    mem.updateNumberSlot(slotOffset, val);
+    bumpTarget(mem, key, target);
+    return;
+  }
+  if (typeof val === "boolean") {
+    // Fast path: booleans need no old-slot read (freeSlotRefs is a no-op)
+    // and no in-place string reuse; write the 4 Int32s directly.
+    mem.updateBooleanSlot(slotOffset, val);
+    bumpTarget(mem, key, target);
+    return;
+  }
+  if (typeof val === "bigint" && val >= MIN_INT64 && val <= MAX_INT64) {
+    // Fast path: int64 bigints are written directly, avoiding the ValueSlot
+    // object allocation of the generic path.
+    mem.updateBigIntSlot(slotOffset, val);
+    bumpTarget(mem, key, target);
+    return;
+  }
+  if (typeof val === "string") {
+    // Fast path: short strings are written inline into the slot itself.
+    if (mem.updateInlineStringSlot(slotOffset, val)) {
+      bumpTarget(mem, key, target);
+      return;
+    }
+  }
+  const oldSlot = mem.readValueSlot(slotOffset);
+  freeSlotRefs(mem, oldSlot);
+  mem.updateValueSlot(
+    slotOffset,
+    encodeValue(mem, val, arrayCapacity, oldSlot),
+  );
+  bumpTarget(mem, key, target);
+}
+
 /**
  * Write a single property of a shared object value in place.
  *
@@ -350,8 +561,36 @@ function writeProp(
   prop: string | symbol,
   val: unknown,
   arrayCapacity?: number,
+  target?: WriteTarget,
 ): void {
-  mem.withLock(() => {
+  // Inline writeLock to avoid a closure allocation on the hot path.
+  mem.beginWrite();
+  if (mem.isDefragmenting()) {
+    mem.endWrite();
+    mem.withLock(() =>
+      writePropInner(mem, key, prop, val, arrayCapacity, target),
+    );
+    return;
+  }
+  try {
+    writePropInner(mem, key, prop, val, arrayCapacity, target);
+  } finally {
+    mem.endWrite();
+  }
+}
+
+function writePropInner(
+  mem: SharedMemory,
+  key: string,
+  prop: string | symbol,
+  val: unknown,
+  arrayCapacity?: number,
+  target?: WriteTarget,
+): void {
+  // If the slot type is already cached on the target, we can skip the
+  // getObjectLayout Map lookup for top-level arrays (which are never objects).
+  const knownType = target?.__type;
+  if (knownType !== TYPE_ARRAY_REF) {
     // Object property: use the cached layout to write only that slot.
     const layout = getObjectLayout(mem, key);
     if (layout !== null) {
@@ -361,70 +600,123 @@ function writeProp(
           `Value for key "${key}" has a fixed shape: properties may not be added or removed`,
         );
       }
-      mem.updateValueSlot(slotOffset, encodeValue(mem, val));
-      bump(mem, key);
+      writeObjectSlot(mem, key, slotOffset, val, arrayCapacity, target);
       return;
     }
+  }
 
-    // Top-level array index write: update only that array slot.
-    const offset = getOffset(mem, key);
-    if (offset === null) {
-      throw new Error(`No shared value found for key "${key}"`);
-    }
-    const slot = mem.readValueSlot(offset);
+  // Top-level array index write: update only that array slot.
+  const offset = getCachedOffset(mem, key, target);
+  if (offset === null) {
+    throw new Error(`No shared value found for key "${key}"`);
+  }
+  const slotType =
+    target !== undefined && target.__type !== undefined
+      ? target.__type
+      : mem.dataTable.getInt32(offset);
+  if (target !== undefined && target.__type === undefined) {
+    target.__type = slotType;
+  }
+  if (
+    slotType === TYPE_ARRAY_REF &&
+    typeof prop === "string" &&
+    /^\d+$/.test(prop)
+  ) {
+    const index = Number(prop);
+    // Use the cached ArrayRef when it is still valid (same layout version,
+    // i.e. no defragmentation or array growth has moved it). Otherwise
+    // re-read the 3 header Int32s and refresh the cache.
+    let ref = target?.__arrayRef;
     if (
-      slot.type === TYPE_ARRAY_REF &&
-      typeof prop === "string" &&
-      /^\d+$/.test(prop)
+      ref === undefined ||
+      target!.__arrayRefLayoutVersion !== mem.getLayoutVersion()
     ) {
-      const index = Number(prop);
-      const ref = { offset: slot.a, count: slot.b, capacity: slot.c };
-      if (index >= ref.count) {
-        throw new RangeError(
-          `Index ${index} out of bounds for array of length ${ref.count}`,
-        );
+      ref = {
+        offset: mem.dataTable.getInt32(offset + 4),
+        count: mem.dataTable.getInt32(offset + 8),
+        capacity: mem.dataTable.getInt32(offset + 12),
+      };
+      if (target !== undefined) {
+        target.__arrayRef = ref;
+        target.__arrayRefLayoutVersion = mem.getLayoutVersion();
       }
-      mem.updateArraySlot(ref, index, encodeValue(mem, val));
-      bump(mem, key);
+    }
+    if (index >= ref.count) {
+      throw new RangeError(
+        `Index ${index} out of bounds for array of length ${ref.count}`,
+      );
+    }
+    if (typeof val === "number") {
+      // Fast path: numbers need no old-slot read (freeSlotRefs is a no-op).
+      mem.updateArrayNumberSlot(ref, index, val);
+      bumpTarget(mem, key, target);
       return;
     }
-
-    // Top-level array length write: shrink/grow the array in place.
-    if (slot.type === TYPE_ARRAY_REF && prop === "length") {
-      const newLen = Number(val);
-      if (!Number.isInteger(newLen) || newLen < 0) {
-        throw new RangeError("Invalid array length");
-      }
-      const ref = { offset: slot.a, count: slot.b, capacity: slot.c };
-      if (newLen <= ref.capacity) {
-        mem.updateValueSlot(
-          offset,
-          arrayRefSlot({
-            offset: ref.offset,
-            count: newLen,
-            capacity: ref.capacity,
-          }),
-        );
-        bump(mem, key);
+    if (typeof val === "boolean") {
+      // Fast path: booleans need no old-slot read (freeSlotRefs is a no-op).
+      mem.updateArrayBooleanSlot(ref, index, val);
+      bumpTarget(mem, key, target);
+      return;
+    }
+    if (typeof val === "bigint" && val >= MIN_INT64 && val <= MAX_INT64) {
+      // Fast path: int64 bigints are written directly, avoiding the
+      // ValueSlot object allocation of the generic path.
+      mem.updateArrayBigIntSlot(ref, index, val);
+      bumpTarget(mem, key, target);
+      return;
+    }
+    if (typeof val === "string") {
+      // Fast path: short strings are written inline into the array slot.
+      if (mem.updateArrayInlineStringSlot(ref, index, val)) {
+        bumpTarget(mem, key, target);
         return;
       }
     }
+    freeSlotRefs(mem, mem.readArraySlot(ref, index));
+    mem.updateArraySlot(ref, index, encodeValue(mem, val));
+    bumpTarget(mem, key, target);
+    return;
+  }
 
-    // Fallback: full read-modify-write.
-    mutateValue<unknown, boolean>(
-      mem,
-      key,
-      (value) => {
-        if (Array.isArray(value)) {
-          (value as unknown as Record<string | symbol, unknown>)[prop] = val;
-        } else {
-          (value as Record<string | symbol, unknown>)[prop] = val;
-        }
-        return true;
-      },
-      arrayCapacity,
-    );
-  });
+  // Top-level array length write: shrink/grow the array in place.
+  if (slotType === TYPE_ARRAY_REF && prop === "length") {
+    const newLen = Number(val);
+    if (!Number.isInteger(newLen) || newLen < 0) {
+      throw new RangeError("Invalid array length");
+    }
+    const ref = {
+      offset: mem.dataTable.getInt32(offset + 4),
+      count: mem.dataTable.getInt32(offset + 8),
+      capacity: mem.dataTable.getInt32(offset + 12),
+    };
+    if (newLen <= ref.capacity) {
+      mem.updateValueSlot(
+        offset,
+        arrayRefSlot({
+          offset: ref.offset,
+          count: newLen,
+          capacity: ref.capacity,
+        }),
+      );
+      bumpTarget(mem, key, target);
+      return;
+    }
+  }
+
+  // Fallback: full read-modify-write.
+  mutateValue<unknown, boolean>(
+    mem,
+    key,
+    (value) => {
+      if (Array.isArray(value)) {
+        (value as unknown as Record<string | symbol, unknown>)[prop] = val;
+      } else {
+        (value as Record<string | symbol, unknown>)[prop] = val;
+      }
+      return true;
+    },
+    arrayCapacity,
+  );
 }
 
 /** Create a SharedRef proxy backed by a SharedMemory instance. */
@@ -444,6 +736,26 @@ function createSharedRef<T>(
     // the version check in the get handler.
     __cache: undefined as
       { version: number; value: unknown; index: number } | undefined,
+    // Cached DataTable offset for this key, valid only while the global
+    // layout version is unchanged (i.e. no defragmentation has moved it).
+    // Mirrors the module-level offsetCache to avoid a Map lookup on the
+    // write hot path.
+    __offset: undefined as number | undefined,
+    __layoutVersion: -1,
+    // Cached slot type for this key, so the write hot path can skip the
+    // DataTable type read when the value's type is known to be stable.
+    __type: undefined as number | undefined,
+    // Cached ArrayRef for a top-level array value, so the write hot path can
+    // skip re-reading the 3 header Int32s on every index write. Valid only
+    // while the global layout version is unchanged (no defragmentation) and
+    // while the array has not grown past the cached count (checked by the
+    // caller via `index < ref.count`).
+    __arrayRef: undefined as
+      { offset: number; count: number; capacity: number } | undefined,
+    __arrayRefLayoutVersion: -1,
+    // Cached version-cell index for this key, so the write hot path can bump
+    // the version cell without a Map lookup. Stable for the key's lifetime.
+    __index: undefined as number | undefined,
     read: () => {
       const value = copyValue(readValue(mem, key, target)) as T;
       if (tracker && isTrackable(value)) {
@@ -454,7 +766,7 @@ function createSharedRef<T>(
     },
     write: (value: T) => {
       target.__cache = undefined;
-      writeValue(mem, key, value, arrayCapacity);
+      writeValue(mem, key, value, arrayCapacity, target);
     },
     update: (fn: (current: T) => T) => {
       target.__cache = undefined;
@@ -521,33 +833,106 @@ function createSharedRef<T>(
       },
     });
     const ref = Object.create(proto) as Record<string | symbol, unknown>;
+    // Resolve the object's stable version-cell index lazily (the value may not
+    // be written to shared memory until after this accessor is built) and cache
+    // it so the hot getter can load the version cell directly without a Map
+    // lookup or an index→cell computation on every read. The cell index is
+    // stable for the key's lifetime (the Index Table is never reordered).
+    let cellIndex: number | null = null;
     for (const name of propNames) {
+      // Per-property cache slot bound to this getter closure (mirrors
+      // cofusion's per-field `desc.cachedVer`/`desc.cachedVal`). On a cache
+      // hit the getter returns the already-decoded value directly, avoiding
+      // the `readCache` Map hash lookup and the whole-object `v[name]`
+      // extraction on the hot path.
+      const fieldCache: { version: number; value: unknown } = {
+        version: -1,
+        value: undefined,
+      };
+      // Stable array proxy for this property, cached across writes. A write
+      // bumps the version and invalidates `fieldCache`, which would otherwise
+      // recreate the array proxy on every access. The proxy reads fresh data
+      // on each access, so it stays correct without being recreated.
+      let arrayProxy: unknown[] | undefined;
+      // Cached object slot offset for this property so writes skip the
+      // getObjectLayout Map lookup + properties.get on the hot path.
+      // Invalidated when the layout version changes (defragmentation moves
+      // the object block).
+      let slotOffset: number | undefined;
+      let slotLayoutVersion = -1;
       Object.defineProperty(ref, name, {
         enumerable: true,
         configurable: false,
         get() {
           // Lock-free fast path inlined so the JIT can optimize the hot
           // cache-hit read without a function-call chain.
-          const cached = readCache.get(key);
-          if (
-            cached !== undefined &&
-            cached.version === mem.getVersion(cached.index)
-          ) {
-            const v = cached.value;
-            if (Array.isArray(v)) {
-              return getTopLevelArrayMember(mem, key, v, name, arrayCapacity);
-            }
-            const pv = (v as Record<string | symbol, unknown>)[name];
-            if (Array.isArray(pv)) {
-              return createArrayProxy(mem, key, name, arrayCapacity);
-            }
-            return pv;
+          if (cellIndex === null) {
+            cellIndex = mem.getVersionCellIndex(getIndex(mem, key));
+          }
+          const version = Atomics.load(mem.versionView, cellIndex);
+          if (fieldCache.version === version) {
+            return fieldCache.value;
           }
-          return readProp(mem, key, name, arrayCapacity);
+          // If this property is an array, return the stable cached proxy
+          // (which reads fresh data on each access) instead of recreating it
+          // on every write.
+          if (arrayProxy !== undefined) {
+            return arrayProxy;
+          }
+          const value = readObjectProp(
+            mem,
+            key,
+            name,
+            fieldCache,
+            version,
+            arrayCapacity,
+          );
+          if (Array.isArray(value)) {
+            arrayProxy = value;
+          }
+          return value;
         },
         set(v: unknown) {
           target.__cache = undefined;
-          writeProp(mem, key, name, v, arrayCapacity);
+          mem.beginWrite();
+          if (mem.isDefragmenting()) {
+            // A defrag pass may move the object block: drop the cached slot
+            // offset so it is re-resolved, and run the write under the mutex.
+            mem.endWrite();
+            slotOffset = undefined;
+            slotLayoutVersion = -1;
+            mem.withLock(() =>
+              writePropInner(mem, key, name, v, arrayCapacity, target),
+            );
+            return;
+          }
+          try {
+            // Write directly to the cached slot offset when still valid,
+            // skipping the getObjectLayout Map lookup + properties.get.
+            if (slotLayoutVersion !== mem.getLayoutVersion()) {
+              slotOffset = undefined;
+              slotLayoutVersion = mem.getLayoutVersion();
+            }
+            if (slotOffset === undefined) {
+              const layout = getObjectLayout(mem, key);
+              if (layout === null) {
+                // Not an object (shouldn't happen for an object accessor).
+                throw new TypeError(
+                  `Value for key "${key}" has a fixed shape: properties may not be added or removed`,
+                );
+              }
+              const so = layout.properties.get(name);
+              if (so === undefined) {
+                throw new TypeError(
+                  `Value for key "${key}" has a fixed shape: properties may not be added or removed`,
+                );
+              }
+              slotOffset = so;
+            }
+            writeObjectSlot(mem, key, slotOffset, v, arrayCapacity, target);
+          } finally {
+            mem.endWrite();
+          }
         },
       });
     }
@@ -581,7 +966,7 @@ function createSharedRef<T>(
     },
     set(t, prop, val) {
       t.__cache = undefined;
-      writeProp(mem, key, prop, val, arrayCapacity);
+      writeProp(mem, key, prop, val, arrayCapacity, t);
       return true;
     },
     deleteProperty() {
@@ -592,22 +977,6 @@ function createSharedRef<T>(
   }) as unknown as SharedRef<T>;
 }
 
-/**
- * Lock-free fast path: if the cached version matches the current version cell,
- * the cached value is still valid. Returns the cached value, or a miss marker.
- * Kept small so the JIT can inline it into hot accessor getters.
- */
-function readCachedValue(
-  mem: SharedMemory,
-  key: string,
-): { hit: true; value: unknown } | { hit: false } {
-  const cached = readCache.get(key);
-  if (cached !== undefined && cached.version === mem.getVersion(cached.index)) {
-    return { hit: true, value: cached.value };
-  }
-  return { hit: false };
-}
-
 /**
  * Read the full value for a key from shared memory, using the read cache.
  *
@@ -622,10 +991,13 @@ function readValue(
     __cache?: { version: number; value: unknown; index: number };
   },
 ): unknown {
-  const fast = readCachedValue(mem, key);
-  if (fast.hit) return fast.value;
-
+  // Inline the read-cache fast path (see readProp) to avoid the polymorphic
+  // {hit,value} union returned by readCachedValue.
   const cached = readCache.get(key);
+  if (cached !== undefined && cached.version === mem.getVersion(cached.index)) {
+    return cached.value;
+  }
+
   const index = cached !== undefined ? cached.index : getIndex(mem, key);
   const version = mem.getVersion(index);
 
@@ -661,61 +1033,156 @@ function writeValue(
   key: string,
   value: unknown,
   arrayCapacity?: number,
+  target?: WriteTarget,
 ): void {
-  mem.withLock(() => {
-    const existing = getOffset(mem, key);
-    if (existing !== null) {
-      const type = mem.dataTable.getInt32(existing);
-      if (type === 5) {
-        // Update existing object's property slots in place.
-        const properties = mem.readObject(existing);
-        const valueObj = value as Record<string, unknown>;
-        for (let i = 0; i < properties.length; i++) {
-          const [name] = properties[i]!;
-          if (!(name in valueObj)) {
-            throw new TypeError(
-              `Value for key "${key}" has a fixed shape: properties may not be added or removed`,
-            );
-          }
-          mem.updateObjectSlot(
-            existing,
-            i,
-            encodeValue(mem, valueObj[name], arrayCapacity),
+  // Inline writeLock to avoid a closure allocation on the hot path.
+  mem.beginWrite();
+  if (mem.isDefragmenting()) {
+    mem.endWrite();
+    mem.withLock(() => writeValueInner(mem, key, value, arrayCapacity, target));
+    return;
+  }
+  try {
+    writeValueInner(mem, key, value, arrayCapacity, target);
+  } finally {
+    mem.endWrite();
+  }
+}
+
+function writeValueInner(
+  mem: SharedMemory,
+  key: string,
+  value: unknown,
+  arrayCapacity?: number,
+  target?: WriteTarget,
+): void {
+  const existing = getCachedOffset(mem, key, target);
+  if (existing !== null) {
+    // Skip the DataTable type read when the slot type is known to be stable
+    // (cached on the target). Only re-read when the type is unknown.
+    let type = target?.__type;
+    if (type === undefined) {
+      type = mem.dataTable.getInt32(existing);
+      if (target !== undefined) target.__type = type;
+    }
+    if (type === 5) {
+      // Update existing object's property slots in place.
+      const properties = mem.readObject(existing);
+      const valueObj = value as Record<string, unknown>;
+      for (let i = 0; i < properties.length; i++) {
+        const [name] = properties[i]!;
+        if (!(name in valueObj)) {
+          throw new TypeError(
+            `Value for key "${key}" has a fixed shape: properties may not be added or removed`,
           );
         }
-        // Check for extra properties.
-        const existingNames = new Set(properties.map(([n]) => n));
-        for (const name of Object.keys(valueObj)) {
-          if (!existingNames.has(name)) {
-            throw new TypeError(
-              `Value for key "${key}" has a fixed shape: properties may not be added or removed`,
-            );
-          }
+        // Free the old referenced blocks (array/string) before overwriting.
+        const oldPropSlot = properties[i]![1];
+        freeSlotRefs(mem, oldPropSlot);
+        mem.updateObjectSlot(
+          existing,
+          i,
+          encodeValue(mem, valueObj[name], arrayCapacity, oldPropSlot),
+        );
+      }
+      // Check for extra properties.
+      const existingNames = new Set(properties.map(([n]) => n));
+      for (const name of Object.keys(valueObj)) {
+        if (!existingNames.has(name)) {
+          throw new TypeError(
+            `Value for key "${key}" has a fixed shape: properties may not be added or removed`,
+          );
         }
-        bump(mem, key);
-        return;
       }
-      // Update a single value slot in place.
-      mem.updateValueSlot(existing, encodeValue(mem, value, arrayCapacity));
-      bump(mem, key);
+      bumpTarget(mem, key, target);
       return;
     }
-
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      // Create a new object.
-      const valueObj = value as Record<string, unknown>;
-      const props: Array<[string, ValueSlot]> = Object.entries(valueObj).map(
-        ([name, v]) => [name, encodeValue(mem, v, arrayCapacity)],
+    // Update a single value slot in place.
+    if (typeof value === "number") {
+      // Fast path: numbers need no old-slot read (freeSlotRefs is a no-op)
+      // and no in-place string reuse; write the float64 directly.
+      mem.updateNumberSlot(existing, value);
+      bumpTarget(mem, key, target);
+      return;
+    }
+    const isPrimitive = typeof value === "boolean" || typeof value === "bigint";
+    if (isPrimitive) {
+      // Fast path: primitives need no old-slot read (freeSlotRefs is a
+      // no-op) and no in-place string reuse.
+      if (typeof value === "boolean") {
+        mem.updateBooleanSlot(existing, value);
+      } else if (value >= MIN_INT64 && value <= MAX_INT64) {
+        // Fast path: int64 bigints are written directly, avoiding the
+        // ValueSlot object allocation of the generic path.
+        mem.updateBigIntSlot(existing, value);
+      } else {
+        mem.updateValueSlot(existing, encodeValue(mem, value, arrayCapacity));
+      }
+      bumpTarget(mem, key, target);
+      return;
+    }
+    if (typeof value === "string") {
+      // Fast path: short strings are written inline into the slot itself,
+      // avoiding a heap allocation and the string-table write. Longer strings
+      // read the old string ref directly (no ValueSlot object allocation) so
+      // storeStringValue can reuse the block in place.
+      if (mem.updateInlineStringSlot(existing, value)) {
+        bumpTarget(mem, key, target);
+        return;
+      }
+      const oldType = mem.dataTable.getInt32(existing);
+      const oldA = mem.dataTable.getInt32(existing + 4);
+      const oldB = mem.dataTable.getInt32(existing + 8);
+      const ref = mem.storeStringValue(
+        value,
+        oldType === TYPE_STRING_VALUE_REF
+          ? { offset: oldA, length: oldB }
+          : undefined,
       );
-      const offset = mem.createObject(props);
-      mem.insert(key, offset);
+      mem.updateValueSlot(existing, stringValueRefSlot(ref));
+      bumpTarget(mem, key, target);
       return;
     }
+    const oldSlot = mem.readValueSlot(existing);
+    freeSlotRefs(mem, oldSlot);
+    mem.updateValueSlot(
+      existing,
+      encodeValue(mem, value, arrayCapacity, oldSlot),
+    );
+    bumpTarget(mem, key, target);
+    return;
+  }
 
-    // Create a single value slot (primitive or array).
-    const offset = mem.storeValueSlot(encodeValue(mem, value, arrayCapacity));
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    // Create a new object.
+    const valueObj = value as Record<string, unknown>;
+    const props: Array<[string, ValueSlot]> = Object.entries(valueObj).map(
+      ([name, v]) => [name, encodeValue(mem, v, arrayCapacity)],
+    );
+    const offset = mem.createObject(props);
     mem.insert(key, offset);
-  });
+    const lv = mem.getLayoutVersion();
+    offsetCache.set(key, { offset, layoutVersion: lv });
+    if (target !== undefined) {
+      target.__offset = offset;
+      target.__layoutVersion = lv;
+      target.__type = undefined;
+      target.__arrayRef = undefined;
+    }
+    return;
+  }
+
+  // Create a single value slot (primitive or array).
+  const offset = mem.storeValueSlot(encodeValue(mem, value, arrayCapacity));
+  mem.insert(key, offset);
+  const lv = mem.getLayoutVersion();
+  offsetCache.set(key, { offset, layoutVersion: lv });
+  if (target !== undefined) {
+    target.__offset = offset;
+    target.__layoutVersion = lv;
+    target.__type = undefined;
+    target.__arrayRef = undefined;
+  }
 }
 
 /** Bump the version cell for a key, invalidating read caches. */
@@ -723,6 +1190,25 @@ function bump(mem: SharedMemory, key: string): void {
   mem.bumpVersion(getIndex(mem, key));
 }
 
+/**
+ * Bump the version cell for a key using the target's cached index, avoiding
+ * the `getIndex` Map lookup on the write hot path. Falls back to `bump` when
+ * the index is not yet cached.
+ */
+function bumpTarget(
+  mem: SharedMemory,
+  key: string,
+  target?: WriteTarget,
+): void {
+  if (target !== undefined && target.__index !== undefined) {
+    mem.bumpVersion(target.__index);
+    return;
+  }
+  const index = getIndex(mem, key);
+  if (target !== undefined) target.__index = index;
+  mem.bumpVersion(index);
+}
+
 /** Atomically update the value for a key. */
 function updateValue<T>(
   mem: SharedMemory,
@@ -730,7 +1216,7 @@ function updateValue<T>(
   fn: (current: T) => T,
   arrayCapacity?: number,
 ): T {
-  return mem.withLock(() => {
+  return writeLock(mem, () => {
     const current = readValue(mem, key) as T;
     const next = fn(current);
     writeValue(mem, key, next, arrayCapacity);
@@ -749,7 +1235,7 @@ function mutateValue<T, R>(
   fn: (current: T) => R,
   arrayCapacity?: number,
 ): R {
-  return mem.withLock(() => {
+  return writeLock(mem, () => {
     const current = readValue(mem, key) as T;
     const result = fn(current);
     writeValue(mem, key, current, arrayCapacity);
@@ -794,7 +1280,7 @@ function mutateArrayRef(
   method: "push" | "pop",
   args: unknown[],
 ): unknown {
-  return mem.withLock(() => {
+  return writeLock(mem, () => {
     const slotOffset = findArrayRefSlot(mem, key, prop);
     if (slotOffset === null) {
       throw new TypeError("Value is not an array");
@@ -822,6 +1308,8 @@ function mutateArrayRef(
     // Read the last element before decrementing.
     const lastSlot = mem.readArraySlot(ref, ref.count - 1);
     const result = decodeValue(mem, lastSlot);
+    // Free the removed element's referenced blocks (array/string).
+    freeSlotRefs(mem, lastSlot);
     const next = {
       offset: ref.offset,
       count: ref.count - 1,
@@ -883,6 +1371,159 @@ function createArrayProxy(
   prop: string,
   arrayCapacity?: number,
 ): unknown[] {
+  // Cache the object's property slot offset and the array ref so index writes
+  // skip the per-write getObjectLayout Map lookup, properties.get, and the
+  // DataTable header reads. Invalidated when the layout version changes
+  // (defragmentation or array growth via moveArray).
+  let cachedSlotOffset: number | undefined;
+  let cachedRef:
+    { offset: number; count: number; capacity: number } | undefined;
+  let cachedLayoutVersion = -1;
+  // Cached version-cell index for this key, so writes can bump the version
+  // cell without a Map lookup on every write. Stable for the key's lifetime.
+  let cachedIndex: number | undefined;
+
+  /** Bump the key's version cell using the cached index (resolved lazily). */
+  function bumpCached(): void {
+    if (cachedIndex === undefined) {
+      cachedIndex = getIndex(mem, key);
+    }
+    mem.bumpVersion(cachedIndex);
+  }
+
+  /**
+   * Write a single array-property slot in place. Defined once (not per call)
+   * so the set handler can inline the writeLock without allocating a closure
+   * on every write. Mutates the cached slot offset/ref/layout version.
+   */
+  function writeArrayProp(arrProp: string | symbol, val: unknown): boolean {
+    // Refresh the cached slot offset when the layout version changed
+    // (defragmentation may have moved the object block).
+    if (cachedLayoutVersion !== mem.getLayoutVersion()) {
+      cachedSlotOffset = undefined;
+      cachedRef = undefined;
+      cachedLayoutVersion = mem.getLayoutVersion();
+    }
+    if (cachedSlotOffset === undefined) {
+      const layout = getObjectLayout(mem, key);
+      if (layout === null) {
+        // Fallback: full read-modify-write.
+        return mutateValue<Record<string, unknown>, boolean>(
+          mem,
+          key,
+          (fresh) => {
+            const arr = fresh[prop] as unknown[];
+            (arr as unknown as Record<string | symbol, unknown>)[arrProp] = val;
+            return true;
+          },
+          arrayCapacity,
+        );
+      }
+      const so = layout.properties.get(prop);
+      if (so === undefined) {
+        throw new TypeError(
+          `Value for key "${key}" has a fixed shape: properties may not be added or removed`,
+        );
+      }
+      cachedSlotOffset = so;
+    }
+    const propSlot = mem.readValueSlot(cachedSlotOffset);
+    if (
+      propSlot.type === TYPE_ARRAY_REF &&
+      typeof arrProp === "string" &&
+      /^\d+$/.test(arrProp)
+    ) {
+      const index = Number(arrProp);
+      // Use the cached ref when valid; re-read when the array may have
+      // grown past the cached count (push) or the layout changed.
+      let ref = cachedRef;
+      if (
+        ref === undefined ||
+        index >= ref.count ||
+        cachedLayoutVersion !== mem.getLayoutVersion()
+      ) {
+        ref = {
+          offset: propSlot.a,
+          count: propSlot.b,
+          capacity: propSlot.c,
+        };
+        cachedRef = ref;
+      }
+      if (index >= ref.count) {
+        throw new RangeError(
+          `Index ${index} out of bounds for array of length ${ref.count}`,
+        );
+      }
+      if (typeof val === "number") {
+        // Fast path: numbers need no old-slot read (freeSlotRefs is a no-op).
+        mem.updateArrayNumberSlot(ref, index, val);
+        bumpCached();
+        return true;
+      }
+      if (typeof val === "boolean") {
+        // Fast path: booleans need no old-slot read (freeSlotRefs is a no-op).
+        mem.updateArrayBooleanSlot(ref, index, val);
+        bumpCached();
+        return true;
+      }
+      if (typeof val === "bigint" && val >= MIN_INT64 && val <= MAX_INT64) {
+        // Fast path: int64 bigints are written directly, avoiding the
+        // ValueSlot object allocation of the generic path.
+        mem.updateArrayBigIntSlot(ref, index, val);
+        bumpCached();
+        return true;
+      }
+      if (typeof val === "string") {
+        // Fast path: short strings are written inline into the slot.
+        if (mem.updateArrayInlineStringSlot(ref, index, val)) {
+          bumpCached();
+          return true;
+        }
+      }
+      freeSlotRefs(mem, mem.readArraySlot(ref, index));
+      mem.updateArraySlot(ref, index, encodeValue(mem, val));
+      bumpCached();
+      return true;
+    }
+    // Array property length write: shrink/grow in place without re-encoding
+    // the whole object (which would leave a dead slot).
+    if (propSlot.type === TYPE_ARRAY_REF && arrProp === "length") {
+      const newLen = Number(val);
+      if (!Number.isInteger(newLen) || newLen < 0) {
+        throw new RangeError("Invalid array length");
+      }
+      const ref = {
+        offset: propSlot.a,
+        count: propSlot.b,
+        capacity: propSlot.c,
+      };
+      if (newLen <= ref.capacity) {
+        mem.updateValueSlot(
+          cachedSlotOffset,
+          arrayRefSlot({
+            offset: ref.offset,
+            count: newLen,
+            capacity: ref.capacity,
+          }),
+        );
+        bumpCached();
+        return true;
+      }
+      // Growing beyond capacity falls through to the full read-modify-write.
+    }
+    // Fallback: full read-modify-write.
+    return mutateValue<Record<string, unknown>, boolean>(
+      mem,
+      key,
+      (fresh) => {
+        const arr = fresh[prop] as unknown[];
+        (arr as unknown as Record<string | symbol, unknown>)[arrProp] = val;
+        return true;
+      },
+      arrayCapacity,
+    );
+  }
+
   return new Proxy([] as unknown[], {
     get(_target, arrProp) {
       // push/pop on an array property: operate directly on the array ref
@@ -939,73 +1580,18 @@ function createArrayProxy(
     },
     set(_target, arrProp, val) {
       // In-place update: write only the affected array slot instead of
-      // decoding and re-encoding the whole object.
-      return mem.withLock(() => {
-        const layout = getObjectLayout(mem, key);
-        if (layout !== null) {
-          const slotOffset = layout.properties.get(prop);
-          if (slotOffset !== undefined) {
-            const propSlot = mem.readValueSlot(slotOffset);
-            if (
-              propSlot.type === TYPE_ARRAY_REF &&
-              typeof arrProp === "string" &&
-              /^\d+$/.test(arrProp)
-            ) {
-              const index = Number(arrProp);
-              const ref = {
-                offset: propSlot.a,
-                count: propSlot.b,
-                capacity: propSlot.c,
-              };
-              if (index >= ref.count) {
-                throw new RangeError(
-                  `Index ${index} out of bounds for array of length ${ref.count}`,
-                );
-              }
-              mem.updateArraySlot(ref, index, encodeValue(mem, val));
-              bump(mem, key);
-              return true;
-            }
-            // Array property length write: shrink/grow in place without
-            // re-encoding the whole object (which would leave a dead slot).
-            if (propSlot.type === TYPE_ARRAY_REF && arrProp === "length") {
-              const newLen = Number(val);
-              if (!Number.isInteger(newLen) || newLen < 0) {
-                throw new RangeError("Invalid array length");
-              }
-              const ref = {
-                offset: propSlot.a,
-                count: propSlot.b,
-                capacity: propSlot.c,
-              };
-              if (newLen <= ref.capacity) {
-                mem.updateValueSlot(
-                  slotOffset,
-                  arrayRefSlot({
-                    offset: ref.offset,
-                    count: newLen,
-                    capacity: ref.capacity,
-                  }),
-                );
-                bump(mem, key);
-                return true;
-              }
-              // Growing beyond capacity falls through to the full read-modify-write.
-            }
-          }
-        }
-        // Fallback: full read-modify-write.
-        return mutateValue<Record<string, unknown>, boolean>(
-          mem,
-          key,
-          (fresh) => {
-            const arr = fresh[prop] as unknown[];
-            (arr as unknown as Record<string | symbol, unknown>)[arrProp] = val;
-            return true;
-          },
-          arrayCapacity,
-        );
-      });
+      // decoding and re-encoding the whole object. Inline writeLock to avoid
+      // a closure allocation on the hot path.
+      mem.beginWrite();
+      if (mem.isDefragmenting()) {
+        mem.endWrite();
+        return mem.withLock(() => writeArrayProp(arrProp, val));
+      }
+      try {
+        return writeArrayProp(arrProp, val);
+      } finally {
+        mem.endWrite();
+      }
     },
   });
 }