bun-shared-memory 0.1.8 → 0.2.0

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";
@@ -338,6 +455,44 @@ 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 property of a shared object value in place.
  *
@@ -350,8 +505,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 +544,136 @@ 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);
+      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 === "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);
       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 === "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 +693,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 +723,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 +790,62 @@ 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;
       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;
+          }
+          // 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;
           }
-          return readProp(mem, key, name, arrayCapacity);
+          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);
+          writeProp(mem, key, name, v, arrayCapacity, target);
         },
       });
     }
@@ -581,7 +879,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() {
@@ -661,61 +959,152 @@ 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 {
+        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 +1112,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 +1138,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 +1157,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 +1202,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 +1230,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 +1293,14 @@ 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;
   return new Proxy([] as unknown[], {
     get(_target, arrProp) {
       // push/pop on an array property: operate directly on the array ref
@@ -940,59 +1358,116 @@ 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));
+      return writeLock(mem, () => {
+        // 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) and no in-place string reuse.
+            mem.updateArrayNumberSlot(ref, index, val);
+            bump(mem, key);
+            return true;
+          }
+          if (typeof val === "boolean") {
+            // Fast path: booleans need no old-slot read (freeSlotRefs is a
+            // no-op).
+            mem.updateArrayBooleanSlot(ref, index, val);
+            bump(mem, key);
+            return true;
+          }
+          if (typeof val === "string") {
+            // Fast path: short strings are written inline into the slot.
+            if (mem.updateArrayInlineStringSlot(ref, index, 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.
-            }
           }
+          freeSlotRefs(mem, mem.readArraySlot(ref, index));
+          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(
+              cachedSlotOffset,
+              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>(