@memnexus-ai/sdk 1.59.17 → 1.59.19

package/dist/index.cjs

@@ -1427,6 +1427,13 @@ var Memories = class {
    * Retrieve the current HEAD version of a named memory by its user-assigned name.
    * Supports the same detail levels as GET /api/memories/{id}.
    * 
+   * 404 semantics: a 404 does NOT always mean the name was never created. It
+   * is also returned when the name's current head was superseded, contradicted,
+   * or duplicated and left with no successor version carrying the name (an
+   * integrity condition — an orphaned head). Only current (or legacy
+   * unstamped) heads are served; a superseded head is never returned as stale
+   * content. Callers must not assume 404 == never-existed.
+   * 
    * @param name — Memory name (kebab-case, 2-64 chars)
    * @param options — Optional parameters
    */
@@ -1470,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

@@ -2849,6 +2849,13 @@ declare class Memories {
      * Retrieve the current HEAD version of a named memory by its user-assigned name.
      * Supports the same detail levels as GET /api/memories/{id}.
      *
+     * 404 semantics: a 404 does NOT always mean the name was never created. It
+     * is also returned when the name's current head was superseded, contradicted,
+     * or duplicated and left with no successor version carrying the name (an
+     * integrity condition — an orphaned head). Only current (or legacy
+     * unstamped) heads are served; a superseded head is never returned as stale
+     * content. Callers must not assume 404 == never-existed.
+     *
      * @param name — Memory name (kebab-case, 2-64 chars)
      * @param options — Optional parameters
      */
@@ -2896,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

@@ -2849,6 +2849,13 @@ declare class Memories {
      * Retrieve the current HEAD version of a named memory by its user-assigned name.
      * Supports the same detail levels as GET /api/memories/{id}.
      *
+     * 404 semantics: a 404 does NOT always mean the name was never created. It
+     * is also returned when the name's current head was superseded, contradicted,
+     * or duplicated and left with no successor version carrying the name (an
+     * integrity condition — an orphaned head). Only current (or legacy
+     * unstamped) heads are served; a superseded head is never returned as stale
+     * content. Callers must not assume 404 == never-existed.
+     *
      * @param name — Memory name (kebab-case, 2-64 chars)
      * @param options — Optional parameters
      */
@@ -2896,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

@@ -1400,6 +1400,13 @@ var Memories = class {
    * Retrieve the current HEAD version of a named memory by its user-assigned name.
    * Supports the same detail levels as GET /api/memories/{id}.
    * 
+   * 404 semantics: a 404 does NOT always mean the name was never created. It
+   * is also returned when the name's current head was superseded, contradicted,
+   * or duplicated and left with no successor version carrying the name (an
+   * integrity condition — an orphaned head). Only current (or legacy
+   * unstamped) heads are served; a superseded head is never returned as stale
+   * content. Callers must not assume 404 == never-existed.
+   * 
    * @param name — Memory name (kebab-case, 2-64 chars)
    * @param options — Optional parameters
    */
@@ -1443,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.17",
+  "version": "1.59.19",
   "description": "Official Node.js SDK for the MemNexus API",
   "license": "Proprietary",
   "type": "module",