@monoes/memory 1.0.20 → 1.0.21

package/dist/sql-backend-reads.js

@@ -0,0 +1,295 @@
+/**
+ * Read-path methods for SqlBackend (get/query/search family).
+ *
+ * File-size sweep: split out of sql-backend.ts. Mixed into
+ * SqlBackend.prototype at the bottom of sql-backend.ts.
+ *
+ * @module v1/memory/sql-backend-reads
+ */
+import { cosineSimilarity } from './math-utils.js';
+/** Cap on votes/rows pulled in one go, guarding against unbounded memory use. */
+const MAX_QUERY_LIMIT = 10_000;
+export const sqlBackendReadMethods = {
+    async get(id, agentId) {
+        this.ensureInitialized();
+        const startTime = performance.now();
+        const row = this.driver?.get('SELECT memory_entries.*, emb.embedding AS _emb FROM memory_entries LEFT JOIN memory_embeddings emb ON emb.entry_id = memory_entries.id WHERE memory_entries.id = ?', [id]);
+        if (!row)
+            return null;
+        // Collaborative memory promotion — https://arxiv.org/abs/2505.18279
+        const AGENT_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
+        if (agentId && AGENT_ID_RE.test(agentId)) {
+            try {
+                this.driver?.run('INSERT OR IGNORE INTO agent_reads (entry_id, agent_id, read_at) VALUES (?, ?, ?)', [id, agentId, Date.now()]);
+                this._readCount++;
+                if (this._readCount % 1000 === 0)
+                    this.checkAndPromoteEntry(id);
+            }
+            catch {
+                /* non-critical */
+            }
+        }
+        const entry = this.rowToEntry(row);
+        this.emit('entry:retrieved', { id, duration: performance.now() - startTime });
+        return entry;
+    },
+    /**
+     * Promote an entry to 'team' once 3+ distinct agents have read it within 24h.
+     * https://arxiv.org/abs/2505.18279
+     */
+    checkAndPromoteEntry(entryId) {
+        const d = this.driver;
+        if (!d)
+            return;
+        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+        d.run('DELETE FROM agent_reads WHERE read_at <= ?', [cutoff]);
+        const row = d.get('SELECT COUNT(DISTINCT agent_id) as cnt FROM agent_reads WHERE entry_id = ? AND read_at > ?', [entryId, cutoff]);
+        if (Number(row?.cnt ?? 0) >= 3) {
+            d.run("UPDATE memory_entries SET access_level = 'team' WHERE id = ? AND access_level = 'private'", [entryId]);
+        }
+    },
+    async getByKey(namespace, key) {
+        this.ensureInitialized();
+        const startTime = performance.now();
+        const row = this.driver?.get('SELECT memory_entries.*, emb.embedding AS _emb FROM memory_entries LEFT JOIN memory_embeddings emb ON emb.entry_id = memory_entries.id WHERE memory_entries.namespace = ? AND memory_entries.key = ?', [namespace, key]);
+        if (!row)
+            return null;
+        const entry = this.rowToEntry(row);
+        this.emit('entry:retrieved', { namespace, key, duration: performance.now() - startTime });
+        return entry;
+    },
+    async query(query) {
+        this.ensureInitialized();
+        const startTime = performance.now();
+        // PKG-3: LEFT JOIN memory_embeddings once so rowToEntry can read the
+        // embedding column without an N+1 round-trip per result row.
+        let sql = 'SELECT memory_entries.*, emb.embedding AS _emb FROM memory_entries LEFT JOIN memory_embeddings emb ON emb.entry_id = memory_entries.id WHERE 1=1';
+        const params = [];
+        if (query.namespace) {
+            sql += ' AND namespace = ?';
+            params.push(query.namespace);
+        }
+        if (query.key) {
+            sql += ' AND key = ?';
+            params.push(query.key);
+        }
+        if (query.keyPrefix) {
+            sql += ' AND key LIKE ?';
+            params.push(`${query.keyPrefix}%`);
+        }
+        if (query.memoryType) {
+            sql += ' AND type = ?';
+            params.push(query.memoryType);
+        }
+        if (query.accessLevel) {
+            sql += ' AND access_level = ?';
+            params.push(query.accessLevel);
+        }
+        if (query.ownerId) {
+            sql += ' AND owner_id = ?';
+            params.push(query.ownerId);
+        }
+        if (query.createdAfter) {
+            sql += ' AND created_at >= ?';
+            params.push(query.createdAfter);
+        }
+        if (query.createdBefore) {
+            sql += ' AND created_at <= ?';
+            params.push(query.createdBefore);
+        }
+        if (query.updatedAfter) {
+            sql += ' AND updated_at >= ?';
+            params.push(query.updatedAfter);
+        }
+        if (query.updatedBefore) {
+            sql += ' AND updated_at <= ?';
+            params.push(query.updatedBefore);
+        }
+        // Bi-temporal event-time filters (arXiv:2501.13956 — Zep/Graphiti)
+        if (query.eventAfter) {
+            sql += ' AND event_at >= ?';
+            params.push(query.eventAfter);
+        }
+        if (query.eventBefore) {
+            sql += ' AND event_at <= ?';
+            params.push(query.eventBefore);
+        }
+        if (!query.includeExpired) {
+            sql += ' AND (expires_at IS NULL OR expires_at > ?)';
+            params.push(Date.now());
+        }
+        // MemoryQuery.tags is documented as "entries must have all specified tags"
+        // (types.ts). Counting distinct matches enforces that; an EXISTS(... IN ...)
+        // would be ANY-match, which is exactly the divergence that made the two old
+        // backends return different result sets for the same call.
+        if (query.tags && query.tags.length > 0) {
+            this.validateTags(query.tags);
+            const placeholders = query.tags.map(() => '?').join(', ');
+            sql += ` AND (
+        SELECT COUNT(DISTINCT t.tag) FROM memory_entry_tags t
+        WHERE t.entry_id = memory_entries.id AND t.tag IN (${placeholders})
+      ) = ?`;
+            params.push(...query.tags, query.tags.length);
+        }
+        const colMap = {
+            createdAt: 'created_at',
+            updatedAt: 'updated_at',
+            lastAccessedAt: 'last_accessed_at',
+            accessCount: 'access_count',
+            key: 'key',
+        };
+        const orderCol = query.sortField && query.sortField !== 'score' && colMap[query.sortField]
+            ? colMap[query.sortField]
+            : 'created_at';
+        const orderDir = query.sortDirection === 'asc' ? 'ASC' : 'DESC';
+        sql += ` ORDER BY ${orderCol} ${orderDir} LIMIT ?`;
+        const effectiveLimit = Math.min(Math.max(1, query.limit ?? MAX_QUERY_LIMIT), MAX_QUERY_LIMIT);
+        params.push(effectiveLimit);
+        if (query.offset) {
+            sql += ' OFFSET ?';
+            params.push(query.offset);
+        }
+        const rows = this.driver?.all(sql, params) ?? [];
+        const results = rows.map((r) => this.rowToEntry(r));
+        const duration = performance.now() - startTime;
+        this.stats.queryCount++;
+        this.stats.totalQueryTime += duration;
+        this.emit('query:executed', { query, resultCount: results.length, duration });
+        return results;
+    },
+    /**
+     * Semantic search. Below MONOMIND_HNSW_THRESHOLD active embedded entries
+     * (default 5000), brute-force cosine over stored embeddings — namespace-
+     * and TTL-filtered in SQL — stays cheaper (a few tens of ms at second-brain
+     * scale). Above it, getAnnIndex() builds (or loads a persisted) HNSW graph
+     * and this searches that instead; results are still namespace/threshold
+     * filtered post-search to match the brute-force semantics exactly.
+     */
+    async search(embedding, options) {
+        this.ensureInitialized();
+        const ns = options.filters?.namespace;
+        const ann = await this.getAnnIndex(embedding.length).catch(() => null);
+        if (ann) {
+            const applyFilters = (raw) => {
+                const out = [];
+                for (const r of raw) {
+                    const entry = ann.entries.get(r.id);
+                    if (!entry)
+                        continue;
+                    if (ns && entry.namespace !== ns)
+                        continue;
+                    const score = 1 - r.distance;
+                    if (options.threshold !== undefined && score < options.threshold)
+                        continue;
+                    out.push({ entry, score, distance: r.distance });
+                    if (out.length >= options.k)
+                        break;
+                }
+                return out;
+            };
+            const overFetch = Math.max(options.k * 4, options.k + 20);
+            let results = applyFilters(await ann.index.search(embedding, Math.min(overFetch, ann.entries.size)));
+            // A fixed over-fetch multiple assumes matches are spread roughly evenly
+            // through the globally-nearest candidates. A namespace filter can
+            // violate that — a namespace's true nearest neighbors may simply not be
+            // among the top `overFetch` globally, understating recall (or
+            // returning nothing) even though matches exist elsewhere in the graph.
+            // There's no way to know how deep those matches rank without searching
+            // further, so the only correct fallback is to widen all the way to the
+            // full index rather than guessing a bigger-but-still-arbitrary number.
+            if (ns && results.length < options.k && ann.entries.size > overFetch) {
+                results = applyFilters(await ann.index.search(embedding, ann.entries.size));
+            }
+            results.sort((a, b) => b.score - a.score);
+            return results;
+        }
+        const rows = this.driver?.iterate(`SELECT e.*, emb.embedding AS _emb
+         FROM memory_entries e
+         JOIN memory_embeddings emb ON emb.entry_id = e.id
+        WHERE (e.expires_at IS NULL OR e.expires_at = 0 OR e.expires_at > ?)
+        ${ns ? 'AND e.namespace = ?' : ''}`, ns ? [Date.now(), ns] : [Date.now()]) ?? [];
+        const results = [];
+        for (const row of rows) {
+            const buf = row._emb;
+            if (!buf || buf.byteLength % 4 !== 0)
+                continue;
+            const vec = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+            if (vec.length !== embedding.length)
+                continue;
+            const similarity = cosineSimilarity(embedding, vec);
+            if (options.threshold !== undefined && similarity < options.threshold)
+                continue;
+            // PKG-3: row already carries _emb from the JOIN; rowToEntry reads it
+            // directly instead of re-querying memory_embeddings per row.
+            results.push({ entry: this.rowToEntry(row), score: similarity, distance: 1 - similarity });
+        }
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, options.k);
+    },
+    /**
+     * FTS5-accelerated keyword search (Issue #66).
+     *
+     * When the FTS5 index is available, text matching runs inside SQLite via
+     * `MATCH` — orders of magnitude faster than loading 50k rows into JS. When
+     * FTS5 is unavailable (e.g. sql.js WASM compiled without the extension) the
+     * method returns `null` so the caller can fall back to JS-side matching.
+     *
+     * `queryText` is the raw user query; it is FTS5-tokenized automatically.
+     * Special characters are escaped to prevent FTS5 syntax errors.
+     */
+    async keywordSearch(queryText, options = {}) {
+        this.ensureInitialized();
+        if (!this._fts5Available)
+            return null;
+        const limit = Math.min(Math.max(1, options.limit ?? 50), MAX_QUERY_LIMIT);
+        // Escape FTS5 special characters and build a query where every token must
+        // appear (implicit AND). Tokens shorter than 2 chars are dropped — they
+        // produce noise and FTS5 may reject single-char tokens depending on the
+        // tokenizer configuration.
+        const tokens = queryText
+            .replace(/[":*^~(){}[\]\\]/g, ' ')
+            .split(/\s+/)
+            .filter((t) => t.length > 1)
+            .map((t) => `"${t}"`);
+        if (!tokens.length)
+            return null;
+        const d = this.driver;
+        const ns = options.namespace;
+        const search = (match) => d.all(`SELECT f.entry_id, f.key, f.content, e.namespace, rank
+           FROM memory_entries_fts f
+           JOIN memory_entries e ON e.id = f.entry_id
+          WHERE memory_entries_fts MATCH ?
+            AND (e.expires_at IS NULL OR e.expires_at = 0 OR e.expires_at > ?)
+            ${ns ? 'AND e.namespace = ?' : ''}
+          ORDER BY rank
+          LIMIT ?`, ns ? [match, Date.now(), ns, limit] : [match, Date.now(), limit]);
+        // Preserve the precise all-terms query first. Natural-language queries
+        // often contain context words absent from the target document, though; a
+        // zero-result strict search should still surface the best lexical leads.
+        let rows = search(tokens.join(' '));
+        if (rows.length === 0 && tokens.length > 1)
+            rows = search(tokens.join(' OR '));
+        return rows.map((r) => ({
+            id: String(r.entry_id),
+            key: String(r.key),
+            content: String(r.content),
+            namespace: String(r.namespace),
+            // FTS5 rank is negative (lower = better match); invert to a 0–1 score.
+            rank: Number(r.rank),
+        }));
+    },
+    async count(namespace) {
+        this.ensureInitialized();
+        const row = namespace
+            ? this.driver?.get('SELECT COUNT(*) as count FROM memory_entries WHERE namespace = ?', [
+                namespace,
+            ])
+            : this.driver?.get('SELECT COUNT(*) as count FROM memory_entries');
+        return Number(row?.count ?? 0);
+    },
+    async listNamespaces() {
+        this.ensureInitialized();
+        return (this.driver?.all('SELECT DISTINCT namespace FROM memory_entries') ?? []).map((r) => String(r.namespace));
+    },
+};
+//# sourceMappingURL=sql-backend-reads.js.map

package/dist/sql-backend-reads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-backend-reads.js","sourceRoot":"","sources":["../src/sql-backend-reads.ts"],"names":[],"mappings":"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"}

package/dist/sql-backend-writes.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Write-path methods for SqlBackend (store/update/delete family).
+ *
+ * File-size sweep: split out of sql-backend.ts. Mixed into
+ * SqlBackend.prototype at the bottom of sql-backend.ts.
+ *
+ * @module v1/memory/sql-backend-writes
+ */
+import type { SqlBackend } from './sql-backend.js';
+import type { MemoryEntry, MemoryEntryUpdate } from './types.js';
+export declare const sqlBackendWriteMethods: {
+    store(this: SqlBackend, entry: MemoryEntry): Promise<void>;
+    /**
+     * Compare-and-swap update: writes ONLY if the row's stored `version` still
+     * equals `expectedVersion`. The check and the write are one SQL statement
+     * (`UPDATE ... WHERE id = ? AND version = ?`), so SQLite's own single-
+     * statement atomicity — the same guarantee `store()`'s INSERT OR REPLACE
+     * already relies on — makes this a real compare-and-swap against every
+     * other writer, in this process or another, with no bridge-level lock.
+     *
+     * Exists for memory-KG review finding K5: a getByKey() + store() read-
+     * merge-write (what every caller did before this) leaves a window in which
+     * two concurrent callers each merge onto the same row and the second
+     * store() silently overwrites the first's contribution. A caller that reads
+     * a row's version, merges onto it, and writes back through here instead
+     * gets `false` when its merge has gone stale, rather than winning a race it
+     * did not know it was running.
+     *
+     * Only the columns a claim-ledger merge (memory-kg.ts) actually changes are
+     * updated; embeddings are left untouched, matching storeSync's own rule that
+     * a revision without a new vector keeps the one it had.
+     *
+     * @returns true when the write landed, false when the row's version had
+     * already moved (or the row no longer exists) — the caller must re-read and
+     * re-merge, never assume the write happened.
+     */
+    storeIfVersion(this: SqlBackend, entry: MemoryEntry, expectedVersion: number): Promise<boolean>;
+    /**
+     * Compare-and-swap create: the create-side counterpart to `storeIfVersion`.
+     * Inserts ONLY if no row already occupies this id or this namespace/key pair
+     * (the schema's `UNIQUE(namespace, key)` index — see sql-schema.ts).
+     *
+     * Exists for the same K5 race on the CREATE side: two concurrent callers
+     * asserting the same new KG entity mint the same deterministic `key` but a
+     * different random row `id` (see memory-bridge.ts's upsert). Plain `store()`
+     * (INSERT OR REPLACE) resolves that collision by silently deleting whichever
+     * row landed first — exactly the lost update K5 describes, just on first
+     * write instead of a merge. `INSERT OR IGNORE` instead leaves the first row
+     * untouched and reports that it did, so the loser re-reads and merges onto
+     * it instead of clobbering it.
+     *
+     * @returns true when this call created the row, false when one already
+     * existed — the caller must re-read and merge rather than assume it won.
+     */
+    storeIfAbsent(this: SqlBackend, entry: MemoryEntry): Promise<boolean>;
+    /** Synchronous store body, shared by store() and bulkInsert(). */
+    storeSync(this: SqlBackend, entry: MemoryEntry): void;
+    bulkInsert(this: SqlBackend, entries: MemoryEntry[]): Promise<void>;
+    update(this: SqlBackend, id: string, update: MemoryEntryUpdate): Promise<MemoryEntry | null>;
+    delete(this: SqlBackend, id: string): Promise<boolean>;
+    bulkDelete(this: SqlBackend, ids: string[]): Promise<number>;
+    clearNamespace(this: SqlBackend, namespace: string): Promise<number>;
+};
+//# sourceMappingURL=sql-backend-writes.d.ts.map

package/dist/sql-backend-writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-backend-writes.d.ts","sourceRoot":"","sources":["../src/sql-backend-writes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEjE,eAAO,MAAM,sBAAsB;IAC3B,KAAK,OAAO,UAAU,SAAS,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAahE;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,cAAc,OACZ,UAAU,SACT,WAAW,mBACD,MAAM,GACtB,OAAO,CAAC,OAAO,CAAC;IAgCnB;;;;;;;;;;;;;;;;OAgBG;IACG,aAAa,OAAO,UAAU,SAAS,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC;IAqD3E,kEAAkE;IAClE,SAAS,OAAO,UAAU,SAAS,WAAW,GAAG,IAAI;IAwE/C,UAAU,OAAO,UAAU,WAAW,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IASnE,MAAM,OACJ,UAAU,MACZ,MAAM,UACF,iBAAiB,GACxB,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAoBxB,MAAM,OAAO,UAAU,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAetD,UAAU,OAAO,UAAU,OAAO,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAgB5D,cAAc,OAAO,UAAU,aAAa,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAgB3E,CAAC"}

package/dist/sql-backend-writes.js

@@ -0,0 +1,270 @@
+/**
+ * Write-path methods for SqlBackend (store/update/delete family).
+ *
+ * File-size sweep: split out of sql-backend.ts. Mixed into
+ * SqlBackend.prototype at the bottom of sql-backend.ts.
+ *
+ * @module v1/memory/sql-backend-writes
+ */
+export const sqlBackendWriteMethods = {
+    async store(entry) {
+        this.ensureInitialized();
+        const startTime = performance.now();
+        this.validateTags(entry.tags);
+        this.driver?.transaction(() => this.storeSync(entry));
+        const duration = performance.now() - startTime;
+        this.stats.writeCount++;
+        this.stats.totalWriteTime += duration;
+        this.emit('entry:stored', { id: entry.id, duration });
+    },
+    /**
+     * Compare-and-swap update: writes ONLY if the row's stored `version` still
+     * equals `expectedVersion`. The check and the write are one SQL statement
+     * (`UPDATE ... WHERE id = ? AND version = ?`), so SQLite's own single-
+     * statement atomicity — the same guarantee `store()`'s INSERT OR REPLACE
+     * already relies on — makes this a real compare-and-swap against every
+     * other writer, in this process or another, with no bridge-level lock.
+     *
+     * Exists for memory-KG review finding K5: a getByKey() + store() read-
+     * merge-write (what every caller did before this) leaves a window in which
+     * two concurrent callers each merge onto the same row and the second
+     * store() silently overwrites the first's contribution. A caller that reads
+     * a row's version, merges onto it, and writes back through here instead
+     * gets `false` when its merge has gone stale, rather than winning a race it
+     * did not know it was running.
+     *
+     * Only the columns a claim-ledger merge (memory-kg.ts) actually changes are
+     * updated; embeddings are left untouched, matching storeSync's own rule that
+     * a revision without a new vector keeps the one it had.
+     *
+     * @returns true when the write landed, false when the row's version had
+     * already moved (or the row no longer exists) — the caller must re-read and
+     * re-merge, never assume the write happened.
+     */
+    async storeIfVersion(entry, expectedVersion) {
+        this.ensureInitialized();
+        this.validateTags(entry.tags);
+        const d = this.driver;
+        return d.transaction(() => {
+            const changes = d.run(`UPDATE memory_entries
+           SET content = ?, tags = ?, metadata = ?, updated_at = ?, version = ?, "references" = ?
+         WHERE id = ? AND version = ?`, [
+                entry.content,
+                JSON.stringify(entry.tags),
+                JSON.stringify(entry.metadata),
+                entry.updatedAt,
+                entry.version,
+                JSON.stringify(entry.references),
+                entry.id,
+                expectedVersion,
+            ]);
+            if (changes === 0)
+                return false;
+            d.run('DELETE FROM memory_entry_tags WHERE entry_id = ?', [entry.id]);
+            for (const tag of entry.tags) {
+                d.run('INSERT OR IGNORE INTO memory_entry_tags (entry_id, tag) VALUES (?, ?)', [
+                    entry.id,
+                    tag,
+                ]);
+            }
+            return true;
+        });
+    },
+    /**
+     * Compare-and-swap create: the create-side counterpart to `storeIfVersion`.
+     * Inserts ONLY if no row already occupies this id or this namespace/key pair
+     * (the schema's `UNIQUE(namespace, key)` index — see sql-schema.ts).
+     *
+     * Exists for the same K5 race on the CREATE side: two concurrent callers
+     * asserting the same new KG entity mint the same deterministic `key` but a
+     * different random row `id` (see memory-bridge.ts's upsert). Plain `store()`
+     * (INSERT OR REPLACE) resolves that collision by silently deleting whichever
+     * row landed first — exactly the lost update K5 describes, just on first
+     * write instead of a merge. `INSERT OR IGNORE` instead leaves the first row
+     * untouched and reports that it did, so the loser re-reads and merges onto
+     * it instead of clobbering it.
+     *
+     * @returns true when this call created the row, false when one already
+     * existed — the caller must re-read and merge rather than assume it won.
+     */
+    async storeIfAbsent(entry) {
+        this.ensureInitialized();
+        this.validateTags(entry.tags);
+        const d = this.driver;
+        return d.transaction(() => {
+            const changes = d.run(`INSERT OR IGNORE INTO memory_entries (
+           id, key, content, type, namespace, tags, metadata, owner_id, access_level,
+           created_at, updated_at, expires_at, event_at, version, "references",
+           access_count, last_accessed_at
+         ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`, [
+                entry.id,
+                entry.key,
+                entry.content,
+                entry.type,
+                entry.namespace,
+                JSON.stringify(entry.tags),
+                JSON.stringify(entry.metadata),
+                entry.ownerId || null,
+                entry.accessLevel,
+                entry.createdAt,
+                entry.updatedAt,
+                entry.expiresAt || null,
+                entry.eventAt ?? null,
+                entry.version,
+                JSON.stringify(entry.references),
+                entry.accessCount,
+                entry.lastAccessedAt,
+            ]);
+            if (changes === 0)
+                return false;
+            for (const tag of entry.tags) {
+                d.run('INSERT OR IGNORE INTO memory_entry_tags (entry_id, tag) VALUES (?, ?)', [
+                    entry.id,
+                    tag,
+                ]);
+            }
+            if (entry.embedding && entry.embedding.byteLength > 0) {
+                const bytes = Buffer.from(entry.embedding.buffer, entry.embedding.byteOffset, entry.embedding.byteLength);
+                d.run('INSERT OR REPLACE INTO memory_embeddings (entry_id, embedding) VALUES (?, ?)', [
+                    entry.id,
+                    bytes,
+                ]);
+            }
+            return true;
+        });
+    },
+    /** Synchronous store body, shared by store() and bulkInsert(). */
+    storeSync(entry) {
+        const d = this.driver;
+        // Read any existing embedding BEFORE INSERT OR REPLACE fires the CASCADE
+        // that would delete it — an entry updated without a vector must keep the
+        // one it already had.
+        let embeddingToStore = entry.embedding;
+        if (!embeddingToStore) {
+            const existing = d.get('SELECT embedding FROM memory_embeddings WHERE entry_id = ?', [
+                entry.id,
+            ]);
+            const buf = existing?.embedding;
+            if (buf && buf.byteLength > 0) {
+                embeddingToStore = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+            }
+        }
+        d.run(`INSERT OR REPLACE INTO memory_entries (
+         id, key, content, type, namespace, tags, metadata, owner_id, access_level,
+         created_at, updated_at, expires_at, event_at, version, "references",
+         access_count, last_accessed_at
+       ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`, [
+            entry.id,
+            entry.key,
+            entry.content,
+            entry.type,
+            entry.namespace,
+            JSON.stringify(entry.tags),
+            JSON.stringify(entry.metadata),
+            entry.ownerId || null,
+            entry.accessLevel,
+            entry.createdAt,
+            entry.updatedAt,
+            entry.expiresAt || null,
+            entry.eventAt ?? null,
+            entry.version,
+            JSON.stringify(entry.references),
+            entry.accessCount,
+            entry.lastAccessedAt,
+        ]);
+        d.run('DELETE FROM memory_entry_tags WHERE entry_id = ?', [entry.id]);
+        for (const tag of entry.tags) {
+            d.run('INSERT OR IGNORE INTO memory_entry_tags (entry_id, tag) VALUES (?, ?)', [
+                entry.id,
+                tag,
+            ]);
+        }
+        if (embeddingToStore) {
+            // Slice by byteOffset/byteLength: for copies under Node's 4KB pooling
+            // threshold, `.buffer` refers to the entire shared pool, so writing it
+            // whole silently stores unrelated memory.
+            const bytes = Buffer.from(embeddingToStore.buffer, embeddingToStore.byteOffset, embeddingToStore.byteLength);
+            d.run('INSERT OR REPLACE INTO memory_embeddings (entry_id, embedding) VALUES (?, ?)', [
+                entry.id,
+                bytes,
+            ]);
+        }
+    },
+    async bulkInsert(entries) {
+        this.ensureInitialized();
+        for (const e of entries)
+            this.validateTags(e.tags);
+        this.driver?.transaction(() => {
+            for (const entry of entries)
+                this.storeSync(entry);
+        });
+        this.emit('bulk:inserted', { count: entries.length });
+    },
+    async update(id, update) {
+        this.ensureInitialized();
+        const entry = await this.get(id);
+        if (!entry)
+            return null;
+        if (update.content !== undefined)
+            entry.content = update.content;
+        if (update.tags !== undefined)
+            entry.tags = update.tags;
+        if (update.metadata !== undefined)
+            entry.metadata = { ...entry.metadata, ...update.metadata };
+        if (update.accessLevel !== undefined)
+            entry.accessLevel = update.accessLevel;
+        if (update.expiresAt !== undefined)
+            entry.expiresAt = update.expiresAt;
+        if (update.references !== undefined)
+            entry.references = update.references;
+        entry.updatedAt = Date.now();
+        entry.version++;
+        await this.store(entry);
+        this.emit('entry:updated', { id });
+        return entry;
+    },
+    async delete(id) {
+        this.ensureInitialized();
+        const d = this.driver;
+        // Explicit tag cleanup as well as the CASCADE — belt and braces, since FK
+        // enforcement is a pragma that not every driver honours.
+        d.run('DELETE FROM memory_entry_tags WHERE entry_id = ?', [id]);
+        d.run('DELETE FROM memory_embeddings WHERE entry_id = ?', [id]);
+        const changes = d.run('DELETE FROM memory_entries WHERE id = ?', [id]);
+        if (changes > 0) {
+            this.emit('entry:deleted', { id });
+            return true;
+        }
+        return false;
+    },
+    async bulkDelete(ids) {
+        this.ensureInitialized();
+        const d = this.driver;
+        const count = d.transaction(() => {
+            let deleted = 0;
+            for (const id of ids) {
+                d.run('DELETE FROM memory_entry_tags WHERE entry_id = ?', [id]);
+                d.run('DELETE FROM memory_embeddings WHERE entry_id = ?', [id]);
+                if (d.run('DELETE FROM memory_entries WHERE id = ?', [id]) > 0)
+                    deleted++;
+            }
+            return deleted;
+        });
+        this.emit('bulk:deleted', { count });
+        return count;
+    },
+    async clearNamespace(namespace) {
+        this.ensureInitialized();
+        const d = this.driver;
+        const count = d.transaction(() => {
+            d.run(`DELETE FROM memory_entry_tags
+          WHERE entry_id IN (SELECT id FROM memory_entries WHERE namespace = ?)`, [namespace]);
+            const changes = d.run('DELETE FROM memory_entries WHERE namespace = ?', [namespace]);
+            d.run('DELETE FROM memory_embeddings WHERE entry_id NOT IN (SELECT id FROM memory_entries)');
+            return changes;
+        });
+        this.emit('namespace:cleared', { namespace, count });
+        return count;
+    },
+};
+//# sourceMappingURL=sql-backend-writes.js.map