mnemocyte 0.1.2 → 0.1.3

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { drizzle } from "drizzle-orm/postgres-js";
 import postgres from "postgres";
-import { and, desc, eq, gt, inArray, isNotNull, isNull, lt, or, sql } from "drizzle-orm";
+import { and, count, countDistinct, desc, eq, gt, inArray, isNotNull, isNull, lt, or, sql } from "drizzle-orm";
 import { customType, index, integer, jsonb, pgTable, real, text, timestamp } from "drizzle-orm/pg-core";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -54,7 +54,11 @@ const memoriesTable = pgTable("mnemocyte_memories", {
 	accessCount: integer("access_count").notNull().default(0),
 	createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
 	updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [index("mnemocyte_memories_entity_idx").on(table.entityId), index("mnemocyte_memories_entity_type_idx").on(table.entityId, table.type)]);
+}, (table) => [
+	index("mnemocyte_memories_entity_idx").on(table.entityId),
+	index("mnemocyte_memories_entity_type_idx").on(table.entityId, table.type),
+	index("mnemocyte_memories_embedding_hnsw_idx").using("hnsw", table.embedding.op("vector_cosine_ops"))
+]);
 const eventsTable = pgTable("mnemocyte_events", {
 	id: text("id").primaryKey(),
 	entityId: text("entity_id").notNull(),
@@ -64,11 +68,22 @@ const eventsTable = pgTable("mnemocyte_events", {
 }, (table) => [index("mnemocyte_events_entity_time_idx").on(table.entityId, table.timestamp)]);
 //#endregion
 //#region src/db/index.ts
+function parseSslFromUrl(url) {
+	const mode = url.searchParams.get("sslmode");
+	if (!mode || mode === "disable") return void 0;
+	if (mode === "require" || mode === "prefer" || mode === "allow") return { rejectUnauthorized: false };
+	if (mode === "verify-full") return "verify-full";
+}
 function createDatabase(databaseUrl) {
+	const url = new URL(databaseUrl);
+	const ssl = parseSslFromUrl(url);
+	const isPooler = url.port === "6543" || url.searchParams.get("pgbouncer") === "true";
 	const client = postgres(databaseUrl, {
 		max: 10,
 		idle_timeout: 20,
-		connect_timeout: 10
+		connect_timeout: 10,
+		...ssl ? { ssl } : {},
+		...isPooler ? { prepare: false } : {}
 	});
 	return {
 		db: drizzle(client, { schema: schema_exports }),
@@ -489,6 +504,12 @@ function cloneMemory(memory) {
 		updatedAt: new Date(memory.updatedAt)
 	};
 }
+function toDate(value) {
+	return value instanceof Date ? value : new Date(value);
+}
+function toNullableDate(value) {
+	return value === null ? null : toDate(value);
+}
 function rowToMemory(row) {
 	return {
 		id: row.id,
@@ -503,12 +524,12 @@ function rowToMemory(row) {
 		embeddingModel: row.embeddingModel,
 		embeddingDimensions: row.embeddingDimensions,
 		supersededBy: row.supersededBy,
-		supersededAt: row.supersededAt,
-		expiresAt: row.expiresAt,
-		lastAccessedAt: row.lastAccessedAt,
+		supersededAt: toNullableDate(row.supersededAt),
+		expiresAt: toNullableDate(row.expiresAt),
+		lastAccessedAt: toNullableDate(row.lastAccessedAt),
 		accessCount: row.accessCount,
-		createdAt: row.createdAt,
-		updatedAt: row.updatedAt
+		createdAt: toDate(row.createdAt),
+		updatedAt: toDate(row.updatedAt)
 	};
 }
 async function embedOne(embedder, text, options = {}) {
@@ -681,12 +702,18 @@ function cosineSimilarity(a, b) {
 	if (aMagnitude === 0 || bMagnitude === 0) return 0;
 	return dot / (Math.sqrt(aMagnitude) * Math.sqrt(bMagnitude));
 }
-function lexicalScore(content, query) {
-	const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+function tokenizeQuery(query) {
+	return query.toLowerCase().split(/\s+/).filter(Boolean);
+}
+function lexicalScoreWithTerms(content, terms) {
 	if (terms.length === 0) return 0;
 	const lowerContent = content.toLowerCase();
 	return terms.filter((term) => lowerContent.includes(term)).length / terms.length;
 }
+function createLexicalScorer(query) {
+	const terms = tokenizeQuery(query);
+	return (content) => lexicalScoreWithTerms(content, terms);
+}
 function clampScore(value) {
 	if (!Number.isFinite(value)) return 0;
 	return Math.max(0, Math.min(1, value));
@@ -707,6 +734,13 @@ function normalizeWeights(weights) {
 		importance: merged.importance / total
 	};
 }
+function createScoringConfig(config) {
+	return {
+		weights: normalizeWeights(config?.weights),
+		recencyHalfLifeDays: config?.recencyHalfLifeDays ?? DEFAULT_RECENCY_HALF_LIFE_DAYS,
+		accessSaturation: config?.accessSaturation ?? DEFAULT_ACCESS_SATURATION
+	};
+}
 function recencyScore(createdAt, halfLifeDays) {
 	const ageMs = Date.now() - createdAt.getTime();
 	const ageDays = Math.max(0, ageMs / 864e5);
@@ -716,11 +750,11 @@ function accessScore(accessCount, saturation) {
 	if (accessCount <= 0) return 0;
 	return Math.min(1, Math.log1p(accessCount) / Math.log1p(saturation));
 }
-function toScoredMemory(memory, vector, lexical, input, config) {
-	const weights = normalizeWeights(config?.weights);
-	const recency = recencyScore(memory.createdAt, config?.recencyHalfLifeDays ?? DEFAULT_RECENCY_HALF_LIFE_DAYS);
+function toScoredMemoryWithConfig(memory, vector, lexical, input, config) {
+	const { weights } = config;
+	const recency = recencyScore(memory.createdAt, config.recencyHalfLifeDays);
 	const confidence = clampScore(memory.confidence);
-	const access = accessScore(memory.accessCount, config?.accessSaturation ?? DEFAULT_ACCESS_SATURATION);
+	const access = accessScore(memory.accessCount, config.accessSaturation);
 	const importance = IMPORTANCE_SCORES[memory.importance];
 	const score = Math.max(0, Math.min(1, clampScore(vector) * weights.vector + clampScore(lexical) * weights.lexical + recency * weights.recency + confidence * weights.confidence + access * weights.access + importance * weights.importance));
 	return {
@@ -817,7 +851,7 @@ function createInMemoryClient(config) {
 			count: 1
 		}));
 	}
-	return {
+	const client = {
 		remember,
 		async rememberMany(inputs) {
 			return observe(config, "in-memory", "rememberMany", { count: inputs.length }, async () => {
@@ -877,7 +911,9 @@ function createInMemoryClient(config) {
 					...config.provider === void 0 ? {} : { resilience: config.provider }
 				});
 				const now = /* @__PURE__ */ new Date();
-				const scored = Array.from(memories.values()).filter((memory) => matchesRecallFilter(memory, input, now)).map((memory) => toScoredMemory(memory, Math.max(0, cosineSimilarity(memory.embedding, queryEmbedding)), lexicalScore(memory.content, input.query), input, config.retrieval)).filter((memory) => memory.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
+				const scoreLexical = createLexicalScorer(input.query);
+				const scoringConfig = createScoringConfig(config.retrieval);
+				const scored = Array.from(memories.values()).filter((memory) => matchesRecallFilter(memory, input, now)).map((memory) => toScoredMemoryWithConfig(memory, Math.max(0, cosineSimilarity(memory.embedding, queryEmbedding)), scoreLexical(memory.content), input, scoringConfig)).filter((memory) => memory.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
 				for (const memory of scored) {
 					const stored = memories.get(memory.id);
 					if (stored) {
@@ -896,7 +932,7 @@ function createInMemoryClient(config) {
 					input,
 					recall: (contextInput) => {
 						const recallInput = contextInputToRecallInput(contextInput);
-						return this.recall(input.signal === void 0 ? recallInput : {
+						return client.recall(input.signal === void 0 ? recallInput : {
 							...recallInput,
 							signal: input.signal
 						});
@@ -1030,6 +1066,7 @@ function createInMemoryClient(config) {
 			});
 		}
 	};
+	return client;
 	function createExperimental() {
 		return { async consolidate(input) {
 			return observe(config, "in-memory", "consolidate", {
@@ -1081,7 +1118,7 @@ function createInMemoryClient(config) {
 //#region src/db/queries/events.ts
 async function insertEvent(db, row) {
 	const inserted = (await db.insert(eventsTable).values(row).returning())[0];
-	if (!inserted) throw new Error("Event insert returned no rows.");
+	if (!inserted) throw new MnemocyteError("Event insert returned no rows.", "DB");
 	return inserted;
 }
 async function listEvents(db, filter) {
@@ -1096,12 +1133,50 @@ function formatVectorComponent(value) {
 	if (!Number.isFinite(value)) throw new Error("Vector values must be finite numbers.");
 	return Object.is(value, -0) ? "0" : value.toFixed(17);
 }
-function filterConditions(filter) {
-	return and(eq(memoriesTable.entityId, filter.entityId), filter.includeSuperseded ? void 0 : isNull(memoriesTable.supersededBy), filter.includeExpired ? void 0 : sql`(${memoriesTable.expiresAt} IS NULL OR ${memoriesTable.expiresAt} > now())`, filter.types && filter.types.length > 0 ? inArray(memoriesTable.type, [...filter.types]) : void 0, filter.tags && filter.tags.length > 0 ? sql`${memoriesTable.tags} @> ${filter.tags}` : void 0, filter.before ? lt(memoriesTable.createdAt, filter.before) : void 0, filter.after ? gt(memoriesTable.createdAt, filter.after) : void 0);
+function timestampParam(value) {
+	return sql`${value.toISOString()}::timestamptz`;
+}
+function textArrayLiteral(values) {
+	return sql`ARRAY[${sql.join(values.map((value) => sql`${value}`), sql`, `)}]::text[]`;
+}
+function tagsContainAll(tags) {
+	return tags && tags.length > 0 ? sql`${memoriesTable.tags} @> ${textArrayLiteral(tags)}` : void 0;
+}
+function rawTagsFilter(tags) {
+	return tags && tags.length > 0 ? sql`AND tags @> ${textArrayLiteral(tags)}` : sql``;
+}
+function duplicateTagsFilter(tags) {
+	return tags && tags.length > 0 ? sql`AND a.tags @> ${textArrayLiteral(tags)} AND b.tags @> ${textArrayLiteral(tags)}` : sql``;
+}
+function memoryStatsCountFields(now) {
+	return {
+		memoryCount: count(),
+		activeMemoryCount: sql`
+			(count(*) FILTER (
+				WHERE ${memoriesTable.supersededBy} IS NULL
+					AND (${memoriesTable.expiresAt} IS NULL OR ${memoriesTable.expiresAt} > ${timestampParam(now)})
+			))::int
+		`.mapWith(Number),
+		expiredMemoryCount: sql`
+			(count(*) FILTER (
+				WHERE ${memoriesTable.expiresAt} IS NOT NULL
+					AND ${memoriesTable.expiresAt} <= ${timestampParam(now)}
+			))::int
+		`.mapWith(Number),
+		supersededMemoryCount: sql`(count(*) FILTER (WHERE ${memoriesTable.supersededBy} IS NOT NULL))::int`.mapWith(Number)
+	};
+}
+function emptyMemoryStatsCounts() {
+	return {
+		memoryCount: 0,
+		activeMemoryCount: 0,
+		expiredMemoryCount: 0,
+		supersededMemoryCount: 0
+	};
 }
 async function insertMemory(db, row) {
 	const inserted = (await db.insert(memoriesTable).values(row).returning())[0];
-	if (!inserted) throw new Error("Memory insert returned no rows.");
+	if (!inserted) throw new MnemocyteError("Memory insert returned no rows.", "DB");
 	return inserted;
 }
 async function insertMemories(db, rows) {
@@ -1111,8 +1186,17 @@ async function insertMemories(db, rows) {
 async function getMemoryById(db, entityId, memoryId) {
 	return (await db.select().from(memoriesTable).where(and(eq(memoriesTable.entityId, entityId), eq(memoriesTable.id, memoryId))).limit(1))[0] ?? null;
 }
-async function listMemories(db, filter) {
-	return db.select().from(memoriesTable).where(filterConditions(filter));
+async function getEntityMemoryStatsCounts(db, entityId, now) {
+	return (await db.select(memoryStatsCountFields(now)).from(memoriesTable).where(eq(memoriesTable.entityId, entityId)))[0] ?? emptyMemoryStatsCounts();
+}
+async function getGlobalMemoryStatsCounts(db, now) {
+	return (await db.select({
+		entityCount: countDistinct(memoriesTable.entityId),
+		...memoryStatsCountFields(now)
+	}).from(memoriesTable))[0] ?? {
+		entityCount: 0,
+		...emptyMemoryStatsCounts()
+	};
 }
 async function deleteMemory(db, entityId, memoryId) {
 	return (await db.delete(memoriesTable).where(and(eq(memoriesTable.entityId, entityId), eq(memoriesTable.id, memoryId))).returning({ id: memoriesTable.id })).length > 0;
@@ -1121,10 +1205,10 @@ async function deleteMemoriesForEntity(db, entityId) {
 	return (await db.delete(memoriesTable).where(eq(memoriesTable.entityId, entityId)).returning({ id: memoriesTable.id })).length;
 }
 function pruneConditions(filter) {
-	return and(filter.entityId !== void 0 ? eq(memoriesTable.entityId, filter.entityId) : void 0, filter.expired ? and(isNotNull(memoriesTable.expiresAt), sql`${memoriesTable.expiresAt} <= now()`) : void 0, filter.superseded ? isNotNull(memoriesTable.supersededBy) : void 0, filter.createdBefore ? lt(memoriesTable.createdAt, filter.createdBefore) : void 0, filter.notAccessedSince ? or(isNull(memoriesTable.lastAccessedAt), lt(memoriesTable.lastAccessedAt, filter.notAccessedSince)) : void 0, filter.types && filter.types.length > 0 ? inArray(memoriesTable.type, [...filter.types]) : void 0, filter.tags && filter.tags.length > 0 ? sql`${memoriesTable.tags} @> ${filter.tags}` : void 0, filter.maxImportanceLevels && filter.maxImportanceLevels.length > 0 ? inArray(memoriesTable.importance, [...filter.maxImportanceLevels]) : void 0);
+	return and(filter.entityId !== void 0 ? eq(memoriesTable.entityId, filter.entityId) : void 0, filter.expired ? and(isNotNull(memoriesTable.expiresAt), sql`${memoriesTable.expiresAt} <= now()`) : void 0, filter.superseded ? isNotNull(memoriesTable.supersededBy) : void 0, filter.createdBefore ? lt(memoriesTable.createdAt, filter.createdBefore) : void 0, filter.notAccessedSince ? or(isNull(memoriesTable.lastAccessedAt), lt(memoriesTable.lastAccessedAt, filter.notAccessedSince)) : void 0, filter.types && filter.types.length > 0 ? inArray(memoriesTable.type, [...filter.types]) : void 0, tagsContainAll(filter.tags), filter.maxImportanceLevels && filter.maxImportanceLevels.length > 0 ? inArray(memoriesTable.importance, [...filter.maxImportanceLevels]) : void 0);
 }
 async function countPruneMatches(db, filter) {
-	return (await db.select({ count: sql`count(*)::int` }).from(memoriesTable).where(pruneConditions(filter)))[0]?.count ?? 0;
+	return db.$count(memoriesTable, pruneConditions(filter));
 }
 async function pruneMemories(db, filter) {
 	return (await db.delete(memoriesTable).where(pruneConditions(filter)).returning({ id: memoriesTable.id })).length;
@@ -1182,7 +1266,7 @@ async function findDuplicatePairs(db, input) {
 			${input.includeSuperseded ? sql`` : sql`AND a.superseded_by IS NULL AND b.superseded_by IS NULL`}
 			${input.includeExpired ? sql`` : sql`AND (a.expires_at IS NULL OR a.expires_at > now()) AND (b.expires_at IS NULL OR b.expires_at > now())`}
 			${input.types && input.types.length > 0 ? sql`AND a.type IN (${sql.join(input.types.map((type) => sql`${type}`), sql`, `)}) AND b.type IN (${sql.join(input.types.map((type) => sql`${type}`), sql`, `)})` : sql``}
-			${input.tags && input.tags.length > 0 ? sql`AND a.tags @> ${input.tags} AND b.tags @> ${input.tags}` : sql``}
+			${duplicateTagsFilter(input.tags)}
 			AND 1 - (a.embedding <=> b.embedding) >= ${input.threshold}
 		ORDER BY "similarity" DESC
 		LIMIT ${input.limit}
@@ -1260,13 +1344,22 @@ async function setMemoryTags(db, params) {
 	}).where(and(eq(memoriesTable.entityId, params.entityId), eq(memoriesTable.id, params.memoryId)));
 }
 async function markMemoryAccessed(db, memoryIds) {
+	const now = /* @__PURE__ */ new Date();
 	if (memoryIds.length === 0) return;
 	await db.update(memoriesTable).set({
-		lastAccessedAt: /* @__PURE__ */ new Date(),
+		lastAccessedAt: now,
 		accessCount: sql`${memoriesTable.accessCount} + 1`,
-		updatedAt: /* @__PURE__ */ new Date()
+		updatedAt: now
 	}).where(inArray(memoriesTable.id, [...memoryIds]));
 }
+async function getMemoryEmbeddings(db, memoryIds) {
+	if (memoryIds.length === 0) return /* @__PURE__ */ new Map();
+	const rows = await db.select({
+		id: memoriesTable.id,
+		embedding: memoriesTable.embedding
+	}).from(memoriesTable).where(inArray(memoriesTable.id, [...memoryIds]));
+	return new Map(rows.flatMap((row) => row.embedding ? [[row.id, row.embedding]] : []));
+}
 async function vectorSearch(db, input) {
 	const embedding = vectorLiteral(input.embedding);
 	const minScore = input.minScore ?? 0;
@@ -1281,7 +1374,6 @@ async function vectorSearch(db, input) {
 			source,
 			metadata,
 			confidence,
-			embedding,
 			embedding_model AS "embeddingModel",
 			embedding_dimensions AS "embeddingDimensions",
 			superseded_by AS "supersededBy",
@@ -1299,9 +1391,9 @@ async function vectorSearch(db, input) {
 			${input.includeSuperseded ? sql`` : sql`AND superseded_by IS NULL`}
 			${input.includeExpired ? sql`` : sql`AND (expires_at IS NULL OR expires_at > now())`}
 			${input.types && input.types.length > 0 ? sql`AND type IN (${sql.join(input.types.map((type) => sql`${type}`), sql`, `)})` : sql``}
-			${input.tags && input.tags.length > 0 ? sql`AND tags @> ${input.tags}` : sql``}
-			${input.before ? sql`AND created_at < ${input.before}` : sql``}
-			${input.after ? sql`AND created_at > ${input.after}` : sql``}
+			${rawTagsFilter(input.tags)}
+			${input.before ? sql`AND created_at < ${timestampParam(input.before)}` : sql``}
+			${input.after ? sql`AND created_at > ${timestampParam(input.after)}` : sql``}
 			AND 1 - (embedding <=> ${embedding}::vector) >= ${minScore}
 		ORDER BY embedding <=> ${embedding}::vector
 		LIMIT ${input.limit}
@@ -1319,7 +1411,6 @@ async function lexicalSearch(db, input) {
 			source,
 			metadata,
 			confidence,
-			embedding,
 			embedding_model AS "embeddingModel",
 			embedding_dimensions AS "embeddingDimensions",
 			superseded_by AS "supersededBy",
@@ -1336,9 +1427,9 @@ async function lexicalSearch(db, input) {
 			${input.includeSuperseded ? sql`` : sql`AND superseded_by IS NULL`}
 			${input.includeExpired ? sql`` : sql`AND (expires_at IS NULL OR expires_at > now())`}
 			${input.types && input.types.length > 0 ? sql`AND type IN (${sql.join(input.types.map((type) => sql`${type}`), sql`, `)})` : sql``}
-			${input.tags && input.tags.length > 0 ? sql`AND tags @> ${input.tags}` : sql``}
-			${input.before ? sql`AND created_at < ${input.before}` : sql``}
-			${input.after ? sql`AND created_at > ${input.after}` : sql``}
+			${rawTagsFilter(input.tags)}
+			${input.before ? sql`AND created_at < ${timestampParam(input.before)}` : sql``}
+			${input.after ? sql`AND created_at > ${timestampParam(input.after)}` : sql``}
 			AND to_tsvector('english', content) @@ websearch_to_tsquery('english', ${input.query})
 		ORDER BY "lexicalScore" DESC
 		LIMIT ${input.limit}
@@ -1353,6 +1444,8 @@ async function hybridRecall(input) {
 	});
 	const candidateMultiplier = input.retrieval?.candidateMultiplier ?? 3;
 	const candidateLimit = Math.max(input.limit, input.limit * candidateMultiplier);
+	const scoreLexical = createLexicalScorer(input.input.query);
+	const scoringConfig = createScoringConfig(input.retrieval);
 	const [vectorRows, lexicalRows] = await Promise.all([vectorSearch(input.db, {
 		...input.input,
 		embedding: queryEmbedding,
@@ -1366,13 +1459,15 @@ async function hybridRecall(input) {
 	for (const row of vectorRows) merged.set(row.id, {
 		row,
 		vectorScore: row.vectorScore,
-		lexicalScore: lexicalScore(row.content, input.input.query)
+		lexicalScore: scoreLexical(row.content)
 	});
+	const lexicalOnlyRows = lexicalRows.filter((row) => !merged.has(row.id));
+	const lexicalOnlyEmbeddings = await getMemoryEmbeddings(input.db, lexicalOnlyRows.map((row) => row.id));
 	for (const row of lexicalRows) {
 		const existing = merged.get(row.id);
 		if (existing) existing.lexicalScore = row.lexicalScore;
 		else {
-			const embedding = row.embedding;
+			const embedding = lexicalOnlyEmbeddings.get(row.id);
 			const sim = embedding ? cosineSimilarity(embedding, queryEmbedding) : 0;
 			merged.set(row.id, {
 				row,
@@ -1381,7 +1476,7 @@ async function hybridRecall(input) {
 			});
 		}
 	}
-	const scored = Array.from(merged.values()).map((entry) => toScoredMemory(rowToMemory(entry.row), Math.max(0, entry.vectorScore), Math.max(0, entry.lexicalScore), input.input, input.retrieval)).filter((memory) => memory.score >= input.minScore).sort((a, b) => b.score - a.score).slice(0, input.limit);
+	const scored = Array.from(merged.values()).map((entry) => toScoredMemoryWithConfig(rowToMemory(entry.row), Math.max(0, entry.vectorScore), Math.max(0, entry.lexicalScore), input.input, scoringConfig)).filter((memory) => memory.score >= input.minScore).sort((a, b) => b.score - a.score).slice(0, input.limit);
 	await markMemoryAccessed(input.db, scored.map((memory) => memory.id));
 	return scored;
 }
@@ -1475,7 +1570,7 @@ function createPostgresClient(config, handle) {
 			count: 1
 		}));
 	}
-	return {
+	const client = {
 		remember,
 		async rememberMany(inputs) {
 			return observe(config, "postgres", "rememberMany", { count: inputs.length }, async () => {
@@ -1544,7 +1639,7 @@ function createPostgresClient(config, handle) {
 					input,
 					recall: (contextInput) => {
 						const recallInput = contextInputToRecallInput(contextInput);
-						return this.recall(input.signal === void 0 ? recallInput : {
+						return client.recall(input.signal === void 0 ? recallInput : {
 							...recallInput,
 							signal: input.signal
 						});
@@ -1630,27 +1725,13 @@ function createPostgresClient(config, handle) {
 				assertOpen();
 				const now = /* @__PURE__ */ new Date();
 				if (input?.entityId) {
-					const selected = await listMemories(handle.db, {
-						entityId: input.entityId,
-						includeExpired: true,
-						includeSuperseded: true
-					});
+					const counts = await getEntityMemoryStatsCounts(handle.db, input.entityId, now);
 					return {
 						entityId: input.entityId,
-						memoryCount: selected.length,
-						activeMemoryCount: selected.filter((memory) => !isExpired(rowToMemory(memory), now) && memory.supersededBy === null).length,
-						expiredMemoryCount: selected.filter((memory) => isExpired(rowToMemory(memory), now)).length,
-						supersededMemoryCount: selected.filter((memory) => memory.supersededBy !== null).length
+						...counts
 					};
 				}
-				const allMemories = await handle.db.select().from(memoriesTable);
-				return {
-					entityCount: new Set(allMemories.map((memory) => memory.entityId)).size,
-					memoryCount: allMemories.length,
-					activeMemoryCount: allMemories.filter((memory) => !isExpired(rowToMemory(memory), now) && memory.supersededBy === null).length,
-					expiredMemoryCount: allMemories.filter((memory) => isExpired(rowToMemory(memory), now)).length,
-					supersededMemoryCount: allMemories.filter((memory) => memory.supersededBy !== null).length
-				};
+				return await getGlobalMemoryStatsCounts(handle.db, now);
 			});
 		},
 		experimental: createExperimental(),
@@ -1661,6 +1742,7 @@ function createPostgresClient(config, handle) {
 			});
 		}
 	};
+	return client;
 	function createExperimental() {
 		return { async consolidate(input) {
 			return observe(config, "postgres", "consolidate", {
@@ -1690,7 +1772,7 @@ function createPostgresClient(config, handle) {
 						now
 					});
 					const newSupersededIds = updated.map((row) => row.id);
-					for (const id of newSupersededIds) await insertEvent(tx, {
+					if (config.audit?.enabled === true) for (const id of newSupersededIds) await insertEvent(tx, {
 						id: createEventId(),
 						entityId: input.entityId,
 						description: "memory.superseded",