mnemocyte 0.3.0 → 0.5.0

package/dist/index.mjs

@@ -1,1088 +1,11 @@
-import { n as isMnemocyteError, t as MnemocyteError } from "./errors-B_7ZdjEO.mjs";
-import { drizzle } from "drizzle-orm/postgres-js";
-import postgres from "postgres";
-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;
-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;
-};
-//#endregion
-//#region 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.toFixed(17);
-}
-//#endregion
-//#region 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()
-});
-//#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) {
-	let url;
-	try {
-		url = new URL(databaseUrl);
-	} catch (error) {
-		throw new MnemocyteError("databaseUrl must be a valid Postgres connection URL.", "CONFIG", error);
-	}
-	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();
-		}
-	};
-}
-//#endregion
-//#region src/memory/json.ts
-function invalidJsonValue(path, cause) {
-	return new MnemocyteError(`${path} must contain only JSON-compatible value data.`, "VALIDATION", cause);
-}
-function cloneJsonValue(value, path, ancestors) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw invalidJsonValue(path);
-		return Object.is(value, -0) ? 0 : value;
-	}
-	if (typeof value !== "object") throw invalidJsonValue(path);
-	if (ancestors.has(value)) throw invalidJsonValue(path);
-	ancestors.add(value);
-	try {
-		if (Array.isArray(value)) {
-			if (Object.getOwnPropertySymbols(value).length > 0 || Object.keys(value).some((key) => !/^(0|[1-9]\d*)$/.test(key))) throw invalidJsonValue(path);
-			return Array.from({ length: value.length }, (_, index) => {
-				if (!Object.hasOwn(value, index)) throw invalidJsonValue(`${path}[${index}]`);
-				return cloneJsonValue(value[index], `${path}[${index}]`, ancestors);
-			});
-		}
-		const prototype = Object.getPrototypeOf(value);
-		if (prototype !== Object.prototype && prototype !== null) throw invalidJsonValue(path);
-		const descriptors = Object.getOwnPropertyDescriptors(value);
-		const entries = [];
-		for (const key of Reflect.ownKeys(descriptors)) {
-			if (typeof key !== "string") throw invalidJsonValue(path);
-			const descriptor = descriptors[key];
-			if (descriptor === void 0 || descriptor.enumerable !== true || !("value" in descriptor)) throw invalidJsonValue(`${path}.${key}`);
-			entries.push([key, cloneJsonValue(descriptor.value, `${path}.${key}`, ancestors)]);
-		}
-		return Object.fromEntries(entries);
-	} finally {
-		ancestors.delete(value);
-	}
-}
-/** Validate and deep-clone a JSON-compatible object. */
-function cloneJsonObject(value, path = "metadata") {
-	try {
-		if (value === null || typeof value !== "object" || Array.isArray(value)) throw invalidJsonValue(path);
-		return cloneJsonValue(value, path, /* @__PURE__ */ new Set());
-	} catch (error) {
-		if (error instanceof MnemocyteError) throw error;
-		throw invalidJsonValue(path, error);
-	}
-}
-/** Assert that a runtime value is a JSON-compatible object. */
-function validateJsonObject(value, path = "metadata") {
-	cloneJsonObject(value, path);
-}
-//#endregion
-//#region src/memory/records.ts
-function normalizeTags(tags) {
-	if (!tags) return [];
-	return [...new Set(tags.map((tag) => tag.trim()).filter(Boolean))];
-}
-function createId() {
-	return `mem_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
-}
-/** Generate a unique audit-event id (`evt_*`). */
-function createEventId() {
-	return `evt_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
-}
-function cloneMemory(memory) {
-	return {
-		id: memory.id,
-		entityId: memory.entityId,
-		content: memory.content,
-		type: memory.type,
-		importance: memory.importance,
-		tags: [...memory.tags],
-		source: memory.source,
-		metadata: cloneJsonObject(memory.metadata),
-		confidence: memory.confidence,
-		embeddingModel: memory.embeddingModel,
-		embeddingDimensions: memory.embeddingDimensions,
-		supersededBy: memory.supersededBy,
-		supersededAt: memory.supersededAt ? new Date(memory.supersededAt) : null,
-		expiresAt: memory.expiresAt ? new Date(memory.expiresAt) : null,
-		lastAccessedAt: memory.lastAccessedAt ? new Date(memory.lastAccessedAt) : null,
-		accessCount: memory.accessCount,
-		createdAt: new Date(memory.createdAt),
-		updatedAt: new Date(memory.updatedAt)
-	};
-}
-//#endregion
-//#region src/retrieval/scorer.ts
-const IMPORTANCE_SCORES = {
-	low: 0,
-	normal: .5,
-	high: .8,
-	critical: 1
-};
-const DEFAULT_RETRIEVAL_WEIGHTS = {
-	vector: .55,
-	lexical: .2,
-	recency: .1,
-	confidence: .05,
-	access: .05,
-	importance: .05
-};
-const DEFAULT_RECENCY_HALF_LIFE_DAYS = 90;
-const DEFAULT_ACCESS_SATURATION = 10;
-function cosineSimilarity(a, b) {
-	let dot = 0;
-	let aMagnitude = 0;
-	let bMagnitude = 0;
-	for (let i = 0; i < a.length; i += 1) {
-		const av = a[i] ?? 0;
-		const bv = b[i] ?? 0;
-		dot += av * bv;
-		aMagnitude += av * av;
-		bMagnitude += bv * bv;
-	}
-	if (aMagnitude === 0 || bMagnitude === 0) return 0;
-	return dot / (Math.sqrt(aMagnitude) * Math.sqrt(bMagnitude));
-}
-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));
-}
-function normalizeWeights(weights) {
-	const merged = {
-		...DEFAULT_RETRIEVAL_WEIGHTS,
-		...weights
-	};
-	const total = merged.vector + merged.lexical + merged.recency + merged.confidence + merged.access + merged.importance;
-	if (total <= 0) return { ...DEFAULT_RETRIEVAL_WEIGHTS };
-	return {
-		vector: merged.vector / total,
-		lexical: merged.lexical / total,
-		recency: merged.recency / total,
-		confidence: merged.confidence / total,
-		access: merged.access / total,
-		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);
-	return Math.exp(-Math.LN2 * ageDays / halfLifeDays);
-}
-function accessScore(accessCount, saturation) {
-	if (accessCount <= 0) return 0;
-	return Math.min(1, Math.log1p(accessCount) / Math.log1p(saturation));
-}
-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);
-	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 {
-		...cloneMemory(memory),
-		score,
-		scores: {
-			vector: clampScore(vector),
-			lexical: clampScore(lexical),
-			recency,
-			confidence,
-			access,
-			importance
-		},
-		explanation: input.explain ? {
-			vectorScore: clampScore(vector),
-			lexicalScore: clampScore(lexical),
-			recencyScore: recency,
-			confidenceScore: confidence,
-			accessScore: access,
-			importanceScore: importance,
-			importanceBoost: importance * weights.importance,
-			weights,
-			finalScore: score
-		} : null
-	};
-}
-//#endregion
-//#region src/context/formatter.ts
-function escapeXml(value) {
-	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
-}
-function formatMetadata(memory) {
-	const parts = [
-		`type=${memory.type}`,
-		`importance=${memory.importance}`,
-		`score=${memory.score.toFixed(3)}`
-	];
-	if (memory.source) parts.push(`source=${memory.source}`);
-	if (memory.tags.length > 0) parts.push(`tags=${memory.tags.join(",")}`);
-	return parts.join("; ");
-}
-function markdownFence(value) {
-	const longestBacktickRun = Math.max(0, ...Array.from(value.matchAll(/`+/g), (match) => match[0].length));
-	return "`".repeat(Math.max(3, longestBacktickRun + 1));
-}
-function formatMarkdown(memories, query, omittedCount) {
-	const lines = [
-		"# Memory Context",
-		"",
-		`Query: ${query}`,
-		"",
-		"## Relevant Memories"
-	];
-	for (const memory of memories) {
-		const fence = markdownFence(memory.content);
-		lines.push("", `- ${formatMetadata(memory)}`, `  ${fence}text`, ...memory.content.split("\n").map((line) => `  ${line}`), `  ${fence}`);
-	}
-	if (omittedCount > 0) lines.push("", `[${omittedCount} memories omitted to fit token budget]`);
-	return lines.join("\n");
-}
-function formatPlain(memories, query, omittedCount) {
-	const lines = [
-		"MEMORY CONTEXT",
-		"",
-		`QUERY: ${query}`,
-		"",
-		"RELEVANT MEMORIES"
-	];
-	for (const [index, memory] of memories.entries()) lines.push("", `--- MEMORY ${index + 1} START ---`, formatMetadata(memory), memory.content, `--- MEMORY ${index + 1} END ---`);
-	if (omittedCount > 0) lines.push("", `[${omittedCount} memories omitted to fit token budget]`);
-	return lines.join("\n");
-}
-function formatXml(memories, query, omittedCount) {
-	const lines = [`<memory_context query="${escapeXml(query)}">`];
-	for (const memory of memories) lines.push(`  <memory id="${escapeXml(memory.id)}" type="${escapeXml(memory.type)}" importance="${escapeXml(memory.importance)}" score="${memory.score.toFixed(3)}">`, `    <content>${escapeXml(memory.content)}</content>`, `    <metadata>${escapeXml(formatMetadata(memory))}</metadata>`, "  </memory>");
-	if (omittedCount > 0) lines.push(`  <omitted count="${omittedCount}" reason="token_budget" />`);
-	lines.push("</memory_context>");
-	return lines.join("\n");
-}
-function formatContext(memories, query, format, omittedCount = 0) {
-	switch (format) {
-		case "markdown": return formatMarkdown(memories, query, omittedCount);
-		case "plain": return formatPlain(memories, query, omittedCount);
-		case "xml": return formatXml(memories, query, omittedCount);
-	}
-}
-//#endregion
-//#region src/context/tokens.ts
-const heuristicTokenCounter = { count(text) {
-	return Math.ceil(text.length / 4);
-} };
-function trimToTokenBudget(text, maxTokens, tokenCounter) {
-	if (maxTokens < 1 || tokenCounter.count(text) <= maxTokens) return text;
-	let low = 0;
-	let high = text.length;
-	let best = "";
-	while (low <= high) {
-		const mid = Math.floor((low + high) / 2);
-		const output = `${text.slice(0, mid).trimEnd()}\n[truncated to fit token budget]`;
-		if (tokenCounter.count(output) <= maxTokens) {
-			best = output;
-			low = mid + 1;
-		} else high = mid - 1;
-	}
-	return best || "[truncated to fit token budget]";
-}
-//#endregion
-//#region src/context/builder.ts
-async function buildContext(options) {
-	const format = options.input.format ?? "markdown";
-	const maxTokens = options.input.maxTokens ?? 1200;
-	const tokenCounter = options.input.tokenCounter ?? heuristicTokenCounter;
-	const memories = await options.recall(options.input);
-	let low = 0;
-	let high = memories.length;
-	let bestContext = "";
-	while (low <= high) {
-		const mid = Math.floor((low + high) / 2);
-		const omittedCount = memories.length - mid;
-		const context = formatContext(memories.slice(0, mid), options.input.query, format, omittedCount);
-		if (tokenCounter.count(context) <= maxTokens) {
-			bestContext = context;
-			low = mid + 1;
-		} else high = mid - 1;
-	}
-	if (bestContext || memories.length === 0) return bestContext;
-	return trimToTokenBudget(formatContext([], options.input.query, format, memories.length), maxTokens, tokenCounter);
-}
-//#endregion
-//#region src/observability.ts
-function withMetadata(event, metadata) {
-	return {
-		...event,
-		...metadata.entityId === void 0 ? {} : { entityId: metadata.entityId },
-		...metadata.memoryId === void 0 ? {} : { memoryId: metadata.memoryId },
-		...metadata.count === void 0 ? {} : { count: metadata.count }
-	};
-}
-async function emitObservation(config, event) {
-	try {
-		await config.observability?.onEvent?.(event);
-	} catch {
-		return;
-	}
-}
-async function observe(config, backend, operation, metadata, action, successMetadata) {
-	const startedAt = Date.now();
-	await emitObservation(config, withMetadata({
-		operation,
-		phase: "start",
-		backend,
-		timestamp: new Date(startedAt)
-	}, metadata));
-	try {
-		const result = await action();
-		await emitObservation(config, withMetadata({
-			operation,
-			phase: "success",
-			backend,
-			timestamp: /* @__PURE__ */ new Date(),
-			durationMs: Date.now() - startedAt
-		}, {
-			...metadata,
-			...successMetadata?.(result)
-		}));
-		return result;
-	} catch (error) {
-		await emitObservation(config, withMetadata({
-			operation,
-			phase: "error",
-			backend,
-			timestamp: /* @__PURE__ */ new Date(),
-			durationMs: Date.now() - startedAt,
-			error
-		}, metadata));
-		throw error;
-	}
-}
-/**
-* Ordering of {@link ImportanceLevel} from least to most important. Used
-* by `prune({ maxImportance })` to compare a memory's importance against
-* the caller-supplied ceiling.
-*/
-const IMPORTANCE_RANK = {
-	low: 0,
-	normal: 1,
-	high: 2,
-	critical: 3
-};
-//#endregion
-//#region src/resilience.ts
-/**
-* Default per-provider-call timeout. Disabled by default so that callers
-* who do not configure {@link ProviderResilienceConfig.timeoutMs} are
-* unaffected.
-*/
-const DEFAULT_TIMEOUT_MS = 0;
-/** Default number of retry attempts on transient provider failures. */
-const DEFAULT_RETRIES = 0;
-/** Default base backoff delay used between retry attempts. */
-const DEFAULT_BASE_DELAY_MS = 100;
-/** Default ceiling for retry backoff delay. */
-const DEFAULT_MAX_DELAY_MS = 2e3;
-/**
-* Throw a {@link MnemocyteError} with code `"ABORTED"` if `signal` is
-* already aborted. Safe to call with `undefined`.
-*/
-function throwIfAborted(signal) {
-	if (signal?.aborted) throw new MnemocyteError("Operation was aborted.", "ABORTED", signal.reason);
-}
-/**
-* Heuristic default for whether an error should be retried.
-*
-* Conservative by design: only retries on common transient failure
-* indicators (network errors, 5xx-ish messages, `ECONN*` etc.). Never
-* retries on validation, configuration, or {@link MnemocyteError} of
-* code `"VALIDATION"` / `"CONFIG"` / `"ABORTED"`.
-*/
-function defaultShouldRetry(error) {
-	if (error instanceof MnemocyteError) {
-		if (error.code === "VALIDATION" || error.code === "CONFIG" || error.code === "ABORTED") return false;
-		return true;
-	}
-	if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number" && [
-		429,
-		500,
-		502,
-		503,
-		504
-	].includes(error.status)) return true;
-	if (error instanceof Error) {
-		const message = error.message.toLowerCase();
-		if (message.includes("econn") || message.includes("etimedout") || message.includes("network") || message.includes("timeout") || message.includes("temporarily") || message.includes("rate limit") || message.includes("503") || message.includes("502") || message.includes("504") || message.includes("500")) return true;
-	}
-	return false;
-}
-/**
-* Compute the backoff delay for the given retry attempt, using exponential
-* growth capped at {@link ProviderResilienceConfig.maxDelayMs}.
-*
-* `attempt` is 1-indexed: the delay before the first retry uses
-* `attempt = 1`, before the second retry `attempt = 2`, etc.
-*/
-function computeDelayMs(attempt, baseDelayMs, maxDelayMs) {
-	const exponential = baseDelayMs * 2 ** (attempt - 1);
-	return Math.max(0, Math.min(maxDelayMs, exponential));
-}
-/**
-* Promise-based `setTimeout` that rejects with an `"ABORTED"`
-* {@link MnemocyteError} if `signal` aborts while waiting.
-*/
-function delay(ms, signal) {
-	if (ms <= 0) {
-		throwIfAborted(signal);
-		return Promise.resolve();
-	}
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		const onAbort = () => {
-			clearTimeout(timer);
-			reject(new MnemocyteError("Operation was aborted.", "ABORTED", signal?.reason));
-		};
-		if (signal) {
-			if (signal.aborted) {
-				clearTimeout(timer);
-				reject(new MnemocyteError("Operation was aborted.", "ABORTED", signal.reason));
-				return;
-			}
-			signal.addEventListener("abort", onAbort, { once: true });
-		}
-	});
-}
-function timeoutError(timeoutMs) {
-	return new MnemocyteError(`Provider call timed out after ${timeoutMs}ms.`, "TIMEOUT");
-}
-/**
-* Run one provider attempt with a signal linked to the caller's signal and
-* Mnemocyte's configured timeout. Timeout aborts are actively propagated to
-* providers that honor `AbortSignal`.
-*/
-function runAttempt(action, timeoutMs, signal) {
-	if (timeoutMs <= 0 && !signal) return action(void 0);
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		const controller = new AbortController();
-		const timer = timeoutMs > 0 ? setTimeout(() => {
-			if (settled) return;
-			settled = true;
-			signal?.removeEventListener("abort", onAbort);
-			controller.abort(timeoutError(timeoutMs));
-			reject(timeoutError(timeoutMs));
-		}, timeoutMs) : void 0;
-		const onAbort = () => {
-			if (settled) return;
-			settled = true;
-			if (timer) clearTimeout(timer);
-			controller.abort(signal?.reason);
-			reject(new MnemocyteError("Operation was aborted.", "ABORTED", signal?.reason));
-		};
-		if (signal) {
-			if (signal.aborted) {
-				if (timer) clearTimeout(timer);
-				settled = true;
-				controller.abort(signal.reason);
-				reject(new MnemocyteError("Operation was aborted.", "ABORTED", signal.reason));
-				return;
-			}
-			signal.addEventListener("abort", onAbort, { once: true });
-		}
-		action(controller.signal).then((value) => {
-			if (settled) return;
-			settled = true;
-			if (timer) clearTimeout(timer);
-			signal?.removeEventListener("abort", onAbort);
-			resolve(value);
-		}, (error) => {
-			if (settled) return;
-			settled = true;
-			if (timer) clearTimeout(timer);
-			signal?.removeEventListener("abort", onAbort);
-			reject(error);
-		});
-	});
-}
-/**
-* Run `action` with timeout, retry, and abort handling derived from
-* `options.resilience` and `options.signal`. Each retry attempt receives
-* a fresh `AbortSignal` linked to the caller's signal — so callers may
-* abort mid-retry and the in-flight attempt will cancel promptly if the
-* underlying provider honours signals.
-*
-* Errors from {@link MnemocyteError} with code `"VALIDATION"` /
-* `"CONFIG"` / `"ABORTED"` are never retried.
-*/
-async function withResilience(action, options = {}) {
-	const config = options.resilience ?? {};
-	const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	const retries = Math.max(0, config.retries ?? DEFAULT_RETRIES);
-	const baseDelayMs = Math.max(0, config.baseDelayMs ?? DEFAULT_BASE_DELAY_MS);
-	const maxDelayMs = Math.max(baseDelayMs, config.maxDelayMs ?? DEFAULT_MAX_DELAY_MS);
-	const shouldRetry = config.shouldRetry ?? defaultShouldRetry;
-	const externalSignal = options.signal;
-	throwIfAborted(externalSignal);
-	const maxAttempts = retries + 1;
-	let lastError;
-	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-		throwIfAborted(externalSignal);
-		try {
-			return await runAttempt(action, timeoutMs, externalSignal);
-		} catch (error) {
-			lastError = error;
-			if (error instanceof MnemocyteError && error.code === "ABORTED") throw error;
-			if (attempt >= maxAttempts) throw error;
-			if (!shouldRetry(error, attempt)) throw error;
-			await delay(computeDelayMs(attempt, baseDelayMs, maxDelayMs), externalSignal);
-		}
-	}
-	throw lastError;
-}
-//#endregion
-//#region src/memory/embeddings.ts
-function validateEmbedding(embedding, dimensions) {
-	if (embedding.length !== dimensions) throw new MnemocyteError("Embedder returned an embedding with unexpected dimensions.", "EMBEDDING");
-	if (embedding.some((component) => !Number.isFinite(component))) throw new MnemocyteError("Embedder returned an embedding with non-finite values.", "EMBEDDING");
-}
-async function embedOne(embedder, text, options = {}) {
-	let embeddings;
-	try {
-		embeddings = await withResilience((signal) => signal === void 0 ? embedder.embed([text]) : embedder.embed([text], { signal }), {
-			...options.signal === void 0 ? {} : { signal: options.signal },
-			...options.resilience === void 0 ? {} : { resilience: options.resilience }
-		});
-	} catch (error) {
-		if (error instanceof MnemocyteError && (error.code === "TIMEOUT" || error.code === "ABORTED")) throw error;
-		throw new MnemocyteError("Failed to embed text.", "EMBEDDING", error);
-	}
-	const embedding = embeddings[0];
-	if (!embedding) throw new MnemocyteError("Embedder returned no embedding.", "EMBEDDING");
-	validateEmbedding(embedding, embedder.dimensions);
-	return embedding;
-}
-async function embedMany(embedder, texts, options = {}) {
-	if (texts.length === 0) return [];
-	let embeddings;
-	try {
-		embeddings = await withResilience((signal) => signal === void 0 ? embedder.embed(texts) : embedder.embed(texts, { signal }), {
-			...options.signal === void 0 ? {} : { signal: options.signal },
-			...options.resilience === void 0 ? {} : { resilience: options.resilience }
-		});
-	} catch (error) {
-		if (error instanceof MnemocyteError && (error.code === "TIMEOUT" || error.code === "ABORTED")) throw error;
-		throw new MnemocyteError("Failed to embed texts.", "EMBEDDING", error);
-	}
-	if (embeddings.length !== texts.length) throw new MnemocyteError(`Embedder returned ${embeddings.length} embeddings for ${texts.length} texts.`, "EMBEDDING");
-	for (const embedding of embeddings) validateEmbedding(embedding, embedder.dimensions);
-	return embeddings;
-}
-//#endregion
-//#region src/memory/validation.ts
-function assertNonEmptyString(value, field, code = "VALIDATION") {
-	if (typeof value !== "string" || value.trim().length === 0) throw new MnemocyteError(`${field} must be a non-empty string.`, code);
-}
-function assertLimit(value) {
-	if (!Number.isInteger(value) || value < 1) throw new MnemocyteError("limit must be a positive integer.", "VALIDATION");
-}
-function assertMinScore(value) {
-	if (!Number.isFinite(value) || value < 0 || value > 1) throw new MnemocyteError("minScore must be a number between 0 and 1.", "VALIDATION");
-}
-function assertEmbedder(embedder) {
-	if (!embedder || typeof embedder.embed !== "function") throw new MnemocyteError("embedder with an embed function is required.", "CONFIG");
-	assertNonEmptyString(embedder.model, "embedder.model", "CONFIG");
-	if (!Number.isInteger(embedder.dimensions) || embedder.dimensions < 1) throw new MnemocyteError("embedder.dimensions must be a positive integer.", "CONFIG");
-}
-const RETRIEVAL_WEIGHT_KEYS = [
-	"vector",
-	"lexical",
-	"recency",
-	"confidence",
-	"access",
-	"importance"
-];
-function assertPositiveFiniteConfigValue(value, field) {
-	if (!Number.isFinite(value) || value <= 0) throw new MnemocyteError(`${field} must be a positive finite number.`, "CONFIG");
-}
-function validateRetrievalConfig(config) {
-	if (config === void 0) return;
-	let weightTotal = 0;
-	for (const key of RETRIEVAL_WEIGHT_KEYS) {
-		const weight = config.weights?.[key] ?? DEFAULT_RETRIEVAL_WEIGHTS[key];
-		if (!Number.isFinite(weight) || weight < 0) throw new MnemocyteError(`retrieval.weights.${key} must be a non-negative finite number.`, "CONFIG");
-		weightTotal += weight;
-	}
-	if (weightTotal === 0) throw new MnemocyteError("retrieval.weights must have an effective total greater than zero.", "CONFIG");
-	if (config.recencyHalfLifeDays !== void 0) assertPositiveFiniteConfigValue(config.recencyHalfLifeDays, "retrieval.recencyHalfLifeDays");
-	if (config.accessSaturation !== void 0) assertPositiveFiniteConfigValue(config.accessSaturation, "retrieval.accessSaturation");
-	if (config.candidateMultiplier !== void 0 && (!Number.isInteger(config.candidateMultiplier) || config.candidateMultiplier < 1)) throw new MnemocyteError("retrieval.candidateMultiplier must be an integer greater than or equal to 1.", "CONFIG");
-}
-function validateBuildContextInput(input) {
-	if (input.maxTokens !== void 0 && (!Number.isInteger(input.maxTokens) || input.maxTokens < 1)) throw new MnemocyteError("maxTokens must be a positive integer when supplied.", "VALIDATION");
-}
-function validateRememberInput(input) {
-	assertNonEmptyString(input.entityId, "entityId");
-	assertNonEmptyString(input.content, "content");
-	if (input.metadata !== void 0) validateJsonObject(input.metadata);
-	if (input.confidence !== void 0 && (!Number.isFinite(input.confidence) || input.confidence < 0 || input.confidence > 1)) throw new MnemocyteError("confidence must be a number between 0 and 1.", "VALIDATION");
-}
-function validateRecallInput(input) {
-	assertNonEmptyString(input.entityId, "entityId");
-	assertNonEmptyString(input.query, "query");
-	if (input.limit !== void 0) assertLimit(input.limit);
-	if (input.minScore !== void 0) assertMinScore(input.minScore);
-}
-function contextInputToRecallInput(input) {
-	return {
-		entityId: input.entityId,
-		query: input.query,
-		...input.limit === void 0 ? {} : { limit: input.limit },
-		...input.minScore === void 0 ? {} : { minScore: input.minScore },
-		...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 }
-	};
-}
-/**
-* Validate a {@link PruneInput} and throw a `"VALIDATION"`
-* {@link MnemocyteError} when no selector is supplied. Mnemocyte
-* deliberately rejects `prune({})` to avoid surprise full-table deletes.
-*/
-function validatePruneInput(input) {
-	if (input.entityId !== void 0) assertNonEmptyString(input.entityId, "entityId");
-	if (!(input.entityId !== void 0 || input.expired === true || input.superseded === true || input.createdBefore !== void 0 || input.notAccessedSince !== void 0 || input.types !== void 0 && input.types.length > 0 || input.tags !== void 0 && input.tags.length > 0 || input.maxImportance !== void 0)) throw new MnemocyteError("prune requires at least one selector (entityId, expired, superseded, createdBefore, notAccessedSince, types, tags, or maxImportance).", "VALIDATION");
-}
-/**
-* Validate a {@link FindDuplicatesInput} and throw a `"VALIDATION"`
-* {@link MnemocyteError} for malformed `threshold` / `limit` values.
-*/
-function validateFindDuplicatesInput(input) {
-	assertNonEmptyString(input.entityId, "entityId");
-	if (input.threshold !== void 0) {
-		if (!Number.isFinite(input.threshold) || input.threshold < 0 || input.threshold > 1) throw new MnemocyteError("threshold must be a number between 0 and 1.", "VALIDATION");
-	}
-	if (input.limit !== void 0) assertLimit(input.limit);
-}
-/**
-* Validate a {@link ConsolidateInput} and throw a `"VALIDATION"`
-* {@link MnemocyteError} for malformed inputs (empty `supersededIds`
-* or a `survivorId` appearing in `supersededIds`).
-*/
-function validateConsolidateInput(input) {
-	assertNonEmptyString(input.entityId, "entityId");
-	assertNonEmptyString(input.survivorId, "survivorId");
-	if (input.supersededIds.length === 0) throw new MnemocyteError("supersededIds must contain at least one memory id.", "VALIDATION");
-	if (input.supersededIds.includes(input.survivorId)) throw new MnemocyteError("survivorId must not appear in supersededIds.", "VALIDATION");
-	for (const id of input.supersededIds) assertNonEmptyString(id, "supersededIds[*]");
-}
-/**
-* Validate a {@link ListAuditLogInput} and throw a `"VALIDATION"`
-* {@link MnemocyteError} when malformed.
-*/
-function validateListAuditLogInput(input) {
-	assertNonEmptyString(input.entityId, "entityId");
-	if (input.limit !== void 0) assertLimit(input.limit);
-}
-//#endregion
-//#region src/memory/client-core.ts
-function isPositionalRememberManyInput(input) {
-	return Array.isArray(input);
-}
-function providerOptions(config, signal) {
-	return {
-		...signal === void 0 ? {} : { signal },
-		...config.provider === void 0 ? {} : { resilience: config.provider }
-	};
-}
-function createStoredMemory(config, input, embedding, now) {
-	return {
-		id: createId(),
-		entityId: input.entityId,
-		content: input.content,
-		type: input.type ?? "fact",
-		importance: input.importance ?? "normal",
-		tags: normalizeTags(input.tags),
-		source: input.source ?? null,
-		metadata: cloneJsonObject(input.metadata ?? {}),
-		confidence: input.confidence ?? 1,
-		embeddingModel: config.embedder.model,
-		embeddingDimensions: config.embedder.dimensions,
-		supersededBy: null,
-		supersededAt: null,
-		expiresAt: input.expiresAt ?? null,
-		lastAccessedAt: null,
-		accessCount: 0,
-		createdAt: now,
-		updatedAt: now,
-		embedding
-	};
-}
-function auditEvent(entityId, description, metadata, timestamp = /* @__PURE__ */ new Date()) {
-	return {
-		id: createEventId(),
-		entityId,
-		description,
-		metadata: cloneJsonObject(metadata),
-		timestamp
-	};
-}
-function toDuplicatePair(pair) {
-	return {
-		a: cloneMemory(pair.a),
-		b: cloneMemory(pair.b),
-		similarity: Math.max(0, Math.min(1, pair.similarity))
-	};
-}
-function createMemoryClient(config, store) {
-	let closed = false;
-	function assertOpen() {
-		if (closed) throw new MnemocyteError("Mnemocyte client is closed.", "DB");
-	}
-	async function ensureSchema() {
-		await store.ensureSchema();
-	}
-	async function ensureEmbeddingCompatibility() {
-		await store.ensureEmbeddingCompatibility(config.embedder);
-	}
-	async function recordAudit(events) {
-		if (events.length === 0 || config.audit?.enabled !== true) return;
-		try {
-			await store.addAuditEvents(events);
-		} catch {}
-	}
-	async function remember(input) {
-		const preparedInput = {
-			...input,
-			metadata: cloneJsonObject(input.metadata ?? {})
-		};
-		return observe(config, store.backend, "remember", { entityId: preparedInput.entityId }, async () => {
-			assertOpen();
-			validateRememberInput(preparedInput);
-			await ensureEmbeddingCompatibility();
-			const embedding = await embedOne(config.embedder, preparedInput.content, providerOptions(config, preparedInput.signal));
-			const [memory] = await store.insertMemories([createStoredMemory(config, preparedInput, embedding, /* @__PURE__ */ new Date())]);
-			if (!memory) throw new MnemocyteError("Memory insert returned no rows.", "DB");
-			await recordAudit([auditEvent(memory.entityId, "memory.created", {
-				memoryId: memory.id,
-				type: memory.type,
-				importance: memory.importance
-			})]);
-			return cloneMemory(memory);
-		}, (memory) => ({
-			memoryId: memory.id,
-			count: 1
-		}));
-	}
-	async function rememberMany(input) {
-		const positional = isPositionalRememberManyInput(input);
-		const inputs = positional ? input : input.inputs;
-		const signal = positional ? input[0]?.signal : input.signal;
-		const preparedInputs = inputs.map((item) => ({
-			...item,
-			metadata: cloneJsonObject(item.metadata ?? {})
-		}));
-		return observe(config, store.backend, "rememberMany", { count: preparedInputs.length }, async () => {
-			assertOpen();
-			if (preparedInputs.length === 0) return [];
-			for (const item of preparedInputs) validateRememberInput(item);
-			await ensureEmbeddingCompatibility();
-			const embeddings = await embedMany(config.embedder, preparedInputs.map((item) => item.content), providerOptions(config, signal));
-			const now = /* @__PURE__ */ new Date();
-			const stored = preparedInputs.map((item, idx) => createStoredMemory(config, item, embeddings[idx], now));
-			const memories = await store.insertMemories(stored);
-			await recordAudit(memories.map((memory) => auditEvent(memory.entityId, "memory.created", {
-				memoryId: memory.id,
-				type: memory.type,
-				importance: memory.importance
-			})));
-			return memories.map(cloneMemory);
-		}, (result) => ({ count: result.length }));
-	}
-	const client = {
-		remember,
-		rememberMany,
-		async recall(input) {
-			return observe(config, store.backend, "recall", { entityId: input.entityId }, async () => {
-				assertOpen();
-				validateRecallInput(input);
-				const limit = input.limit ?? config.defaults?.limit ?? 10;
-				const minScore = input.minScore ?? config.defaults?.minScore ?? 0;
-				assertLimit(limit);
-				assertMinScore(minScore);
-				await ensureEmbeddingCompatibility();
-				const queryEmbedding = await embedOne(config.embedder, input.query, providerOptions(config, input.signal));
-				const candidateMultiplier = config.retrieval?.candidateMultiplier ?? 3;
-				const candidateLimit = Math.max(limit, limit * candidateMultiplier);
-				const scoreLexical = createLexicalScorer(input.query);
-				const scoringConfig = createScoringConfig(config.retrieval);
-				const [vectorCandidates, lexicalCandidates] = await Promise.all([store.vectorSearch({
-					...input,
-					embedding: queryEmbedding,
-					limit: candidateLimit,
-					minScore: 0
-				}), store.lexicalSearch({
-					...input,
-					limit: candidateLimit
-				})]);
-				const merged = /* @__PURE__ */ new Map();
-				for (const candidate of vectorCandidates) merged.set(candidate.memory.id, {
-					memory: candidate.memory,
-					vectorScore: candidate.vectorScore,
-					lexicalScore: scoreLexical(candidate.memory.content)
-				});
-				const lexicalOnly = lexicalCandidates.filter((candidate) => !merged.has(candidate.memory.id));
-				const lexicalOnlyEmbeddings = await store.getMemoryEmbeddings(lexicalOnly.map((candidate) => candidate.memory.id));
-				for (const candidate of lexicalCandidates) {
-					const existing = merged.get(candidate.memory.id);
-					if (existing) {
-						existing.lexicalScore = candidate.lexicalScore;
-						continue;
-					}
-					const embedding = lexicalOnlyEmbeddings.get(candidate.memory.id);
-					const similarity = embedding ? cosineSimilarity(embedding, queryEmbedding) : 0;
-					merged.set(candidate.memory.id, {
-						memory: candidate.memory,
-						vectorScore: Math.max(0, similarity),
-						lexicalScore: candidate.lexicalScore
-					});
-				}
-				const scored = Array.from(merged.values()).map((entry) => toScoredMemoryWithConfig(entry.memory, Math.max(0, entry.vectorScore), Math.max(0, entry.lexicalScore), input, scoringConfig)).filter((memory) => memory.score >= minScore).sort((a, b) => b.score - a.score).slice(0, limit);
-				await store.markMemoriesAccessed(scored.map((memory) => memory.id));
-				return scored;
-			}, (result) => ({ count: result.length }));
-		},
-		async buildContext(input) {
-			return observe(config, store.backend, "buildContext", { entityId: input.entityId }, async () => {
-				assertOpen();
-				validateBuildContextInput(input);
-				return buildContext({
-					input,
-					recall: (contextInput) => {
-						const recallInput = contextInputToRecallInput(contextInput);
-						return client.recall(input.signal === void 0 ? recallInput : {
-							...recallInput,
-							signal: input.signal
-						});
-					}
-				});
-			});
-		},
-		async forget(input) {
-			return observe(config, store.backend, "forget", {
-				entityId: input.entityId,
-				memoryId: input.memoryId
-			}, async () => {
-				assertOpen();
-				assertNonEmptyString(input.entityId, "entityId");
-				assertNonEmptyString(input.memoryId, "memoryId");
-				await ensureSchema();
-				if (!await store.deleteMemory(input.entityId, input.memoryId)) throw new MnemocyteError("Memory was not found.", "NOT_FOUND");
-				await recordAudit([auditEvent(input.entityId, "memory.deleted", { memoryId: input.memoryId })]);
-			});
-		},
-		async forgetAll(input) {
-			return observe(config, store.backend, "forgetAll", { entityId: input.entityId }, async () => {
-				assertOpen();
-				assertNonEmptyString(input.entityId, "entityId");
-				await ensureSchema();
-				const deletedCount = await store.deleteMemoriesForEntity(input.entityId);
-				await recordAudit([auditEvent(input.entityId, "entity.cleared", { count: deletedCount })]);
-				return deletedCount;
-			}, (count) => ({ count })).then(() => void 0);
-		},
-		async prune(input) {
-			return observe(config, store.backend, "prune", input.entityId === void 0 ? {} : { entityId: input.entityId }, async () => {
-				assertOpen();
-				validatePruneInput(input);
-				await ensureSchema();
-				const result = await store.prune(input);
-				if (result.deletedCount > 0 && input.entityId !== void 0 && result.dryRun === false) await recordAudit([auditEvent(input.entityId, "memory.pruned", { count: result.deletedCount })]);
-				return result;
-			}, (result) => ({ count: result.deletedCount }));
-		},
-		async findDuplicates(input) {
-			return observe(config, store.backend, "findDuplicates", { entityId: input.entityId }, async () => {
-				assertOpen();
-				validateFindDuplicatesInput(input);
-				await ensureEmbeddingCompatibility();
-				return (await store.findDuplicatePairs(input)).map(toDuplicatePair);
-			}, (result) => ({ count: result.length }));
-		},
-		async listAuditLog(input) {
-			return observe(config, store.backend, "listAuditLog", { entityId: input.entityId }, async () => {
-				assertOpen();
-				validateListAuditLogInput(input);
-				await ensureSchema();
-				return (await store.listAuditLog(input)).map((event) => ({
-					id: event.id,
-					entityId: event.entityId,
-					description: event.description,
-					metadata: cloneJsonObject(event.metadata),
-					timestamp: new Date(event.timestamp)
-				}));
-			}, (result) => ({ count: result.length }));
-		},
-		async stats(input) {
-			return observe(config, store.backend, "stats", input?.entityId ? { entityId: input.entityId } : {}, async () => {
-				assertOpen();
-				await ensureSchema();
-				return store.stats(input, /* @__PURE__ */ new Date());
-			});
-		},
-		experimental: { async consolidate(input) {
-			return observe(config, store.backend, "consolidate", {
-				entityId: input.entityId,
-				memoryId: input.survivorId
-			}, async () => {
-				assertOpen();
-				validateConsolidateInput(input);
-				await ensureSchema();
-				const survivor = await store.getMemory(input.entityId, input.survivorId);
-				if (!survivor) throw new MnemocyteError("Survivor memory was not found.", "NOT_FOUND");
-				if (survivor.supersededBy !== null) throw new MnemocyteError("Survivor memory is itself superseded.", "VALIDATION");
-				const targets = await store.loadConsolidationTargets(input.entityId, input.supersededIds);
-				const foundIds = new Set(targets.map((target) => target.id));
-				for (const id of input.supersededIds) if (!foundIds.has(id)) throw new MnemocyteError("Superseded memory was not found.", "NOT_FOUND");
-				const losers = targets.filter((target) => target.supersededBy === null);
-				if (losers.length === 0) return {
-					survivorId: survivor.id,
-					supersededCount: 0,
-					supersededIds: []
-				};
-				const result = await store.consolidate({
-					entityId: input.entityId,
-					survivorId: survivor.id,
-					survivorTags: survivor.tags,
-					supersededIds: losers.map((loser) => loser.id),
-					mergeTags: input.mergeTags !== false,
-					now: /* @__PURE__ */ new Date(),
-					auditEnabled: config.audit?.enabled === true
-				});
-				return {
-					survivorId: survivor.id,
-					supersededCount: result.supersededIds.length,
-					supersededIds: result.supersededIds
-				};
-			}, (result) => ({ count: result.supersededCount }));
-		} },
-		async close() {
-			return observe(config, store.backend, "close", {}, async () => {
-				if (!closed) {
-					closed = true;
-					await store.close();
-				}
-			});
-		}
-	};
-	return client;
-}
-//#endregion
+import { n as isMnemocyteError, t as MnemocyteError } from "./errors-DIPysVWl.mjs";
+import { _ as cloneJsonObject, a as assertEmbedder, c as validateRetrievalConfig, d as IMPORTANCE_RANK, f as cosineSimilarity, g as createEventId, h as cloneMemory, i as createMemoryClient, l as assertPruneFilterHasSelector, m as toVectorScore, n as unwrapMnemocyteStoreConfig, o as assertNonEmptyString, p as createLexicalScorer, r as memoryHasDependentsError, s as validateProviderResilienceConfig, v as throwIfAborted, y as parsePostgresDatabaseUrl } from "./store-config-BFFTm1sj.mjs";
 //#region src/memory/filters.ts
 function isExpired(memory, now) {
 	return memory.expiresAt !== null && memory.expiresAt.getTime() <= now.getTime();
 }
 /**
-* Test whether `memory` matches a {@link PruneInput}. All specified
+* Test whether `memory` matches a validated prune filter. All specified
 * selectors are AND-combined; unspecified selectors do not restrict.
 *
 * `now` is supplied by the caller so callers can share a consistent
@@ -1126,12 +49,6 @@ function matchesRecallFilter(memory, input, now) {
 }
 //#endregion
 //#region src/memory/in-memory.ts
-function cloneStoredMemory(memory) {
-	return {
-		...cloneMemory(memory),
-		embedding: [...memory.embedding]
-	};
-}
 function cloneAuditEvent(event) {
 	return {
 		id: event.id,
@@ -1141,6 +58,15 @@ function cloneAuditEvent(event) {
 		timestamp: new Date(event.timestamp)
 	};
 }
+function compareAuditPositions(a, b) {
+	const timestampDifference = a.timestamp.getTime() - b.timestamp.getTime();
+	if (timestampDifference !== 0) return timestampDifference;
+	if (a.id === b.id) return 0;
+	return a.id < b.id ? -1 : 1;
+}
+function assertNoDependentMemories(memories, targetIds) {
+	for (const memory of memories.values()) if (memory.supersededBy !== null && targetIds.has(memory.supersededBy)) throw memoryHasDependentsError();
+}
 function createInMemoryStore() {
 	const memories = /* @__PURE__ */ new Map();
 	const auditLog = [];
