@memnexus-ai/sdk 1.59.18 → 1.59.20

package/dist/index.cjs

@@ -1477,9 +1477,12 @@ var Memories = class {
    *
    * Atomically appends a text block to a named memory, eliminating the
    * read-modify-write clobber that concurrent full-content updates cause on
-   * shared named memories. The server reads the current head, concatenates
-   * `existing + separator + block`, and writes a new version under the
-   * NameLock with an internal compare-and-swap + bounded retry — so
+   * shared named memories. Each append runs inside a single transaction that
+   * holds the per-name NameLock end to end: it acquires the lock, reads the
+   * current head UNDER the lock, concatenates `existing + separator + block`,
+   * and writes the new version — all before releasing the lock. Concurrent
+   * appends therefore QUEUE on the lock and serialize (the same mechanism the
+   * full-content PUT path uses); there is no compare-and-swap retry loop, so
    * simultaneous appends all survive and the client needs no retry logic.
    * Content is decrypted, assembled, size-checked, and re-encrypted
    * server-side; plaintext is never returned to other callers.

package/dist/index.d.cts

@@ -2903,9 +2903,12 @@ declare class Memories {
      *
      * Atomically appends a text block to a named memory, eliminating the
      * read-modify-write clobber that concurrent full-content updates cause on
-     * shared named memories. The server reads the current head, concatenates
-     * `existing + separator + block`, and writes a new version under the
-     * NameLock with an internal compare-and-swap + bounded retry — so
+     * shared named memories. Each append runs inside a single transaction that
+     * holds the per-name NameLock end to end: it acquires the lock, reads the
+     * current head UNDER the lock, concatenates `existing + separator + block`,
+     * and writes the new version — all before releasing the lock. Concurrent
+     * appends therefore QUEUE on the lock and serialize (the same mechanism the
+     * full-content PUT path uses); there is no compare-and-swap retry loop, so
      * simultaneous appends all survive and the client needs no retry logic.
      * Content is decrypted, assembled, size-checked, and re-encrypted
      * server-side; plaintext is never returned to other callers.

package/dist/index.d.ts

@@ -2903,9 +2903,12 @@ declare class Memories {
      *
      * Atomically appends a text block to a named memory, eliminating the
      * read-modify-write clobber that concurrent full-content updates cause on
-     * shared named memories. The server reads the current head, concatenates
-     * `existing + separator + block`, and writes a new version under the
-     * NameLock with an internal compare-and-swap + bounded retry — so
+     * shared named memories. Each append runs inside a single transaction that
+     * holds the per-name NameLock end to end: it acquires the lock, reads the
+     * current head UNDER the lock, concatenates `existing + separator + block`,
+     * and writes the new version — all before releasing the lock. Concurrent
+     * appends therefore QUEUE on the lock and serialize (the same mechanism the
+     * full-content PUT path uses); there is no compare-and-swap retry loop, so
      * simultaneous appends all survive and the client needs no retry logic.
      * Content is decrypted, assembled, size-checked, and re-encrypted
      * server-side; plaintext is never returned to other callers.

package/dist/index.js

@@ -1450,9 +1450,12 @@ var Memories = class {
    *
    * Atomically appends a text block to a named memory, eliminating the
    * read-modify-write clobber that concurrent full-content updates cause on
-   * shared named memories. The server reads the current head, concatenates
-   * `existing + separator + block`, and writes a new version under the
-   * NameLock with an internal compare-and-swap + bounded retry — so
+   * shared named memories. Each append runs inside a single transaction that
+   * holds the per-name NameLock end to end: it acquires the lock, reads the
+   * current head UNDER the lock, concatenates `existing + separator + block`,
+   * and writes the new version — all before releasing the lock. Concurrent
+   * appends therefore QUEUE on the lock and serialize (the same mechanism the
+   * full-content PUT path uses); there is no compare-and-swap retry loop, so
    * simultaneous appends all survive and the client needs no retry logic.
    * Content is decrypted, assembled, size-checked, and re-encrypted
    * server-side; plaintext is never returned to other callers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memnexus-ai/sdk",
-  "version": "1.59.18",
+  "version": "1.59.20",
   "description": "Official Node.js SDK for the MemNexus API",
   "license": "Proprietary",
   "type": "module",