@levalicious/server-memory 0.0.12 → 0.0.13

package/binding.gyp

@@ -0,0 +1,16 @@
+{
+  "targets": [
+    {
+      "target_name": "memoryfile",
+      "sources": [
+        "native/memoryfile.c",
+        "native/binding.c"
+      ],
+      "include_dirs": [
+        "native"
+      ],
+      "cflags": ["-std=c11", "-Wall", "-Wextra", "-O2"],
+      "defines": ["_GNU_SOURCE"]
+    }
+  ]
+}

package/dist/server.js

@@ -950,7 +950,7 @@ export function createServer(memoryFilePath) {
                 sizes: ["any"]
             }
         ],
-        version: "0.0.12",
+        version: "0.0.13",
     }, {
         capabilities: {
             tools: {},

package/dist/src/memoryfile.js

@@ -5,12 +5,25 @@
  * Buffers passed to/from the native layer are Node Buffers.
  */
 import { createRequire } from 'module';
+import { existsSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
-// The .node binary is in build/Release/ relative to project root
-const native = require(join(__dirname, '..', 'build', 'Release', 'memoryfile.node'));
+// Walk up from __dirname to find the package root containing build/Release/memoryfile.node.
+// Works from source (src/), compiled (dist/src/), and npx cache contexts.
+function findNative() {
+    let dir = __dirname;
+    const { root } = require('path').parse(dir);
+    while (dir !== root) {
+        const candidate = join(dir, 'build', 'Release', 'memoryfile.node');
+        if (existsSync(candidate))
+            return candidate;
+        dir = dirname(dir);
+    }
+    throw new Error('Could not find native memoryfile.node — was the C addon built? Run: node-gyp rebuild');
+}
+const native = require(findNative());
 export class MemoryFile {
     handle;
     closed = false;

package/native/binding.c

@@ -0,0 +1,340 @@
+/*
+ * N-API binding for memoryfile
+ *
+ * Exposes the C memoryfile allocator to Node.js.
+ * Each MemoryFile handle is wrapped in a pointerless external.
+ */
+
+#define NAPI_VERSION 8
+#include <node_api.h>
+#include <stdlib.h>
+#include <string.h>
+#include "memoryfile.h"
+
+/* =========================================================================
+ * Helpers
+ * ========================================================================= */
+
+#define NAPI_CALL(call)                                                    \
+    do {                                                                   \
+        napi_status status = (call);                                       \
+        if (status != napi_ok) {                                           \
+            napi_throw_error(env, NULL, "N-API call failed: " #call);      \
+            return NULL;                                                   \
+        }                                                                  \
+    } while (0)
+
+static napi_value make_u64(napi_env env, u64 val) {
+    /* Use BigInt for u64 to avoid precision loss */
+    napi_value result;
+    NAPI_CALL(napi_create_bigint_uint64(env, val, &result));
+    return result;
+}
+
+static u64 get_u64(napi_env env, napi_value val) {
+    bool lossless;
+    uint64_t result;
+    napi_get_value_bigint_uint64(env, val, &result, &lossless);
+    return result;
+}
+
+static void mf_release(napi_env env, void *data, void *hint) {
+    (void)env; (void)hint;
+    memfile_t *mf = (memfile_t*)data;
+    if (mf) {
+        memfile_close(mf);  /* no-op if already closed */
+        mf->mmap_base = NULL;
+        mf->header = NULL;
+        free(mf);
+    }
+}
+
+static memfile_t *unwrap_mf(napi_env env, napi_value val) {
+    memfile_t *mf;
+    napi_get_value_external(env, val, (void**)&mf);
+    return mf;
+}
+
+/* =========================================================================
+ * memfile_open(path: string, initialSize: number) => external
+ * ========================================================================= */
+
+static napi_value n_memfile_open(napi_env env, napi_callback_info info) {
+    size_t argc = 2;
+    napi_value argv[2];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    /* Get path string */
+    char path[4096];
+    size_t path_len;
+    NAPI_CALL(napi_get_value_string_utf8(env, argv[0], path, sizeof(path), &path_len));
+
+    /* Get initial size */
+    uint32_t initial_size;
+    NAPI_CALL(napi_get_value_uint32(env, argv[1], &initial_size));
+
+    memfile_t *mf = memfile_open(path, (size_t)initial_size);
+    if (!mf) {
+        napi_throw_error(env, NULL, "memfile_open failed");
+        return NULL;
+    }
+
+    napi_value result;
+    NAPI_CALL(napi_create_external(env, mf, mf_release, NULL, &result));
+    return result;
+}
+
+/* =========================================================================
+ * memfile_close(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_close(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    memfile_close(mf);
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_sync(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_sync(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    memfile_sync(mf);
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_alloc(handle: external, size: bigint) => bigint (offset)
+ * ========================================================================= */
+
+static napi_value n_memfile_alloc(napi_env env, napi_callback_info info) {
+    size_t argc = 2;
+    napi_value argv[2];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    u64 size = get_u64(env, argv[1]);
+
+    u64 offset = memfile_alloc(mf, size);
+    return make_u64(env, offset);
+}
+
+/* =========================================================================
+ * memfile_free(handle: external, offset: bigint) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_free(napi_env env, napi_callback_info info) {
+    size_t argc = 2;
+    napi_value argv[2];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    u64 offset = get_u64(env, argv[1]);
+
+    memfile_free(mf, offset);
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_coalesce(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_coalesce(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    memfile_coalesce(mf);
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_read(handle: external, offset: bigint, length: bigint) => Buffer
+ * ========================================================================= */
+
+static napi_value n_memfile_read(napi_env env, napi_callback_info info) {
+    size_t argc = 3;
+    napi_value argv[3];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    u64 offset = get_u64(env, argv[1]);
+    u64 len = get_u64(env, argv[2]);
+
+    /* Create a Node Buffer and copy data into it */
+    void *buf_data;
+    napi_value result;
+    NAPI_CALL(napi_create_buffer(env, (size_t)len, &buf_data, &result));
+
+    if (memfile_read(mf, offset, buf_data, len) < 0) {
+        napi_throw_error(env, NULL, "memfile_read: offset/length out of bounds");
+        return NULL;
+    }
+
+    return result;
+}
+
+/* =========================================================================
+ * memfile_write(handle: external, offset: bigint, data: Buffer) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_write(napi_env env, napi_callback_info info) {
+    size_t argc = 3;
+    napi_value argv[3];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    u64 offset = get_u64(env, argv[1]);
+
+    /* Get Buffer data */
+    void *buf_data;
+    size_t buf_len;
+    NAPI_CALL(napi_get_buffer_info(env, argv[2], &buf_data, &buf_len));
+
+    if (memfile_write(mf, offset, buf_data, buf_len) < 0) {
+        napi_throw_error(env, NULL, "memfile_write: offset/length out of bounds");
+        return NULL;
+    }
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_lock_shared(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_lock_shared(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    if (memfile_lock_shared(mf) < 0) {
+        napi_throw_error(env, NULL, "memfile_lock_shared failed");
+        return NULL;
+    }
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_lock_exclusive(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_lock_exclusive(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    if (memfile_lock_exclusive(mf) < 0) {
+        napi_throw_error(env, NULL, "memfile_lock_exclusive failed");
+        return NULL;
+    }
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_unlock(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_unlock(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    if (memfile_unlock(mf) < 0) {
+        napi_throw_error(env, NULL, "memfile_unlock failed");
+        return NULL;
+    }
+
+    return NULL;
+}
+
+/* =========================================================================
+ * memfile_stats(handle: external) => { fileSize, allocated, freeListHead }
+ * ========================================================================= */
+
+static napi_value n_memfile_stats(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+
+    napi_value result;
+    NAPI_CALL(napi_create_object(env, &result));
+
+    napi_value v;
+    NAPI_CALL(napi_create_bigint_uint64(env, mf->header->file_size, &v));
+    NAPI_CALL(napi_set_named_property(env, result, "fileSize", v));
+
+    NAPI_CALL(napi_create_bigint_uint64(env, mf->header->allocated, &v));
+    NAPI_CALL(napi_set_named_property(env, result, "allocated", v));
+
+    NAPI_CALL(napi_create_bigint_uint64(env, mf->header->free_list_head, &v));
+    NAPI_CALL(napi_set_named_property(env, result, "freeListHead", v));
+
+    return result;
+}
+
+/* =========================================================================
+ * memfile_refresh(handle: external) => void
+ * ========================================================================= */
+
+static napi_value n_memfile_refresh(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    memfile_t *mf = unwrap_mf(env, argv[0]);
+    if (memfile_refresh(mf) < 0) {
+        napi_throw_error(env, NULL, "memfile_refresh failed");
+        return NULL;
+    }
+
+    return NULL;
+}
+
+/* =========================================================================
+ * Module init
+ * ========================================================================= */
+
+#define EXPORT_FN(name, fn) do {                                               \
+    napi_value _fn;                                                            \
+    napi_create_function(env, name, NAPI_AUTO_LENGTH, fn, NULL, &_fn);         \
+    napi_set_named_property(env, exports, name, _fn);                          \
+} while(0)
+
+NAPI_MODULE_INIT(/* napi_env env, napi_value exports */) {
+    EXPORT_FN("open",          n_memfile_open);
+    EXPORT_FN("close",         n_memfile_close);
+    EXPORT_FN("sync",          n_memfile_sync);
+    EXPORT_FN("alloc",         n_memfile_alloc);
+    EXPORT_FN("free",          n_memfile_free);
+    EXPORT_FN("coalesce",      n_memfile_coalesce);
+    EXPORT_FN("read",          n_memfile_read);
+    EXPORT_FN("write",         n_memfile_write);
+    EXPORT_FN("lockShared",    n_memfile_lock_shared);
+    EXPORT_FN("lockExclusive", n_memfile_lock_exclusive);
+    EXPORT_FN("unlock",        n_memfile_unlock);
+    EXPORT_FN("stats",         n_memfile_stats);
+    EXPORT_FN("refresh",       n_memfile_refresh);
+    return exports;
+}

package/native/memoryfile.c

@@ -0,0 +1,343 @@
+/*
+ * Memory File - mmap-based arena allocator
+ *
+ * Originally from biscuit/server; adapted for MCP memory server.
+ * Added: flock-based concurrency, read/write helpers.
+ */
+
+#include "memoryfile.h"
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+
+/* =========================================================================
+ * Pointer conversion
+ * ========================================================================= */
+
+void *memfile_ptr(memfile_t *mf, u64 offset) {
+    if (offset == 0 || offset >= mf->mmap_size) return NULL;
+    return (u8*)mf->mmap_base + offset;
+}
+
+/* =========================================================================
+ * Direct read/write at offset
+ * ========================================================================= */
+
+int memfile_read(memfile_t *mf, u64 offset, void *buf, u64 len) {
+    if (offset + len > mf->mmap_size) return -1;
+    void *src = memfile_ptr(mf, offset);
+    if (!src) return -1;
+    memcpy(buf, src, len);
+    return 0;
+}
+
+int memfile_write(memfile_t *mf, u64 offset, const void *buf, u64 len) {
+    if (offset + len > mf->mmap_size) return -1;
+    void *dst = memfile_ptr(mf, offset);
+    if (!dst) return -1;
+    memcpy(dst, buf, len);
+    return 0;
+}
+
+/* =========================================================================
+ * File growth via mremap
+ * ========================================================================= */
+
+static int memfile_remap(memfile_t *mf, size_t new_size) {
+    if (ftruncate(mf->fd, new_size) < 0) {
+        return -1;
+    }
+
+    void *new_base = mremap(mf->mmap_base, mf->mmap_size, new_size, MREMAP_MAYMOVE);
+    if (new_base == MAP_FAILED) {
+        return -1;
+    }
+
+    mf->mmap_base = new_base;
+    mf->mmap_size = new_size;
+    mf->header = (memfile_header_t*)new_base;
+    mf->header->file_size = new_size;
+
+    return 0;
+}
+
+static int memfile_ensure_space(memfile_t *mf, u64 needed) {
+    if (mf->header->allocated + needed <= mf->header->file_size) {
+        return 0;
+    }
+
+    size_t new_size = mf->mmap_size * 2;
+    if (new_size < mf->header->allocated + needed) {
+        new_size = mf->header->allocated + needed + 4096;
+    }
+
+    return memfile_remap(mf, new_size);
+}
+
+/* =========================================================================
+ * Allocation
+ * ========================================================================= */
+
+u64 memfile_alloc(memfile_t *mf, u64 size) {
+    u64 total_size = size + sizeof(memfile_alloc_t);
+
+    /* Align to 8 bytes */
+    total_size = (total_size + 7) & ~7ULL;
+
+    /* Try free list first (first-fit) */
+    u64 prev_offset = 0;
+    u64 free_offset = mf->header->free_list_head;
+
+    while (free_offset != 0) {
+        memfile_free_t *free_block = (memfile_free_t*)memfile_ptr(mf, free_offset);
+
+        if (free_block->size >= total_size) {
+            u64 remaining = free_block->size - total_size;
+
+            if (remaining >= sizeof(memfile_free_t) + 8) {
+                /* Split the block */
+                u64 new_free_offset = free_offset + total_size;
+                memfile_free_t *new_free = (memfile_free_t*)memfile_ptr(mf, new_free_offset);
+                new_free->size = remaining;
+                new_free->next = free_block->next;
+
+                if (prev_offset == 0) {
+                    mf->header->free_list_head = new_free_offset;
+                } else {
+                    memfile_free_t *prev = (memfile_free_t*)memfile_ptr(mf, prev_offset);
+                    prev->next = new_free_offset;
+                }
+            } else {
+                /* Use entire block (avoid tiny leftover) */
+                total_size = free_block->size;
+
+                if (prev_offset == 0) {
+                    mf->header->free_list_head = free_block->next;
+                } else {
+                    memfile_free_t *prev = (memfile_free_t*)memfile_ptr(mf, prev_offset);
+                    prev->next = free_block->next;
+                }
+            }
+
+            memfile_alloc_t *alloc = (memfile_alloc_t*)memfile_ptr(mf, free_offset);
+            alloc->size = total_size;
+
+            return free_offset + sizeof(memfile_alloc_t);
+        }
+
+        prev_offset = free_offset;
+        free_offset = free_block->next;
+    }
+
+    /* No suitable free block - bump allocate from end */
+    if (memfile_ensure_space(mf, total_size) < 0) {
+        return 0;
+    }
+
+    u64 offset = mf->header->allocated;
+    memfile_alloc_t *alloc = (memfile_alloc_t*)memfile_ptr(mf, offset);
+    alloc->size = total_size;
+    mf->header->allocated += total_size;
+
+    return offset + sizeof(memfile_alloc_t);
+}
+
+void memfile_free(memfile_t *mf, u64 offset) {
+    if (offset == 0) return;
+
+    u64 alloc_offset = offset - sizeof(memfile_alloc_t);
+    memfile_alloc_t *alloc = (memfile_alloc_t*)memfile_ptr(mf, alloc_offset);
+
+    /* Free list node lives in the freed space itself */
+    memfile_free_t *free_block = (memfile_free_t*)alloc;
+    free_block->size = alloc->size;
+    free_block->next = mf->header->free_list_head;
+
+    mf->header->free_list_head = alloc_offset;
+}
+
+/* =========================================================================
+ * Coalescing - merge adjacent free blocks
+ * ========================================================================= */
+
+void memfile_coalesce(memfile_t *mf) {
+    if (mf->header->free_list_head == 0) return;
+
+    /* Count free blocks */
+    u32 free_count = 0;
+    u64 offset = mf->header->free_list_head;
+    while (offset != 0) {
+        free_count++;
+        memfile_free_t *block = (memfile_free_t*)memfile_ptr(mf, offset);
+        offset = block->next;
+    }
+
+    if (free_count < 2) return;
+
+    /* Collect into temp array */
+    struct { u64 offset; u64 size; } *blocks = malloc(free_count * sizeof(*blocks));
+
+    offset = mf->header->free_list_head;
+    for (u32 i = 0; i < free_count; i++) {
+        memfile_free_t *block = (memfile_free_t*)memfile_ptr(mf, offset);
+        blocks[i].offset = offset;
+        blocks[i].size = block->size;
+        offset = block->next;
+    }
+
+    /* Sort by offset (insertion sort - fine for expected small N) */
+    for (u32 i = 1; i < free_count; i++) {
+        u64 key_off = blocks[i].offset;
+        u64 key_size = blocks[i].size;
+        int j = i - 1;
+        while (j >= 0 && blocks[j].offset > key_off) {
+            blocks[j + 1] = blocks[j];
+            j--;
+        }
+        blocks[j + 1].offset = key_off;
+        blocks[j + 1].size = key_size;
+    }
+
+    /* Merge adjacent */
+    u32 write_idx = 0;
+    for (u32 i = 0; i < free_count; i++) {
+        if (write_idx > 0 &&
+            blocks[write_idx - 1].offset + blocks[write_idx - 1].size == blocks[i].offset) {
+            blocks[write_idx - 1].size += blocks[i].size;
+        } else {
+            if (write_idx != i) {
+                blocks[write_idx] = blocks[i];
+            }
+            write_idx++;
+        }
+    }
+
+    /* Rebuild free list in offset order */
+    mf->header->free_list_head = blocks[0].offset;
+    for (u32 i = 0; i < write_idx; i++) {
+        memfile_free_t *block = (memfile_free_t*)memfile_ptr(mf, blocks[i].offset);
+        block->size = blocks[i].size;
+        block->next = (i + 1 < write_idx) ? blocks[i + 1].offset : 0;
+    }
+
+    free(blocks);
+}
+
+/* =========================================================================
+ * Refresh mapping after another process grows the file
+ * ========================================================================= */
+
+int memfile_refresh(memfile_t *mf) {
+    struct stat st;
+    if (fstat(mf->fd, &st) < 0) return -1;
+
+    size_t actual_size = (size_t)st.st_size;
+    if (actual_size <= mf->mmap_size) return 0;  /* No growth detected */
+
+    /* File grew — remap to cover the new size */
+    void *new_base = mremap(mf->mmap_base, mf->mmap_size, actual_size, MREMAP_MAYMOVE);
+    if (new_base == MAP_FAILED) return -1;
+
+    mf->mmap_base = new_base;
+    mf->mmap_size = actual_size;
+    mf->header = (memfile_header_t*)new_base;
+
+    return 0;
+}
+
+/* =========================================================================
+ * Concurrency - POSIX flock
+ * ========================================================================= */
+
+int memfile_lock_shared(memfile_t *mf) {
+    return flock(mf->fd, LOCK_SH);
+}
+
+int memfile_lock_exclusive(memfile_t *mf) {
+    return flock(mf->fd, LOCK_EX);
+}
+
+int memfile_unlock(memfile_t *mf) {
+    return flock(mf->fd, LOCK_UN);
+}
+
+/* =========================================================================
+ * Open/close
+ * ========================================================================= */
+
+memfile_t *memfile_open(const char *path, size_t initial_size) {
+    memfile_t *mf = calloc(1, sizeof(memfile_t));
+    if (!mf) return NULL;
+    mf->path = strdup(path);
+
+    struct stat st;
+    int exists = (stat(path, &st) == 0 && st.st_size > 0);
+
+    if (exists) {
+        mf->fd = open(path, O_RDWR);
+        if (mf->fd < 0) goto fail;
+
+        mf->mmap_size = st.st_size;
+        mf->mmap_base = mmap(NULL, mf->mmap_size, PROT_READ | PROT_WRITE,
+                             MAP_SHARED, mf->fd, 0);
+        if (mf->mmap_base == MAP_FAILED) goto fail_fd;
+
+        mf->header = (memfile_header_t*)mf->mmap_base;
+
+        if (mf->header->magic != MEMFILE_MAGIC) {
+            munmap(mf->mmap_base, mf->mmap_size);
+            goto fail_fd;
+        }
+    } else {
+        mf->fd = open(path, O_RDWR | O_CREAT, 0644);
+        if (mf->fd < 0) goto fail;
+
+        if (initial_size < sizeof(memfile_header_t) + 64) {
+            initial_size = 4096;
+        }
+
+        if (ftruncate(mf->fd, initial_size) < 0) goto fail_fd;
+
+        mf->mmap_size = initial_size;
+        mf->mmap_base = mmap(NULL, mf->mmap_size, PROT_READ | PROT_WRITE,
+                             MAP_SHARED, mf->fd, 0);
+        if (mf->mmap_base == MAP_FAILED) {
+            unlink(path);
+            goto fail_fd;
+        }
+
+        mf->header = (memfile_header_t*)mf->mmap_base;
+        mf->header->magic = MEMFILE_MAGIC;
+        mf->header->version = MEMFILE_VERSION;
+        mf->header->file_size = initial_size;
+        mf->header->allocated = sizeof(memfile_header_t);
+        mf->header->free_list_head = 0;
+    }
+
+    return mf;
+
+fail_fd:
+    close(mf->fd);
+fail:
+    free(mf->path);
+    free(mf);
+    return NULL;
+}
+
+void memfile_sync(memfile_t *mf) {
+    if (!mf || mf->closed || !mf->mmap_base) return;
+    msync(mf->mmap_base, mf->mmap_size, MS_SYNC);
+}
+
+void memfile_close(memfile_t *mf) {
+    if (!mf || mf->closed) return;
+    mf->closed = 1;
+    memfile_sync(mf);
+    munmap(mf->mmap_base, mf->mmap_size);
+    close(mf->fd);
+    free(mf->path);
+}

package/native/memoryfile.h

@@ -0,0 +1,82 @@
+/*
+ * Memory File - mmap-based arena allocator with automatic growth
+ * 
+ * The file header IS the arena struct (packed, at offset 0).
+ * All allocations return offsets, not pointers.
+ * Pointers become invalid after mremap, offsets remain valid.
+ *
+ * Originally from biscuit/server; adapted for MCP memory server.
+ */
+
+#ifndef MEMORYFILE_H
+#define MEMORYFILE_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+typedef uint8_t  u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+
+#define MEMFILE_MAGIC   0x4D454D46  /* "MEMF" */
+#define MEMFILE_VERSION 1
+
+/* File header - lives at offset 0, IS the arena */
+typedef struct __attribute__((packed)) {
+    u32 magic;
+    u32 version;
+    u64 file_size;          /* Current file size */
+    u64 allocated;          /* Bump pointer: next allocation from end */
+    u64 free_list_head;     /* Offset to first free block (0=none) */
+} memfile_header_t;
+
+/* Free block header - lives IN the free space it describes */
+typedef struct __attribute__((packed)) {
+    u64 size;               /* Size of this free block (including header) */
+    u64 next;               /* Offset to next free block (0=none) */
+} memfile_free_t;
+
+/* Allocation header - immediately before each allocated block */
+typedef struct __attribute__((packed)) {
+    u64 size;               /* Size of allocation (including this header) */
+} memfile_alloc_t;
+
+/* Handle for working with memory file */
+typedef struct {
+    int fd;
+    char *path;
+    void *mmap_base;        /* Base address of mmap */
+    size_t mmap_size;       /* Current mmap size */
+    memfile_header_t *header;  /* Points to offset 0 */
+    int closed;             /* Set after close to prevent double-free */
+} memfile_t;
+
+/* Lifecycle */
+memfile_t *memfile_open(const char *path, size_t initial_size);
+void       memfile_close(memfile_t *mf);
+void       memfile_sync(memfile_t *mf);
+
+/* Allocation - returns offset from file start (0 = failed) */
+u64  memfile_alloc(memfile_t *mf, u64 size);
+void memfile_free(memfile_t *mf, u64 offset);
+
+/* Defragmentation */
+void memfile_coalesce(memfile_t *mf);
+
+/* Direct read/write at offset */
+int memfile_read(memfile_t *mf, u64 offset, void *buf, u64 len);
+int memfile_write(memfile_t *mf, u64 offset, const void *buf, u64 len);
+
+/* Convert offset to pointer (CAUTION: invalid after alloc that triggers remap) */
+void *memfile_ptr(memfile_t *mf, u64 offset);
+
+/* Refresh mapping if the file was grown by another process */
+int memfile_refresh(memfile_t *mf);
+
+/* Concurrency - POSIX flock on the underlying fd */
+int memfile_lock_shared(memfile_t *mf);
+int memfile_lock_exclusive(memfile_t *mf);
+int memfile_unlock(memfile_t *mf);
+
+#endif /* MEMORYFILE_H */

package/package.json

@@ -1,17 +1,20 @@
 {
   "name": "@levalicious/server-memory",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "MCP server for enabling memory for Claude through a knowledge graph",
   "license": "MIT",
   "author": "Levalicious",
   "homepage": "https://modelcontextprotocol.io",
   "bugs": "https://github.com/modelcontextprotocol/servers/issues",
   "type": "module",
+  "gypfile": true,
   "bin": {
     "mcp-server-memory": "dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "binding.gyp",
+    "native"
   ],
   "scripts": {
     "build": "node-gyp rebuild && tsc && shx chmod +x dist/*.js",