@@ -1151,19 +77,18 @@ function createInMemoryStore() {
 		async insertMemories(rows) {
 			const inserted = [];
 			for (const row of rows) {
-				const stored = cloneStoredMemory(row);
-				memories.set(stored.id, stored);
-				inserted.push(cloneMemory(stored));
+				memories.set(row.id, row);
+				inserted.push(cloneMemory(row));
 			}
 			return inserted;
 		},
 		async vectorSearch(input) {
 			const now = /* @__PURE__ */ new Date();
-			const minScore = input.minScore ?? 0;
+			const minVectorScore = input.minVectorScore ?? 0;
 			return Array.from(memories.values()).filter((memory) => matchesRecallFilter(memory, input, now)).map((memory) => ({
 				memory: cloneMemory(memory),
-				vectorScore: Math.max(0, cosineSimilarity(memory.embedding, input.embedding))
-			})).filter((candidate) => candidate.vectorScore >= minScore).sort((a, b) => b.vectorScore - a.vectorScore).slice(0, input.limit);
+				vectorScore: toVectorScore(cosineSimilarity(memory.embedding, input.embedding))
+			})).filter((candidate) => candidate.vectorScore >= minVectorScore).sort((a, b) => b.vectorScore - a.vectorScore).slice(0, input.limit);
 		},
 		async lexicalSearch(input) {
 			const now = /* @__PURE__ */ new Date();
@@ -1183,50 +108,82 @@ function createInMemoryStore() {
 		},
 		async markMemoriesAccessed(memoryIds) {
 			const now = /* @__PURE__ */ new Date();
+			const updates = [];
 			for (const id of memoryIds) {
 				const memory = memories.get(id);
 				if (memory) {
 					memory.lastAccessedAt = now;
 					memory.accessCount += 1;
 					memory.updatedAt = now;
+					updates.push({
+						id: memory.id,
+						lastAccessedAt: now,
+						accessCount: memory.accessCount,
+						updatedAt: now
+					});
 				}
 			}
+			return updates;
 		},
 		async deleteMemory(entityId, memoryId) {
 			const memory = memories.get(memoryId);
 			if (!memory || memory.entityId !== entityId) return false;
+			assertNoDependentMemories(memories, new Set([memoryId]));
 			return memories.delete(memoryId);
 		},
 		async deleteMemoriesForEntity(entityId) {
-			let deleted = 0;
-			for (const [id, memory] of memories) if (memory.entityId === entityId) {
-				memories.delete(id);
-				deleted += 1;
-			}
-			return deleted;
-		},
-		async prune(input) {
+			const targetIds = new Set(Array.from(memories.values()).filter((memory) => memory.entityId === entityId).map((memory) => memory.id));
+			assertNoDependentMemories(memories, targetIds);
+			for (const id of targetIds) memories.delete(id);
+			return targetIds.size;
+		},
+		async prune(input, options) {
+			throwIfAborted(options?.signal);
+			assertPruneFilterHasSelector(input);
 			const now = /* @__PURE__ */ new Date();
 			const matched = [];
-			for (const memory of memories.values()) if (matchesPruneFilter(memory, input, now)) matched.push(memory.id);
+			for (const memory of memories.values()) {
+				throwIfAborted(options?.signal);
+				if (matchesPruneFilter(memory, input, now)) matched.push(memory);
+			}
 			const dryRun = input.dryRun === true;
-			if (!dryRun) for (const id of matched) memories.delete(id);
+			let deletedByEntity = [];
+			if (!dryRun) {
+				throwIfAborted(options?.signal);
+				assertNoDependentMemories(memories, new Set(matched.map((memory) => memory.id)));
+				const deletedCounts = /* @__PURE__ */ new Map();
+				for (const memory of matched) {
+					memories.delete(memory.id);
+					deletedCounts.set(memory.entityId, (deletedCounts.get(memory.entityId) ?? 0) + 1);
+				}
+				deletedByEntity = Array.from(deletedCounts, ([entityId, deletedCount]) => ({
+					entityId,
+					deletedCount
+				})).sort((a, b) => a.entityId.localeCompare(b.entityId));
+			}
 			return {
 				matchedCount: matched.length,
 				deletedCount: dryRun ? 0 : matched.length,
-				dryRun
+				dryRun,
+				deletedByEntity
 			};
 		},
-		async findDuplicatePairs(input) {
+		async findDuplicatePairs(input, options) {
+			throwIfAborted(options?.signal);
 			const threshold = input.threshold ?? .95;
 			const limit = input.limit ?? 100;
 			const now = /* @__PURE__ */ new Date();
-			const candidates = Array.from(memories.values()).filter((memory) => matchesDuplicateFilter(memory, input, now));
+			const candidates = Array.from(memories.values()).filter((memory) => {
+				throwIfAborted(options?.signal);
+				return matchesDuplicateFilter(memory, input, now);
+			});
 			const pairs = [];
 			for (let i = 0; i < candidates.length; i += 1) {
+				throwIfAborted(options?.signal);
 				const a = candidates[i];
 				if (a === void 0) continue;
 				for (let j = i + 1; j < candidates.length; j += 1) {
+					throwIfAborted(options?.signal);
 					const b = candidates[j];
 					if (b === void 0) continue;
 					const similarity = Math.max(0, Math.min(1, cosineSimilarity(a.embedding, b.embedding)));
@@ -1243,27 +200,29 @@ function createInMemoryStore() {
 		async addAuditEvents(events) {
 			auditLog.push(...events.map(cloneAuditEvent));
 		},
-		async listAuditLog(input) {
+		async listAuditLog(input, options) {
+			throwIfAborted(options?.signal);
 			const limit = input.limit ?? 50;
-			return auditLog.map((event, idx) => ({
-				event,
-				idx
-			})).filter(({ event }) => {
+			return auditLog.filter((event) => {
+				throwIfAborted(options?.signal);
 				if (event.entityId !== input.entityId) return false;
 				if (input.before !== void 0 && event.timestamp.getTime() >= input.before.getTime()) return false;
 				if (input.after !== void 0 && event.timestamp.getTime() <= input.after.getTime()) return false;
+				if (input.beforeCursor !== void 0 && compareAuditPositions(event, input.beforeCursor) >= 0) return false;
+				if (input.afterCursor !== void 0 && compareAuditPositions(event, input.afterCursor) <= 0) return false;
 				return true;
 			}).sort((a, b) => {
-				const dt = b.event.timestamp.getTime() - a.event.timestamp.getTime();
-				return dt === 0 ? b.idx - a.idx : dt;
-			}).slice(0, limit).map(({ event }) => cloneAuditEvent(event));
+				return compareAuditPositions(b, a);
+			}).slice(0, limit).map(cloneAuditEvent);
 		},
-		async getMemory(entityId, memoryId) {
+		async getMemory(entityId, memoryId, options) {
+			throwIfAborted(options?.signal);
 			const memory = memories.get(memoryId);
 			return memory && memory.entityId === entityId ? cloneMemory(memory) : null;
 		},
-		async loadConsolidationTargets(entityId, ids) {
+		async loadConsolidationTargets(entityId, ids, options) {
 			return ids.flatMap((id) => {
+				throwIfAborted(options?.signal);
 				const memory = memories.get(id);
 				if (!memory || memory.entityId !== entityId) return [];
 				return [{
@@ -1273,40 +232,51 @@ function createInMemoryStore() {
 				}];
 			});
 		},
-		async consolidate(input) {
+		async consolidate(input, options) {
+			throwIfAborted(options?.signal);
 			const survivor = memories.get(input.survivorId);
+			if (!survivor || survivor.entityId !== input.entityId || survivor.supersededBy !== null) throw new MnemocyteError("Consolidation survivor changed before mutation.", "CONFLICT");
 			const newlySuperseded = [];
+			const targets = [];
 			for (const id of input.supersededIds) {
+				throwIfAborted(options?.signal);
 				const memory = memories.get(id);
 				if (!memory || memory.entityId !== input.entityId) continue;
-				if (memory.supersededBy !== null) continue;
-				memory.supersededBy = input.survivorId;
-				memory.supersededAt = input.now;
-				memory.updatedAt = input.now;
-				newlySuperseded.push(memory.id);
+				targets.push(memory);
 			}
-			if (survivor && input.mergeTags && newlySuperseded.length > 0) {
-				const mergedTags = new Set(input.survivorTags);
-				for (const id of newlySuperseded) {
-					const memory = memories.get(id);
-					if (memory) for (const tag of memory.tags) mergedTags.add(tag);
-				}
-				if (mergedTags.size !== survivor.tags.length) {
-					survivor.tags = [...mergedTags];
-					survivor.updatedAt = input.now;
+			if (targets.some((memory) => memory.supersededBy !== null && memory.supersededBy !== input.survivorId)) throw new MnemocyteError("Superseded memory already belongs to a different survivor.", "CONFLICT");
+			for (const memory of targets) if (memory.supersededBy === null) newlySuperseded.push(memory);
+			let mergedSurvivorTags;
+			if (input.mergeTags && newlySuperseded.length > 0) {
+				const mergedTags = new Set(survivor.tags);
+				for (const memory of newlySuperseded) {
+					throwIfAborted(options?.signal);
+					for (const tag of memory.tags) mergedTags.add(tag);
 				}
+				if (mergedTags.size !== survivor.tags.length) mergedSurvivorTags = [...mergedTags];
 			}
-			if (input.auditEnabled) for (const id of newlySuperseded) auditLog.push({
+			const auditEvents = input.auditEnabled ? newlySuperseded.map((memory) => ({
 				id: createEventId(),
 				entityId: input.entityId,
 				description: "memory.superseded",
 				metadata: {
-					memoryId: id,
+					memoryId: memory.id,
 					supersededBy: input.survivorId
 				},
 				timestamp: input.now
-			});
-			return { supersededIds: newlySuperseded };
+			})) : [];
+			throwIfAborted(options?.signal);
+			for (const memory of newlySuperseded) {
+				memory.supersededBy = input.survivorId;
+				memory.supersededAt = input.now;
+				memory.updatedAt = input.now;
+			}
+			if (mergedSurvivorTags) {
+				survivor.tags = mergedSurvivorTags;
+				survivor.updatedAt = input.now;
+			}
+			if (input.auditEnabled) auditLog.push(...auditEvents);
+			return { supersededIds: newlySuperseded.map((memory) => memory.id) };
 		},
 		async stats(input, now) {
 			const allMemories = Array.from(memories.values());
@@ -1339,611 +309,93 @@ function createInMemoryClient(config) {
 	return createMemoryClient(config, createInMemoryStore());
 }
 //#endregion
-//#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 MnemocyteError("Event insert returned no rows.", "DB");
-	return inserted;
-}
-async function listEvents(db, filter) {
-	return db.select().from(eventsTable).where(and(eq(eventsTable.entityId, filter.entityId), filter.before ? lt(eventsTable.timestamp, filter.before) : void 0, filter.after ? gt(eventsTable.timestamp, filter.after) : void 0)).orderBy(desc(eventsTable.timestamp)).limit(filter.limit ?? 50);
-}
-//#endregion
-//#region src/db/queries/memories.ts
-function vectorLiteral(embedding) {
-	return `[${embedding.map(formatVectorComponent).join(",")}]`;
-}
-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 (await db.delete(memoriesTable).where(and(eq(memoriesTable.entityId, entityId), eq(memoriesTable.id, memoryId))).returning({ id: memoriesTable.id })).length > 0;
-}
-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, tagsContainAll(filter.tags), filter.maxImportanceLevels && filter.maxImportanceLevels.length > 0 ? inArray(memoriesTable.importance, [...filter.maxImportanceLevels]) : void 0);
-}
-async function countPruneMatches(db, filter) {
-	return db.$count(memoriesTable, pruneConditions(filter));
-}
-async function pruneMemories(db, filter) {
-	return (await db.delete(memoriesTable).where(pruneConditions(filter)).returning({ id: memoriesTable.id })).length;
-}
-async function findDuplicatePairs(db, input) {
-	return (await db.execute(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}
-	`)).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 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;
-	await db.update(memoriesTable).set({
-		lastAccessedAt: now,
-		accessCount: sql`${memoriesTable.accessCount} + 1`,
-		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;
-	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",
-			1 - (embedding <=> ${embedding}::vector) 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 1 - (embedding <=> ${embedding}::vector) >= ${minScore}
-		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;
-}
-//#endregion
-//#region 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)
-	};
-}
-//#endregion
-//#region src/memory/postgres.ts
-const IMPORTANCE_LEVELS = [
-	"low",
-	"normal",
-	"high",
-	"critical"
-];
-const MIGRATION_ERROR_CODES = new Set([
-	"42P01",
-	"42703",
-	"42704",
-	"42883"
-]);
-function rowToAuditEvent(row) {
-	return {
-		id: row.id,
-		entityId: row.entityId,
-		description: row.description,
-		metadata: cloneJsonObject(row.metadata),
-		timestamp: 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 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);
-	}
-}
-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],
-		metadata: cloneJsonObject(memory.metadata),
-		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")) throw new MnemocyteError("mnemocyte_meta is missing. Apply the v0.2.0 migration or render a dimension-specific initial migration before using the Postgres backend.", "MIGRATION", error);
-			throw normalizePostgresError(error);
-		}
-		if (!meta) throw new MnemocyteError("mnemocyte_meta is missing the \"installation\" row. Apply the v0.2.0 migration or render a dimension-specific initial migration before using the Postgres backend.", "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");
-		schemaValidated = true;
+//#region src/memory/lazy-postgres.ts
+function createLazyPostgresStore(databaseUrl) {
+	let storePromise;
+	function loadStore() {
+		storePromise ??= import("./postgres-runtime-DxJxns07.mjs").then(({ createPostgresStoreFromUrl }) => createPostgresStoreFromUrl(databaseUrl));
+		return storePromise;
 	}
 	return {
 		backend: "postgres",
-		async ensureSchema() {},
-		ensureEmbeddingCompatibility,
+		async ensureSchema() {
+			return (await loadStore()).ensureSchema();
+		},
+		async ensureEmbeddingCompatibility(embedder) {
+			return (await loadStore()).ensureEmbeddingCompatibility(embedder);
+		},
 		async insertMemories(memories) {
-			return runPostgresOperation(async () => {
-				return (await insertMemories(handle.db, memories.map(toMemoryRow))).map(rowToMemory);
-			});
+			return (await loadStore()).insertMemories(memories);
 		},
 		async vectorSearch(input) {
-			return runPostgresOperation(async () => {
-				return (await vectorSearch(handle.db, input)).map((row) => ({
-					memory: rowToMemory(row),
-					vectorScore: row.vectorScore
-				}));
-			});
+			return (await loadStore()).vectorSearch(input);
 		},
 		async lexicalSearch(input) {
-			return runPostgresOperation(async () => {
-				return (await lexicalSearch(handle.db, input)).map((row) => ({
-					memory: rowToMemory(row),
-					lexicalScore: row.lexicalScore
-				}));
-			});
+			return (await loadStore()).lexicalSearch(input);
 		},
 		async getMemoryEmbeddings(memoryIds) {
-			return runPostgresOperation(() => getMemoryEmbeddings(handle.db, memoryIds));
+			return (await loadStore()).getMemoryEmbeddings(memoryIds);
 		},
 		async markMemoriesAccessed(memoryIds) {
-			return runPostgresOperation(() => markMemoriesAccessed(handle.db, memoryIds));
+			return (await loadStore()).markMemoriesAccessed(memoryIds);
 		},
 		async deleteMemory(entityId, memoryId) {
-			return runPostgresOperation(() => deleteMemory(handle.db, entityId, memoryId));
+			return (await loadStore()).deleteMemory(entityId, memoryId);
 		},
 		async deleteMemoriesForEntity(entityId) {
-			return runPostgresOperation(() => deleteMemoriesForEntity(handle.db, entityId));
+			return (await loadStore()).deleteMemoriesForEntity(entityId);
 		},
-		async prune(input) {
-			return runPostgresOperation(async () => {
-				const filter = toPruneFilter(input);
-				if (input.dryRun === true) return {
-					matchedCount: await countPruneMatches(handle.db, filter),
-					deletedCount: 0,
-					dryRun: true
-				};
-				const deletedCount = await pruneMemories(handle.db, filter);
-				return {
-					matchedCount: deletedCount,
-					deletedCount,
-					dryRun: false
-				};
-			});
+		async prune(input, options) {
+			return (await loadStore()).prune(input, options);
 		},
-		async findDuplicatePairs(input) {
-			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 }
-				})).map((row) => ({
-					a: rowToMemory(row.a),
-					b: rowToMemory(row.b),
-					similarity: Math.max(0, Math.min(1, row.similarity))
-				}));
-			});
+		async findDuplicatePairs(input, options) {
+			return (await loadStore()).findDuplicatePairs(input, options);
 		},
 		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
-				});
-			});
+			return (await loadStore()).addAuditEvents(events);
 		},
-		async listAuditLog(input) {
-			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 }
-				})).map(rowToAuditEvent);
-			});
+		async listAuditLog(input, options) {
+			return (await loadStore()).listAuditLog(input, options);
 		},
-		async getMemory(entityId, memoryId) {
-			return runPostgresOperation(async () => {
-				const row = await getMemoryById(handle.db, entityId, memoryId);
-				return row ? rowToMemory(row) : null;
-			});
+		async getMemory(entityId, memoryId, options) {
+			return (await loadStore()).getMemory(entityId, memoryId, options);
 		},
-		async loadConsolidationTargets(entityId, ids) {
-			return runPostgresOperation(() => loadConsolidationTargets(handle.db, entityId, ids));
+		async loadConsolidationTargets(entityId, ids, options) {
+			return (await loadStore()).loadConsolidationTargets(entityId, ids, options);
 		},
-		async consolidate(input) {
-			return runPostgresOperation(async () => {
-				return { supersededIds: await handle.db.transaction(async (tx) => {
-					const updated = await markMemoriesSuperseded(tx, {
-						survivorId: input.survivorId,
-						entityId: input.entityId,
-						ids: input.supersededIds,
-						now: input.now
-					});
-					const ids = updated.map((row) => row.id);
-					if (input.auditEnabled) for (const id of ids) await insertEvent(tx, {
-						id: createEventId(),
-						entityId: input.entityId,
-						description: "memory.superseded",
-						metadata: {
-							memoryId: id,
-							supersededBy: input.survivorId
-						},
-						timestamp: input.now
-					});
-					if (input.mergeTags && updated.length > 0) {
-						const mergedTags = new Set(input.survivorTags);
-						for (const row of updated) for (const tag of row.tags) mergedTags.add(tag);
-						if (mergedTags.size !== input.survivorTags.length) await setMemoryTags(tx, {
-							entityId: input.entityId,
-							memoryId: input.survivorId,
-							tags: [...mergedTags],
-							now: input.now
-						});
-					}
-					return ids;
-				}) };
-			});
+		async consolidate(input, options) {
+			return (await loadStore()).consolidate(input, options);
 		},
 		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);
-			});
+			return (await loadStore()).stats(input, now);
 		},
 		async close() {
-			return runPostgresOperation(() => handle.close());
+			return (await loadStore()).close();
 		}
 	};
 }
-function createPostgresClient(config, handle) {
-	return createMemoryClient(config, createPostgresStore(handle));
-}
 //#endregion
 //#region src/client.ts
 /**
 * Create a Mnemocyte client.
 *
-* When {@link MnemocyteConfig.databaseUrl} is provided, a Postgres-backed
-* client is returned (requires the `pgvector` extension and the bundled
-* migration applied). Otherwise an in-memory client is returned, intended
-* for tests, demos, and short-lived processes.
+* When {@link MnemocyteConfig.store} is provided, that adapter is used. When
+* {@link MnemocyteConfig.databaseUrl} is provided, a URL-owned Postgres client
+* is used (requires the `pgvector` extension and the bundled migrations).
+* When neither is supplied, an in-memory client is returned for tests, demos,
+* and short-lived processes.
 *
-* The returned client owns any underlying resources (e.g. the Postgres
-* connection pool). Call {@link MnemocyteClient.close} when finished to
-* release them.
+* Call {@link MnemocyteClient.close} when finished. URL-created database
+* resources are owned and closed by Mnemocyte; resources behind a supplied
+* store retain the ownership policy documented by that adapter.
 *
 * @param config - Client configuration. {@link MnemocyteConfig.embedder} is required.
 * @returns A {@link MnemocyteClient} instance.
 * @throws {MnemocyteError} With code `"CONFIG"` if `embedder`, retrieval
-* tuning, or the database URL is malformed, or `"VALIDATION"` if
-* `databaseUrl` is explicitly empty.
+* tuning, provider resilience, or the database URL is malformed or does not
+* use the `postgres:` / `postgresql:` protocol, or if `databaseUrl` and
+* `store` are both provided; or `"VALIDATION"` if `databaseUrl` is explicitly
+* empty.
 *
 * @example Postgres-backed client
 * ```ts
@@ -1956,10 +408,14 @@ function createPostgresClient(config, handle) {
 function createMnemocyte(config) {
 	assertEmbedder(config.embedder);
 	validateRetrievalConfig(config.retrieval);
+	validateProviderResilienceConfig(config.provider);
+	if (config.databaseUrl !== void 0 && config.store !== void 0) throw new MnemocyteError("databaseUrl and store cannot be provided together.", "CONFIG");
 	if (config.databaseUrl !== void 0) {
 		assertNonEmptyString(config.databaseUrl, "databaseUrl");
-		return createPostgresClient(config, createDatabase(config.databaseUrl));
+		parsePostgresDatabaseUrl(config.databaseUrl);
+		return createMemoryClient(config, createLazyPostgresStore(config.databaseUrl));
 	}
+	if (config.store !== void 0) return createMemoryClient(config, unwrapMnemocyteStoreConfig(config.store));
 	return createInMemoryClient(config);
 }
 //#endregion