mnemocyte 0.4.0 → 0.5.1

package/dist/postgres-BDti0rrm.mjs

@@ -0,0 +1,904 @@
+import { t as MnemocyteError } from "./errors-Dgt2nAs1.mjs";
+import { c as IMPORTANCE_RANK, g as parsePostgresDatabaseUrl, i as assertPruneFilterHasSelector, m as throwIfAborted, p as cloneJsonObject, r as memoryHasDependentsError, u as createEventId } from "./store-config-BZ4J1hrM.mjs";
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import { and, count, countDistinct, eq, inArray, isNotNull, isNull, lt, or, sql } from "drizzle-orm";
+import { PgDialect, customType, index, integer, jsonb, pgTable, real, text, timestamp } from "drizzle-orm/pg-core";
+// \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+// src/db/vector.ts
+function formatVectorComponent(value) {
+	if (!Number.isFinite(value)) throw new Error("Vector values must be finite numbers.");
+	return Object.is(value, -0) ? "0" : value.toString();
+}
+// src/db/schema.ts
+var schema_exports = /* @__PURE__ */ __exportAll({
+	eventsTable: () => eventsTable,
+	memoriesTable: () => memoriesTable,
+	metaTable: () => metaTable
+});
+const vector = customType({
+	dataType(config) {
+		return `vector(${config?.dimensions ?? 1536})`;
+	},
+	toDriver(value) {
+		return `[${value.map(formatVectorComponent).join(",")}]`;
+	},
+	fromDriver(value) {
+		return value.slice(1, -1).split(",").filter(Boolean).map(Number);
+	}
+});
+const memoriesTable = pgTable("mnemocyte_memories", {
+	id: text("id").primaryKey(),
+	entityId: text("entity_id").notNull(),
+	content: text("content").notNull(),
+	type: text("type").notNull().default("fact"),
+	importance: text("importance").notNull().default("normal"),
+	tags: text("tags").array().notNull().default(sql`'{}'::text[]`),
+	source: text("source"),
+	metadata: jsonb("metadata").$type().notNull().default({}),
+	confidence: real("confidence").notNull().default(1),
+	embedding: vector("embedding", { dimensions: 1536 }),
+	embeddingModel: text("embedding_model").notNull(),
+	embeddingDimensions: integer("embedding_dimensions").notNull(),
+	supersededBy: text("superseded_by").references(() => memoriesTable.id),
+	supersededAt: timestamp("superseded_at", { withTimezone: true }),
+	expiresAt: timestamp("expires_at", { withTimezone: true }),
+	lastAccessedAt: timestamp("last_accessed_at", { withTimezone: true }),
+	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),
+	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(),
+	description: text("description").notNull(),
+	metadata: jsonb("metadata").$type().notNull().default({}),
+	timestamp: timestamp("timestamp", { withTimezone: true }).notNull().defaultNow()
+}, (table) => [index("mnemocyte_events_entity_time_idx").on(table.entityId, table.timestamp)]);
+const metaTable = pgTable("mnemocyte_meta", {
+	key: text("key").primaryKey(),
+	embeddingDimensions: integer("embedding_dimensions").notNull(),
+	embeddingModel: text("embedding_model")
+});
+// src/db/index.ts
+function createCallerOwnedDatabaseHandle(db) {
+	return {
+		db,
+		async close() {}
+	};
+}
+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 = parsePostgresDatabaseUrl(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,
+		...ssl ? { ssl } : {},
+		...isPooler ? { prepare: false } : {}
+	});
+	return {
+		db: drizzle(client, { schema: schema_exports }),
+		async close() {
+			await client.end();
+		}
+	};
+}
+// src/db/cancellation.ts
+const postgresDialect = new PgDialect();
+async function awaitCancelableQuery(query, signal) {
+	throwIfAborted(signal);
+	if (!signal) return await query;
+	const onAbort = () => {
+		query.cancel();
+	};
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		return await query;
+	} catch (error) {
+		if (signal.aborted) throw new MnemocyteError("Operation was aborted.", "ABORTED", signal.reason);
+		throw error;
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+async function executeCancelableSql(db, statement, signal) {
+	const query = postgresDialect.sqlToQuery(statement);
+	const client = db.$client;
+	if (!client) throw new MnemocyteError("Cancelable Postgres query requires the postgres.js client.", "DB");
+	return await awaitCancelableQuery(client.unsafe(query.sql, query.params), signal);
+}
+// src/db/queries/events.ts
+function timestampParam$1(value) {
+	return sql`${value.toISOString()}::timestamptz`;
+}
+async function insertEvent(db, row) {
+	const inserted = (await db.insert(eventsTable).values(row).returning())[0];
+	if (!inserted) throw new MnemocyteError("Event insert returned no rows.", "DB");
+	return inserted;
+}
+async function listEvents(db, filter, signal) {
+	return executeCancelableSql(db, sql`
+			SELECT
+				id,
+				entity_id AS "entityId",
+				description,
+				metadata,
+				timestamp
+			FROM mnemocyte_events
+			WHERE entity_id = ${filter.entityId}
+				${filter.before ? sql`AND timestamp < ${timestampParam$1(filter.before)}` : sql``}
+				${filter.after ? sql`AND timestamp > ${timestampParam$1(filter.after)}` : sql``}
+				${filter.beforeCursor ? sql`AND (timestamp, id) < (${timestampParam$1(filter.beforeCursor.timestamp)}, ${filter.beforeCursor.id})` : sql``}
+				${filter.afterCursor ? sql`AND (timestamp, id) > (${timestampParam$1(filter.afterCursor.timestamp)}, ${filter.afterCursor.id})` : sql``}
+			ORDER BY timestamp DESC, id DESC
+			LIMIT ${filter.limit ?? 50}
+		`, signal);
+}
+// src/db/queries/memories.ts
+function vectorLiteral(embedding) {
+	return `[${embedding.map(formatVectorComponent).join(",")}]`;
+}
+function clampedVectorScore(embedding) {
+	const rawScore = sql`1 - (embedding <=> ${embedding}::vector)`;
+	return sql`
+		CASE
+			WHEN ${rawScore} = 'NaN'::double precision
+				OR ${rawScore} = 'Infinity'::double precision
+				OR ${rawScore} = '-Infinity'::double precision
+				THEN 0::double precision
+			ELSE GREATEST(
+				0::double precision,
+				LEAST(1::double precision, ${rawScore})
+			)
+		END
+	`;
+}
+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 insertMemories(db, rows) {
+	if (rows.length === 0) return [];
+	return db.insert(memoriesTable).values(rows).returning();
+}
+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 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 deleteMemoriesWithDependentGuard(db, and(eq(memoriesTable.entityId, entityId), eq(memoriesTable.id, memoryId)));
+}
+async function deleteMemoriesForEntity(db, entityId) {
+	return deleteMemoriesWithDependentGuard(db, eq(memoriesTable.entityId, entityId));
+}
+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, tagsContainAll(filter.tags), filter.maxImportanceLevels && filter.maxImportanceLevels.length > 0 ? inArray(memoriesTable.importance, [...filter.maxImportanceLevels]) : void 0);
+}
+async function countPruneMatches(db, filter, signal) {
+	const conditions = pruneConditions(filter);
+	const rows = await executeCancelableSql(db, sql`
+			SELECT count(*)::int AS count
+			FROM ${memoriesTable}
+			${conditions ? sql`WHERE ${conditions}` : sql``}
+		`, signal);
+	return Number(rows[0]?.count ?? 0);
+}
+async function pruneMemories(db, filter, signal) {
+	return deleteMemoriesWithDependentGuard(db, pruneConditions(filter), signal);
+}
+async function deleteMemoriesWithDependentGuard(db, conditions, signal) {
+	const rows = await executeCancelableSql(db, sql`
+			WITH candidates AS MATERIALIZED (
+				SELECT id, entity_id
+				FROM ${memoriesTable}
+				${conditions ? sql`WHERE ${conditions}` : sql``}
+			),
+			dependents AS MATERIALIZED (
+				SELECT 1
+				FROM ${memoriesTable} AS dependent
+				INNER JOIN candidates AS target
+					ON dependent.superseded_by = target.id
+				LIMIT 1
+			),
+			deleted AS (
+				DELETE FROM ${memoriesTable}
+				WHERE ${memoriesTable.id} IN (SELECT id FROM candidates)
+					AND NOT EXISTS (SELECT 1 FROM dependents)
+				RETURNING id, entity_id
+			),
+			deleted_counts AS (
+				SELECT entity_id, count(*)::int AS deleted_count
+				FROM deleted
+				GROUP BY entity_id
+			),
+			summary AS (
+				SELECT
+					(SELECT count(*)::int FROM candidates) AS matched_count,
+					(SELECT count(*)::int FROM deleted) AS deleted_count,
+					EXISTS (SELECT 1 FROM dependents) AS has_dependents
+			)
+			SELECT
+				summary.matched_count AS "matchedCount",
+				summary.deleted_count AS "deletedCount",
+				summary.has_dependents AS "hasDependents",
+				deleted_counts.entity_id AS "entityId",
+				deleted_counts.deleted_count AS "entityDeletedCount"
+			FROM summary
+			LEFT JOIN deleted_counts ON true
+			ORDER BY deleted_counts.entity_id
+		`, signal);
+	const row = rows[0];
+	return {
+		matchedCount: Number(row?.matchedCount ?? 0),
+		deletedCount: Number(row?.deletedCount ?? 0),
+		hasDependents: row?.hasDependents === true,
+		deletedByEntity: rows.flatMap((detail) => detail.entityId === null ? [] : [{
+			entityId: detail.entityId,
+			deletedCount: Number(detail.entityDeletedCount ?? 0)
+		}])
+	};
+}
+async function findDuplicatePairs(db, input, signal) {
+	return (await executeCancelableSql(db, sql`
+			SELECT
+				a.id AS "aId",
+				a.entity_id AS "aEntityId",
+				a.content AS "aContent",
+				a.type AS "aType",
+				a.importance AS "aImportance",
+				a.tags AS "aTags",
+				a.source AS "aSource",
+				a.metadata AS "aMetadata",
+				a.confidence AS "aConfidence",
+				a.embedding AS "aEmbedding",
+				a.embedding_model AS "aEmbeddingModel",
+				a.embedding_dimensions AS "aEmbeddingDimensions",
+				a.superseded_by AS "aSupersededBy",
+				a.superseded_at AS "aSupersededAt",
+				a.expires_at AS "aExpiresAt",
+				a.last_accessed_at AS "aLastAccessedAt",
+				a.access_count AS "aAccessCount",
+				a.created_at AS "aCreatedAt",
+				a.updated_at AS "aUpdatedAt",
+				b.id AS "bId",
+				b.entity_id AS "bEntityId",
+				b.content AS "bContent",
+				b.type AS "bType",
+				b.importance AS "bImportance",
+				b.tags AS "bTags",
+				b.source AS "bSource",
+				b.metadata AS "bMetadata",
+				b.confidence AS "bConfidence",
+				b.embedding AS "bEmbedding",
+				b.embedding_model AS "bEmbeddingModel",
+				b.embedding_dimensions AS "bEmbeddingDimensions",
+				b.superseded_by AS "bSupersededBy",
+				b.superseded_at AS "bSupersededAt",
+				b.expires_at AS "bExpiresAt",
+				b.last_accessed_at AS "bLastAccessedAt",
+				b.access_count AS "bAccessCount",
+				b.created_at AS "bCreatedAt",
+				b.updated_at AS "bUpdatedAt",
+				1 - (a.embedding <=> b.embedding) AS "similarity"
+			FROM mnemocyte_memories a
+			JOIN mnemocyte_memories b
+				ON b.entity_id = a.entity_id
+				AND a.id < b.id
+				AND a.embedding IS NOT NULL
+				AND b.embedding IS NOT NULL
+			WHERE
+				a.entity_id = ${input.entityId}
+				${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``}
+				${duplicateTagsFilter(input.tags)}
+				AND 1 - (a.embedding <=> b.embedding) >= ${input.threshold}
+			ORDER BY "similarity" DESC
+			LIMIT ${input.limit}
+		`, signal)).map((row) => {
+		return {
+			a: {
+				id: row.aId,
+				entityId: row.aEntityId,
+				content: row.aContent,
+				type: row.aType,
+				importance: row.aImportance,
+				tags: row.aTags,
+				source: row.aSource,
+				metadata: row.aMetadata,
+				confidence: row.aConfidence,
+				embedding: row.aEmbedding,
+				embeddingModel: row.aEmbeddingModel,
+				embeddingDimensions: row.aEmbeddingDimensions,
+				supersededBy: row.aSupersededBy,
+				supersededAt: row.aSupersededAt,
+				expiresAt: row.aExpiresAt,
+				lastAccessedAt: row.aLastAccessedAt,
+				accessCount: row.aAccessCount,
+				createdAt: row.aCreatedAt,
+				updatedAt: row.aUpdatedAt
+			},
+			b: {
+				id: row.bId,
+				entityId: row.bEntityId,
+				content: row.bContent,
+				type: row.bType,
+				importance: row.bImportance,
+				tags: row.bTags,
+				source: row.bSource,
+				metadata: row.bMetadata,
+				confidence: row.bConfidence,
+				embedding: row.bEmbedding,
+				embeddingModel: row.bEmbeddingModel,
+				embeddingDimensions: row.bEmbeddingDimensions,
+				supersededBy: row.bSupersededBy,
+				supersededAt: row.bSupersededAt,
+				expiresAt: row.bExpiresAt,
+				lastAccessedAt: row.bLastAccessedAt,
+				accessCount: row.bAccessCount,
+				createdAt: row.bCreatedAt,
+				updatedAt: row.bUpdatedAt
+			},
+			similarity: Number(row.similarity) || 0
+		};
+	});
+}
+async function loadConsolidationTargets(db, entityId, ids) {
+	if (ids.length === 0) return [];
+	return await db.select({
+		id: memoriesTable.id,
+		tags: memoriesTable.tags,
+		supersededBy: memoriesTable.supersededBy
+	}).from(memoriesTable).where(and(eq(memoriesTable.entityId, entityId), inArray(memoriesTable.id, [...ids])));
+}
+async function lockConsolidationMemories(db, entityId, survivorId, supersededIds) {
+	const ids = [.../* @__PURE__ */ new Set([survivorId, ...supersededIds])].sort();
+	return db.select({
+		id: memoriesTable.id,
+		tags: memoriesTable.tags,
+		supersededBy: memoriesTable.supersededBy
+	}).from(memoriesTable).where(and(eq(memoriesTable.entityId, entityId), inArray(memoriesTable.id, ids))).orderBy(memoriesTable.id).for("update");
+}
+async function markMemoriesSuperseded(db, params) {
+	if (params.ids.length === 0) return [];
+	return await db.update(memoriesTable).set({
+		supersededBy: params.survivorId,
+		supersededAt: params.now,
+		updatedAt: params.now
+	}).where(and(eq(memoriesTable.entityId, params.entityId), inArray(memoriesTable.id, [...params.ids]), isNull(memoriesTable.supersededBy))).returning({
+		id: memoriesTable.id,
+		tags: memoriesTable.tags
+	});
+}
+async function setMemoryTags(db, params) {
+	await db.update(memoriesTable).set({
+		tags: [...params.tags],
+		updatedAt: params.now
+	}).where(and(eq(memoriesTable.entityId, params.entityId), eq(memoriesTable.id, params.memoryId)));
+}
+async function markMemoriesAccessed(db, memoryIds) {
+	const now = /* @__PURE__ */ new Date();
+	if (memoryIds.length === 0) return [];
+	return db.update(memoriesTable).set({
+		lastAccessedAt: now,
+		accessCount: sql`${memoriesTable.accessCount} + 1`,
+		updatedAt: now
+	}).where(inArray(memoriesTable.id, [...memoryIds])).returning({
+		id: memoriesTable.id,
+		lastAccessedAt: memoriesTable.lastAccessedAt,
+		accessCount: memoriesTable.accessCount,
+		updatedAt: memoriesTable.updatedAt
+	});
+}
+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 vectorScore = clampedVectorScore(embedding);
+	const minVectorScore = input.minVectorScore ?? 0;
+	return await db.execute(sql`
+		SELECT
+			id,
+			entity_id AS "entityId",
+			content,
+			type,
+			importance,
+			tags,
+			source,
+			metadata,
+			confidence,
+			embedding_model AS "embeddingModel",
+			embedding_dimensions AS "embeddingDimensions",
+			superseded_by AS "supersededBy",
+			superseded_at AS "supersededAt",
+			expires_at AS "expiresAt",
+			last_accessed_at AS "lastAccessedAt",
+			access_count AS "accessCount",
+			created_at AS "createdAt",
+			updated_at AS "updatedAt",
+			${vectorScore} AS "vectorScore"
+		FROM mnemocyte_memories
+		WHERE
+			entity_id = ${input.entityId}
+			AND embedding IS NOT NULL
+			${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``}
+			${rawTagsFilter(input.tags)}
+			${input.before ? sql`AND created_at < ${timestampParam(input.before)}` : sql``}
+			${input.after ? sql`AND created_at > ${timestampParam(input.after)}` : sql``}
+			AND ${vectorScore} >= ${minVectorScore}
+		ORDER BY embedding <=> ${embedding}::vector
+		LIMIT ${input.limit}
+	`);
+}
+async function lexicalSearch(db, input) {
+	return await db.execute(sql`
+		SELECT
+			id,
+			entity_id AS "entityId",
+			content,
+			type,
+			importance,
+			tags,
+			source,
+			metadata,
+			confidence,
+			embedding_model AS "embeddingModel",
+			embedding_dimensions AS "embeddingDimensions",
+			superseded_by AS "supersededBy",
+			superseded_at AS "supersededAt",
+			expires_at AS "expiresAt",
+			last_accessed_at AS "lastAccessedAt",
+			access_count AS "accessCount",
+			created_at AS "createdAt",
+			updated_at AS "updatedAt",
+			ts_rank(to_tsvector('english', content), websearch_to_tsquery('english', ${input.query})) AS "lexicalScore"
+		FROM mnemocyte_memories
+		WHERE
+			entity_id = ${input.entityId}
+			${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``}
+			${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}
+	`);
+}
+async function getInstallationMeta(db) {
+	return (await db.select().from(metaTable).where(eq(metaTable.key, "installation")).limit(1))[0] ?? null;
+}
+async function getStoredEmbeddingModels(db) {
+	return (await db.selectDistinct({ embeddingModel: memoriesTable.embeddingModel }).from(memoriesTable).limit(2)).map((row) => row.embeddingModel);
+}
+async function recordInstallationEmbeddingModel(db, embeddingModel) {
+	return (await db.update(metaTable).set({ embeddingModel }).where(and(eq(metaTable.key, "installation"), isNull(metaTable.embeddingModel))).returning())[0] ?? null;
+}
+// src/memory/postgres-records.ts
+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,
+		entityId: row.entityId,
+		content: row.content,
+		type: row.type,
+		importance: row.importance,
+		tags: row.tags,
+		source: row.source,
+		metadata: cloneJsonObject(row.metadata),
+		confidence: row.confidence,
+		embeddingModel: row.embeddingModel,
+		embeddingDimensions: row.embeddingDimensions,
+		supersededBy: row.supersededBy,
+		supersededAt: toNullableDate(row.supersededAt),
+		expiresAt: toNullableDate(row.expiresAt),
+		lastAccessedAt: toNullableDate(row.lastAccessedAt),
+		accessCount: row.accessCount,
+		createdAt: toDate(row.createdAt),
+		updatedAt: toDate(row.updatedAt)
+	};
+}
+// src/memory/postgres.ts
+const IMPORTANCE_LEVELS = [
+	"low",
+	"normal",
+	"high",
+	"critical"
+];
+const MIGRATION_ERROR_CODES = /* @__PURE__ */ new Set([
+	"42P01",
+	"42703",
+	"42704",
+	"42883"
+]);
+const CONSOLIDATION_SURVIVOR_FOREIGN_KEY = "mnemocyte_memories_superseded_by_mnemocyte_memories_id_fk";
+function rowToAuditEvent(row) {
+	return {
+		id: row.id,
+		entityId: row.entityId,
+		description: row.description,
+		metadata: cloneJsonObject(row.metadata),
+		timestamp: new Date(row.timestamp)
+	};
+}
+function importanceCeilingLevels(max) {
+	return IMPORTANCE_LEVELS.filter((level) => IMPORTANCE_RANK[level] <= IMPORTANCE_RANK[max]);
+}
+function hasPostgresErrorCode(error, code) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function hasPostgresConstraintName(error, name) {
+	return typeof error === "object" && error !== null && "constraint_name" in error && error.constraint_name === name;
+}
+function getPostgresErrorCode(error) {
+	return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+function normalizePostgresError(error) {
+	if (error instanceof MnemocyteError) return error;
+	const code = getPostgresErrorCode(error);
+	if (code && MIGRATION_ERROR_CODES.has(code)) return new MnemocyteError("Postgres schema is missing or incompatible. Apply the bundled Mnemocyte migrations before using the Postgres backend.", "MIGRATION", error);
+	return new MnemocyteError("Postgres operation failed.", "DB", error);
+}
+async function runPostgresOperation(operation) {
+	try {
+		return await operation();
+	} catch (error) {
+		throw normalizePostgresError(error);
+	}
+}
+async function runPostgresDeleteOperation(operation) {
+	try {
+		return await operation();
+	} catch (error) {
+		if (error instanceof MnemocyteError) throw error;
+		if (hasPostgresErrorCode(error, "23503") && hasPostgresConstraintName(error, CONSOLIDATION_SURVIVOR_FOREIGN_KEY)) throw memoryHasDependentsError(error);
+		throw normalizePostgresError(error);
+	}
+}
+function toPruneFilter(input) {
+	const filter = {};
+	if (input.entityId !== void 0) filter.entityId = input.entityId;
+	if (input.expired === true) filter.expired = true;
+	if (input.superseded === true) filter.superseded = true;
+	if (input.createdBefore !== void 0) filter.createdBefore = input.createdBefore;
+	if (input.notAccessedSince !== void 0) filter.notAccessedSince = input.notAccessedSince;
+	if (input.types !== void 0 && input.types.length > 0) filter.types = input.types;
+	if (input.tags !== void 0 && input.tags.length > 0) filter.tags = input.tags;
+	if (input.maxImportance !== void 0) filter.maxImportanceLevels = importanceCeilingLevels(input.maxImportance);
+	return filter;
+}
+function toMemoryRow(memory) {
+	return {
+		...memory,
+		tags: [...memory.tags],
+		embedding: [...memory.embedding]
+	};
+}
+function createPostgresStore(handle) {
+	let schemaValidated = false;
+	let schemaValidationPromise;
+	async function ensureEmbeddingCompatibility(embedder) {
+		if (schemaValidated) return;
+		if (!schemaValidationPromise) schemaValidationPromise = validateEmbeddingCompatibility(embedder).catch((error) => {
+			schemaValidationPromise = void 0;
+			throw error;
+		});
+		await schemaValidationPromise;
+	}
+	async function validateEmbeddingCompatibility(embedder) {
+		let meta;
+		try {
+			meta = await getInstallationMeta(handle.db);
+		} catch (error) {
+			if (hasPostgresErrorCode(error, "42P01") || hasPostgresErrorCode(error, "42703")) throw new MnemocyteError("Postgres embedding metadata is missing or outdated. Apply the bundled migrations through 0002_add_embedding_model.sql, or render a fresh dimension-specific initial migration, before using embedding-dependent operations.", "MIGRATION", error);
+			throw normalizePostgresError(error);
+		}
+		if (!meta) throw new MnemocyteError("mnemocyte_meta is missing the \"installation\" row. Apply the bundled migrations, or render a fresh dimension-specific initial migration, before using embedding-dependent operations.", "MIGRATION");
+		if (meta.embeddingDimensions !== embedder.dimensions) throw new MnemocyteError(`embedder.dimensions (${embedder.dimensions}) must match mnemocyte_meta.embedding_dimensions (${meta.embeddingDimensions}). Render and apply a migration for the selected embedding dimension, or configure an embedder that matches this installation.`, "CONFIG");
+		let installationModel = meta.embeddingModel;
+		if (installationModel === null) {
+			try {
+				const storedModels = await getStoredEmbeddingModels(handle.db);
+				if (storedModels.length > 1) throw new MnemocyteError("mnemocyte_meta.embedding_model is unset, but stored memories contain multiple embedding_model values. Re-embed or remove the mixed historical rows, then explicitly record the installation model before using embedding-dependent operations.", "MIGRATION");
+				const inferredModel = storedModels[0] ?? embedder.model;
+				const recorded = await recordInstallationEmbeddingModel(handle.db, inferredModel);
+				if (recorded) installationModel = recorded.embeddingModel;
+				else installationModel = (await getInstallationMeta(handle.db))?.embeddingModel ?? null;
+			} catch (error) {
+				throw normalizePostgresError(error);
+			}
+			if (installationModel === null) throw new MnemocyteError("mnemocyte_meta.embedding_model could not be recorded. Verify the installation metadata row and retry.", "MIGRATION");
+		}
+		if (installationModel !== embedder.model) throw new MnemocyteError(`embedder.model ("${embedder.model}") must match mnemocyte_meta.embedding_model ("${installationModel}"). Configure the recorded model, or explicitly re-embed existing memories and update the installation metadata.`, "CONFIG");
+		schemaValidated = true;
+	}
+	return {
+		backend: "postgres",
+		async ensureSchema() {},
+		ensureEmbeddingCompatibility,
+		async insertMemories(memories) {
+			return runPostgresOperation(async () => {
+				return (await insertMemories(handle.db, memories.map(toMemoryRow))).map(rowToMemory);
+			});
+		},
+		async vectorSearch(input) {
+			return runPostgresOperation(async () => {
+				return (await vectorSearch(handle.db, input)).map((row) => ({
+					memory: rowToMemory(row),
+					vectorScore: row.vectorScore
+				}));
+			});
+		},
+		async lexicalSearch(input) {
+			return runPostgresOperation(async () => {
+				return (await lexicalSearch(handle.db, input)).map((row) => ({
+					memory: rowToMemory(row),
+					lexicalScore: row.lexicalScore
+				}));
+			});
+		},
+		async getMemoryEmbeddings(memoryIds) {
+			return runPostgresOperation(() => getMemoryEmbeddings(handle.db, memoryIds));
+		},
+		async markMemoriesAccessed(memoryIds) {
+			return runPostgresOperation(async () => {
+				return (await markMemoriesAccessed(handle.db, memoryIds)).map((row) => {
+					if (row.lastAccessedAt === null) throw new MnemocyteError("Postgres access update returned no timestamp.", "DB");
+					return {
+						...row,
+						lastAccessedAt: row.lastAccessedAt
+					};
+				});
+			});
+		},
+		async deleteMemory(entityId, memoryId) {
+			return runPostgresDeleteOperation(async () => {
+				const result = await deleteMemory(handle.db, entityId, memoryId);
+				if (result.hasDependents) throw memoryHasDependentsError();
+				return result.deletedCount > 0;
+			});
+		},
+		async deleteMemoriesForEntity(entityId) {
+			return runPostgresDeleteOperation(async () => {
+				const result = await deleteMemoriesForEntity(handle.db, entityId);
+				if (result.hasDependents) throw memoryHasDependentsError();
+				return result.deletedCount;
+			});
+		},
+		async prune(input, options) {
+			return runPostgresDeleteOperation(async () => {
+				throwIfAborted(options?.signal);
+				assertPruneFilterHasSelector(input);
+				const filter = toPruneFilter(input);
+				if (input.dryRun === true) return {
+					matchedCount: await countPruneMatches(handle.db, filter, options?.signal),
+					deletedCount: 0,
+					dryRun: true,
+					deletedByEntity: []
+				};
+				const result = await pruneMemories(handle.db, filter, options?.signal);
+				if (result.hasDependents) throw memoryHasDependentsError();
+				return {
+					matchedCount: result.matchedCount,
+					deletedCount: result.deletedCount,
+					dryRun: false,
+					deletedByEntity: result.deletedByEntity
+				};
+			});
+		},
+		async findDuplicatePairs(input, options) {
+			return runPostgresOperation(async () => {
+				return (await findDuplicatePairs(handle.db, {
+					entityId: input.entityId,
+					threshold: input.threshold ?? .95,
+					limit: input.limit ?? 100,
+					...input.types === void 0 ? {} : { types: input.types },
+					...input.tags === void 0 ? {} : { tags: input.tags },
+					...input.includeSuperseded === void 0 ? {} : { includeSuperseded: input.includeSuperseded },
+					...input.includeExpired === void 0 ? {} : { includeExpired: input.includeExpired }
+				}, options?.signal)).map((row) => ({
+					a: rowToMemory(row.a),
+					b: rowToMemory(row.b),
+					similarity: Math.max(0, Math.min(1, row.similarity))
+				}));
+			});
+		},
+		async addAuditEvents(events) {
+			return runPostgresOperation(async () => {
+				for (const event of events) await insertEvent(handle.db, {
+					id: event.id,
+					entityId: event.entityId,
+					description: event.description,
+					metadata: cloneJsonObject(event.metadata),
+					timestamp: event.timestamp
+				});
+			});
+		},
+		async listAuditLog(input, options) {
+			return runPostgresOperation(async () => {
+				return (await listEvents(handle.db, {
+					entityId: input.entityId,
+					limit: input.limit ?? 50,
+					...input.before === void 0 ? {} : { before: input.before },
+					...input.after === void 0 ? {} : { after: input.after },
+					...input.beforeCursor === void 0 ? {} : { beforeCursor: input.beforeCursor },
+					...input.afterCursor === void 0 ? {} : { afterCursor: input.afterCursor }
+				}, options?.signal)).map(rowToAuditEvent);
+			});
+		},
+		async getMemory(entityId, memoryId, options) {
+			return runPostgresOperation(async () => {
+				throwIfAborted(options?.signal);
+				const row = await getMemoryById(handle.db, entityId, memoryId);
+				throwIfAborted(options?.signal);
+				return row ? rowToMemory(row) : null;
+			});
+		},
+		async loadConsolidationTargets(entityId, ids, options) {
+			return runPostgresOperation(async () => {
+				throwIfAborted(options?.signal);
+				const targets = await loadConsolidationTargets(handle.db, entityId, ids);
+				throwIfAborted(options?.signal);
+				return targets;
+			});
+		},
+		async consolidate(input, options) {
+			return runPostgresOperation(async () => {
+				throwIfAborted(options?.signal);
+				return { supersededIds: await handle.db.transaction(async (tx) => {
+					throwIfAborted(options?.signal);
+					const lockedMemories = await lockConsolidationMemories(tx, input.entityId, input.survivorId, input.supersededIds);
+					throwIfAborted(options?.signal);
+					const survivor = lockedMemories.find((memory) => memory.id === input.survivorId);
+					if (!survivor || survivor.supersededBy !== null) throw new MnemocyteError("Consolidation survivor changed before mutation.", "CONFLICT");
+					const targets = lockedMemories.filter((memory) => memory.id !== input.survivorId);
+					if (targets.some((target) => target.supersededBy !== null && target.supersededBy !== input.survivorId)) throw new MnemocyteError("Superseded memory already belongs to a different survivor.", "CONFLICT");
+					const activeIds = targets.filter((target) => target.supersededBy === null).map((target) => target.id);
+					const updated = await markMemoriesSuperseded(tx, {
+						survivorId: input.survivorId,
+						entityId: input.entityId,
+						ids: activeIds,
+						now: input.now
+					});
+					throwIfAborted(options?.signal);
+					const ids = updated.map((row) => row.id);
+					if (input.auditEnabled) for (const id of ids) {
+						throwIfAborted(options?.signal);
+						await insertEvent(tx, {
+							id: createEventId(),
+							entityId: input.entityId,
+							description: "memory.superseded",
+							metadata: {
+								memoryId: id,
+								supersededBy: input.survivorId
+							},
+							timestamp: input.now
+						});
+						throwIfAborted(options?.signal);
+					}
+					if (input.mergeTags && updated.length > 0) {
+						const mergedTags = new Set(survivor.tags);
+						for (const row of updated) {
+							throwIfAborted(options?.signal);
+							for (const tag of row.tags) mergedTags.add(tag);
+						}
+						if (mergedTags.size !== survivor.tags.length) {
+							throwIfAborted(options?.signal);
+							await setMemoryTags(tx, {
+								entityId: input.entityId,
+								memoryId: input.survivorId,
+								tags: [...mergedTags],
+								now: input.now
+							});
+							throwIfAborted(options?.signal);
+						}
+					}
+					throwIfAborted(options?.signal);
+					return ids;
+				}) };
+			});
+		},
+		async stats(input, now) {
+			return runPostgresOperation(async () => {
+				if (input?.entityId) {
+					const counts = await getEntityMemoryStatsCounts(handle.db, input.entityId, now);
+					return {
+						entityId: input.entityId,
+						...counts
+					};
+				}
+				return await getGlobalMemoryStatsCounts(handle.db, now);
+			});
+		},
+		async close() {
+			return runPostgresOperation(() => handle.close());
+		}
+	};
+}
+export { createCallerOwnedDatabaseHandle as n, createDatabase as r, createPostgresStore as t };
+
+//# sourceMappingURL=postgres-BDti0rrm.mjs.map