@snoai/memory 0.0.0-stage → 1.0.1

package/dist/internal/engine/observability/observable-memory-store.js

@@ -0,0 +1,701 @@
+import { StorageError } from "../shared/errors.js";
+import { l as runWithMemoryAudit, u as runWithMemoryAuditSync } from "../../../runtime-audit-log-BCeujlEp.js";
+import { getSnoStationMemStateDir } from "../../contract/profile.js";
+import { b as MemoryStore } from "../../../store-nPql26YM.js";
+import { t as countEmbeddingTokens } from "../../../token-counter-BD1f48Km.js";
+import { isAbsolute } from "node:path";
+import { detectProjectId } from "@snoai/observability";
+//#region src/engine/observability/observable-memory-store.ts
+/** @file observable-memory-store.ts
+* @purpose Emits strict runtime audits and best-effort telemetry around memory operations.
+* @boundary Runtime audits fail closed; process telemetry never affects storage.
+*/
+const baseFetchMemoriesInOrder = MemoryStore.prototype.fetchMemoriesInOrder;
+const baseDeleteByIds = MemoryStore.prototype.deleteByIds;
+const baseBackfillMissingChunks = MemoryStore.prototype.backfillMissingChunks;
+var ObservableMemoryStore = class extends MemoryStore {
+	observability;
+	sessionUuidProvider;
+	embeddingConfig;
+	constructor(config, observability, sessionUuidProvider, embeddingConfig) {
+		super(config);
+		this.observability = observability;
+		this.sessionUuidProvider = sessionUuidProvider;
+		this.embeddingConfig = embeddingConfig;
+	}
+	async store(entry) {
+		try {
+			const result = await runWithMemoryAudit({
+				stateDir: getSnoStationMemStateDir(),
+				event: "memory_injected",
+				operation: "store",
+				scope: entry.projectId,
+				startedDetails: {
+					scope: entry.projectId,
+					category: entry.category,
+					count: 1
+				},
+				run: () => super.store(entry),
+				completedDetails: (stored) => ({
+					scope: stored.projectId,
+					category: stored.category,
+					lane: stored.lane,
+					count: 1,
+					memory_ids: [stored.id],
+					write_outcome: stored.storeWriteOutcome,
+					created_count: stored.storeWriteOutcome === "created" ? 1 : 0,
+					existing_count: stored.storeWriteOutcome === "existing" ? 1 : 0
+				})
+			});
+			if (this.observability.enabled) {
+				const sessionUuid = this.sessionUuidProvider();
+				this.observability.trackBestEffort("memory.write", () => this.emitWrite(result, sessionUuid));
+			}
+			return result;
+		} catch (error) {
+			this.observability.trackBestEffort("memory.write:throw", () => this.observability.emitError("memory.write:throw", error, this.sessionUuidProvider()));
+			throw error;
+		}
+	}
+	async storeAtomicExtractionChunk(input) {
+		const result = await super.storeAtomicExtractionChunk(input);
+		this.emitCreatedWrites(result.cardIds);
+		return result;
+	}
+	async applyTaskLifecycleBatchWithAtomicWrite(input) {
+		const result = await super.applyTaskLifecycleBatchWithAtomicWrite(input);
+		this.emitCreatedWrites(result.atomicFactWrite.cardIds);
+		return result;
+	}
+	emitCreatedWrites(ids) {
+		if (!this.observability.enabled) return;
+		const sessionUuid = this.sessionUuidProvider();
+		for (const id of ids) {
+			const entry = super.getById(id);
+			if (!entry) continue;
+			this.observability.trackBestEffort("memory.write", () => this.emitWrite(entry, sessionUuid));
+		}
+	}
+	async update(id, changes) {
+		try {
+			const result = await runWithMemoryAudit({
+				stateDir: getSnoStationMemStateDir(),
+				event: "memory_updated",
+				operation: "update",
+				startedDetails: {
+					memory_ids: [id],
+					requested_count: 1
+				},
+				run: () => super.update(id, changes),
+				completedDetails: (updated) => ({
+					memory_ids: updated ? [updated.id] : [],
+					requested_count: 1,
+					result_count: updated ? 1 : 0,
+					outcome: updated ? "updated" : "missing",
+					...updated ? { scope: updated.projectId } : {}
+				})
+			});
+			if (result && this.observability.enabled) {
+				const sessionUuid = this.sessionUuidProvider();
+				this.observability.trackBestEffort("memory.write", () => this.emitWrite(result, sessionUuid));
+			}
+			return result;
+		} catch (error) {
+			this.observability.trackBestEffort("memory.write:throw", () => this.observability.emitError("memory.write:throw", error, this.sessionUuidProvider()));
+			throw error;
+		}
+	}
+	async bulkStore(entries) {
+		try {
+			const requested = entries.filter((entry) => entry != null);
+			const results = await runWithMemoryAudit({
+				stateDir: getSnoStationMemStateDir(),
+				event: "memory_injected",
+				operation: "bulkStore",
+				startedDetails: { count: requested.length },
+				run: async () => await super.bulkStore(entries),
+				completedDetails: (stored) => {
+					const createdCount = stored.filter((entry) => entry.storeWriteOutcome === "created").length;
+					const existingCount = stored.length - createdCount;
+					const writeOutcome = createdCount === stored.length ? "created" : existingCount === stored.length ? "existing" : "mixed";
+					return {
+						scope: uniformValue(stored.map((entry) => entry.projectId)),
+						category: uniformValue(stored.map((entry) => entry.category)),
+						lane: uniformValue(stored.map((entry) => entry.lane)),
+						count: stored.length,
+						memory_ids: stored.map((entry) => entry.id),
+						write_outcome: writeOutcome,
+						created_count: createdCount,
+						existing_count: existingCount
+					};
+				}
+			});
+			if (this.observability.enabled) for (const entry of results) {
+				const sessionUuid = this.sessionUuidProvider();
+				this.observability.trackBestEffort("memory.write", () => this.emitWrite(entry, sessionUuid));
+			}
+			return results;
+		} catch (error) {
+			this.observability.trackBestEffort("memory.write:throw", () => this.observability.emitError("memory.write:throw", error, this.sessionUuidProvider()));
+			throw error;
+		}
+	}
+	async supersede(args) {
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_superseded",
+			operation: "supersede",
+			scope: args.create.projectId,
+			startedDetails: {
+				scope: args.create.projectId,
+				closed_memory_ids: args.closes.map((close) => close.id)
+			},
+			run: () => runWithMemoryAudit({
+				stateDir: getSnoStationMemStateDir(),
+				event: "memory_injected",
+				operation: "supersede",
+				scope: args.create.projectId,
+				startedDetails: {
+					scope: args.create.projectId,
+					count: 1
+				},
+				run: async () => await super.supersede(args),
+				completedDetails: (stored) => writeDetails(stored)
+			}),
+			completedDetails: (stored) => ({
+				scope: stored.projectId,
+				replacement_memory_id: stored.id,
+				closed_memory_ids: args.closes.map((close) => close.id),
+				write_outcome: stored.storeWriteOutcome
+			})
+		});
+	}
+	async createMergeWithRawLineage(args) {
+		const scope = args.rawSource.projectId;
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_superseded",
+			operation: "createMergeWithRawLineage",
+			scope,
+			startedDetails: {
+				scope,
+				closed_memory_ids: args.closeExisting.map((close) => close.id)
+			},
+			run: () => runWithMemoryAudit({
+				stateDir: getSnoStationMemStateDir(),
+				event: "memory_injected",
+				operation: "createMergeWithRawLineage",
+				scope,
+				startedDetails: {
+					scope,
+					count: 2
+				},
+				run: () => super.createMergeWithRawLineage(args),
+				completedDetails: (result) => ({
+					scope,
+					count: 2,
+					memory_ids: [result.rawSource.id, result.merged.id],
+					write_outcome: "created",
+					created_count: 2,
+					existing_count: 0
+				})
+			}),
+			completedDetails: (result) => ({
+				scope,
+				replacement_memory_id: result.merged.id,
+				closed_memory_ids: [result.rawSource.id, ...args.closeExisting.map((close) => close.id)],
+				write_outcome: "created"
+			})
+		});
+	}
+	async createEventAndSupersede(args) {
+		const scope = args.replacement.projectId;
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_superseded",
+			operation: "createEventAndSupersede",
+			scope,
+			startedDetails: {
+				scope,
+				closed_memory_ids: args.closeExisting.map((close) => close.id)
+			},
+			run: () => runWithMemoryAudit({
+				stateDir: getSnoStationMemStateDir(),
+				event: "memory_injected",
+				operation: "createEventAndSupersede",
+				scope,
+				startedDetails: {
+					scope,
+					count: 2
+				},
+				run: () => super.createEventAndSupersede(args),
+				completedDetails: (result) => ({
+					scope,
+					count: 2,
+					memory_ids: [result.event.id, result.replacement.id],
+					write_outcome: "created",
+					created_count: 2,
+					existing_count: 0
+				})
+			}),
+			completedDetails: (result) => ({
+				scope,
+				replacement_memory_id: result.replacement.id,
+				closed_memory_ids: args.closeExisting.map((close) => close.id),
+				write_outcome: "created"
+			})
+		});
+	}
+	async importEntry(entry) {
+		let existed = false;
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_injected",
+			operation: "importEntry",
+			scope: entry.projectId,
+			startedDetails: {
+				scope: entry.projectId,
+				memory_ids: [entry.id],
+				count: 1
+			},
+			run: async () => {
+				existed = await super.hasId(entry.id);
+				return super.importEntry(entry);
+			},
+			completedDetails: (stored) => {
+				const writeOutcome = existed ? "existing" : "created";
+				return {
+					scope: stored.projectId,
+					category: stored.category,
+					lane: stored.lane,
+					count: 1,
+					memory_ids: [stored.id],
+					write_outcome: writeOutcome,
+					created_count: existed ? 0 : 1,
+					existing_count: existed ? 1 : 0
+				};
+			}
+		});
+	}
+	async backfillMissingChunks() {
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_updated",
+			operation: "backfillMissingChunks",
+			run: () => baseBackfillMissingChunks.call(this),
+			completedDetails: (rewrittenRows) => ({
+				outcome: rewrittenRows === 0 ? "noop" : "chunks_backfilled",
+				rewritten_rows: rewrittenRows
+			})
+		});
+	}
+	findByContentHash(hash, projectId) {
+		return this.auditEntryReadSync("findByContentHash", projectId, () => super.findByContentHash(hash, projectId));
+	}
+	findByExtractionIdempotencyKey(projectId, key) {
+		return this.auditEntryReadSync("findByExtractionIdempotencyKey", projectId, () => super.findByExtractionIdempotencyKey(projectId, key));
+	}
+	/**
+	* Audited like a write, because it is one — a preserved failure that leaves no
+	* audit trail is a write nobody can find afterwards.
+	*/
+	recordUnplacedCandidate(input) {
+		return runWithMemoryAuditSync({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_injected",
+			operation: "recordUnplacedCandidate",
+			scope: input.projectId,
+			startedDetails: {
+				scope: input.projectId,
+				category: input.category,
+				count: 1
+			},
+			run: () => super.recordUnplacedCandidate(input),
+			completedDetails: (result) => ({
+				scope: input.projectId,
+				category: input.category,
+				count: 1,
+				memory_ids: [result.id],
+				write_outcome: result.created ? "created" : "existing",
+				created_count: result.created ? 1 : 0,
+				existing_count: result.created ? 0 : 1
+			})
+		});
+	}
+	getById(id) {
+		return this.auditEntryReadSync("getById", void 0, () => super.getById(id), [id]);
+	}
+	getByFactKey(projectId, factKey) {
+		return this.auditEntryReadSync("getByFactKey", projectId, () => super.getByFactKey(projectId, factKey), []);
+	}
+	async hasId(id) {
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_read",
+			operation: "hasId",
+			startedDetails: {
+				memory_ids: [id],
+				requested_count: 1
+			},
+			run: () => super.hasId(id),
+			completedDetails: (found) => ({
+				memory_ids: found ? [id] : [],
+				requested_count: 1,
+				result_count: found ? 1 : 0,
+				found
+			})
+		});
+	}
+	async searchChunksSemantic(vector, opts) {
+		return this.auditSearch("searchChunksSemantic", opts, () => super.searchChunksSemantic(vector, opts));
+	}
+	async searchChunksKeyword(query, opts) {
+		return this.auditSearch("searchChunksKeyword", opts, () => super.searchChunksKeyword(query, opts));
+	}
+	async searchSemantic(vector, opts = {}) {
+		return this.auditMemorySearch("searchSemantic", opts, () => super.searchSemantic(vector, opts));
+	}
+	async searchKeyword(query, opts = {}) {
+		return this.auditMemorySearch("searchKeyword", opts, () => super.searchKeyword(query, opts));
+	}
+	fetchMemoriesInOrder(memoryIds, opts = {}) {
+		return runWithMemoryAuditSync({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_read",
+			operation: "fetchMemoriesInOrder",
+			startedDetails: {
+				memory_ids: memoryIds,
+				requested_count: memoryIds.length
+			},
+			run: () => baseFetchMemoriesInOrder.call(this, memoryIds, opts),
+			completedDetails: (rows) => ({
+				memory_ids: rows.map((row) => row.id),
+				requested_count: memoryIds.length,
+				result_count: rows.length
+			})
+		});
+	}
+	getVectorsByIds(ids) {
+		return runWithMemoryAuditSync({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_read",
+			operation: "getVectorsByIds",
+			startedDetails: {
+				memory_ids: ids,
+				requested_count: ids.length
+			},
+			run: () => super.getVectorsByIds(ids),
+			completedDetails: (vectors) => ({
+				memory_ids: [...vectors.keys()],
+				requested_count: ids.length,
+				result_count: vectors.size
+			})
+		});
+	}
+	getChunksByParent(memoryIds, facetPolicy) {
+		return runWithMemoryAuditSync({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_read",
+			operation: "getChunksByParent",
+			startedDetails: {
+				memory_ids: memoryIds,
+				requested_count: memoryIds.length
+			},
+			run: () => super.getChunksByParent(memoryIds, facetPolicy),
+			completedDetails: (chunks) => ({
+				memory_ids: [...chunks.keys()],
+				requested_count: memoryIds.length,
+				result_count: chunks.size
+			})
+		});
+	}
+	async list(opts = {}) {
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_read",
+			operation: "list",
+			scope: opts.projectId,
+			startedDetails: {
+				scope: opts.projectId,
+				requested_count: opts.limit
+			},
+			run: () => super.list(opts),
+			completedDetails: (entries) => ({
+				...opts.projectId ? { scope: opts.projectId } : {},
+				memory_ids: entries.map((entry) => entry.id),
+				result_count: entries.length
+			})
+		});
+	}
+	async listReflectionItems(opts) {
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_read",
+			operation: "listReflectionItems",
+			startedDetails: { requested_count: opts.limit },
+			run: () => super.listReflectionItems(opts),
+			completedDetails: (entries) => ({
+				memory_ids: entries.map((entry) => entry.id),
+				result_count: entries.length
+			})
+		});
+	}
+	async getMemoryMetadata(memoryId) {
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_read",
+			operation: "getMemoryMetadata",
+			startedDetails: {
+				memory_ids: [memoryId],
+				requested_count: 1
+			},
+			run: () => super.getMemoryMetadata(memoryId),
+			completedDetails: (metadata) => ({
+				memory_ids: metadata ? [memoryId] : [],
+				requested_count: 1,
+				result_count: metadata ? 1 : 0,
+				found: metadata !== void 0
+			})
+		});
+	}
+	async updateTier(memoryId, newTier, options) {
+		await this.auditMetadataMutation("updateTier", [memoryId], () => super.updateTier(memoryId, newTier, options));
+	}
+	async updateMetadata(memoryId, patch) {
+		await this.auditMetadataMutation("updateMetadata", [memoryId], () => super.updateMetadata(memoryId, patch));
+	}
+	async applyMetadataDelta(memoryId, deltaFn) {
+		await this.auditMetadataMutation("applyMetadataDelta", [memoryId], () => super.applyMetadataDelta(memoryId, deltaFn));
+	}
+	async applyMetadataDeltas(entries) {
+		await this.auditMetadataMutation("applyMetadataDeltas", entries.map((entry) => entry.memoryId), () => super.applyMetadataDeltas(entries));
+	}
+	async resolveReflectionItem(memoryId, opts) {
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_updated",
+			operation: "resolveReflectionItem",
+			startedDetails: {
+				memory_ids: [memoryId],
+				requested_count: 1
+			},
+			run: () => super.resolveReflectionItem(memoryId, opts),
+			completedDetails: (outcome) => ({
+				memory_ids: outcome === "not_found" ? [] : [memoryId],
+				requested_count: 1,
+				result_count: outcome === "not_found" ? 0 : 1,
+				outcome
+			})
+		});
+	}
+	async delete(idOrPrefix, options) {
+		return (await runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_deleted",
+			operation: "delete",
+			startedDetails: { delete_reason: options?.deleteReason },
+			run: () => this.writeMutex.runExclusive(() => {
+				const ids = this.resolveDeleteIds(idOrPrefix);
+				if (ids.length > 0) baseDeleteByIds.call(this, ids, options);
+				return ids;
+			}),
+			completedDetails: (ids) => ({
+				deleted_memory_ids: ids,
+				delete_reason: options?.deleteReason,
+				count: ids.length,
+				outcome: deleteOutcome(ids.length)
+			})
+		})).length;
+	}
+	async deleteMany(ids, options) {
+		return (await runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_deleted",
+			operation: "deleteMany",
+			startedDetails: {
+				delete_reason: options?.deleteReason,
+				count: ids.length
+			},
+			run: () => this.writeMutex.runExclusive(() => {
+				const existingIds = this.readExistingMemoryIds(ids);
+				if (existingIds.length > 0) baseDeleteByIds.call(this, existingIds, options);
+				return existingIds;
+			}),
+			completedDetails: (existingIds) => ({
+				deleted_memory_ids: existingIds,
+				delete_reason: options?.deleteReason,
+				count: existingIds.length,
+				outcome: deleteOutcome(existingIds.length)
+			})
+		})).length;
+	}
+	deleteByIds(ids, options) {
+		runWithMemoryAuditSync({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_deleted",
+			operation: "deleteByIds",
+			startedDetails: {
+				deleted_memory_ids: ids,
+				count: ids.length
+			},
+			run: () => {
+				const existingIds = ids.filter((id) => super.getById(id) !== void 0);
+				baseDeleteByIds.call(this, ids, options);
+				return existingIds;
+			},
+			completedDetails: (deletedIds) => ({
+				deleted_memory_ids: deletedIds,
+				delete_reason: options?.deleteReason,
+				count: deletedIds.length,
+				outcome: deleteOutcome(deletedIds.length)
+			})
+		});
+	}
+	async bulkDelete(filter, options) {
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_deleted",
+			operation: "bulkDelete",
+			scope: filter.projectId,
+			startedDetails: {
+				scope: filter.projectId,
+				delete_reason: options?.deleteReason
+			},
+			run: () => super.bulkDelete(filter, options),
+			completedDetails: (result) => ({
+				...filter.projectId ? { scope: filter.projectId } : {},
+				delete_reason: options?.deleteReason,
+				count: result.deleted,
+				outcome: deleteOutcome(result.deleted)
+			})
+		});
+	}
+	auditEntryReadSync(operation, scope, run, requestedIds = []) {
+		return runWithMemoryAuditSync({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_read",
+			operation,
+			scope,
+			startedDetails: {
+				scope,
+				memory_ids: requestedIds,
+				requested_count: 1
+			},
+			run,
+			completedDetails: (entry) => ({
+				...entry ? {
+					scope: entry.projectId,
+					memory_ids: [entry.id]
+				} : {},
+				requested_count: 1,
+				result_count: entry ? 1 : 0,
+				found: entry !== void 0
+			})
+		});
+	}
+	async auditSearch(operation, opts, run) {
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_searched",
+			operation,
+			startedDetails: { requested_count: opts.limit },
+			run,
+			completedDetails: (results) => ({
+				requested_count: opts.limit,
+				result_count: results.length,
+				memory_ids: results.map((result) => result.parentMemoryId)
+			})
+		});
+	}
+	async auditMemorySearch(operation, opts, run) {
+		return runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_searched",
+			operation,
+			startedDetails: { requested_count: opts.limit },
+			run,
+			completedDetails: (results) => ({
+				requested_count: opts.limit,
+				result_count: results.length,
+				memory_ids: results.map((result) => result.entry.id)
+			})
+		});
+	}
+	async auditMetadataMutation(operation, memoryIds, run) {
+		let existingIds = [];
+		await runWithMemoryAudit({
+			stateDir: getSnoStationMemStateDir(),
+			event: "memory_updated",
+			operation,
+			startedDetails: {
+				memory_ids: memoryIds,
+				requested_count: memoryIds.length
+			},
+			run: async () => {
+				existingIds = memoryIds.filter((id) => super.getById(id) !== void 0);
+				await run();
+			},
+			completedDetails: () => ({
+				memory_ids: existingIds,
+				requested_count: memoryIds.length,
+				result_count: existingIds.length,
+				outcome: existingIds.length === 0 ? "missing" : "updated"
+			})
+		});
+	}
+	resolveDeleteIds(idOrPrefix) {
+		if (!idOrPrefix.endsWith("*")) return this.readExistingMemoryIds([idOrPrefix]);
+		const rawPrefix = idOrPrefix.slice(0, -1);
+		if (rawPrefix.length < 4) throw new StorageError(`Wildcard delete prefix too short (min 4 chars): "${rawPrefix}*"`);
+		const escapedPrefix = rawPrefix.replace(/[\\%_]/g, "\\$&");
+		return this.sqlite.prepare("SELECT id FROM nodix_memories WHERE id LIKE ? ESCAPE '\\'").all(`${escapedPrefix}%`).map((row) => row.id);
+	}
+	readExistingMemoryIds(ids) {
+		const uniqueIds = Array.from(new Set(ids));
+		const existingIds = [];
+		for (let index = 0; index < uniqueIds.length; index += 500) {
+			const batch = uniqueIds.slice(index, index + 500);
+			const rows = this.sqlite.prepare("SELECT id FROM nodix_memories WHERE id IN (SELECT value FROM json_each(?))").all(JSON.stringify(batch));
+			existingIds.push(...rows.map((row) => row.id));
+		}
+		return existingIds;
+	}
+	async emitWrite(entry, sessionUuid) {
+		const keyHash = this.observability.hashText(entry.contentHash || entry.id);
+		if (!keyHash) return;
+		const tokens = await countEmbeddingTokens(entry.text, this.embeddingConfig);
+		await this.observability.emit({
+			eventType: "memory.write",
+			sessionUuid,
+			...isAbsolute(entry.projectId) ? { scope: { project_id: detectProjectId(entry.projectId) } } : {},
+			payload: {
+				key_hash: keyHash,
+				byte_len: Buffer.byteLength(entry.text, "utf8"),
+				content_tokens: tokens.count,
+				tokens_method: tokens.method
+			}
+		});
+	}
+};
+function uniformValue(values) {
+	const first = values[0];
+	if (first === void 0) return "mixed";
+	return values.every((value) => value === first) ? first : "mixed";
+}
+function deleteOutcome(deletedCount) {
+	return deletedCount > 0 ? "deleted" : "noop";
+}
+function writeDetails(entry) {
+	return {
+		scope: entry.projectId,
+		category: entry.category,
+		lane: entry.lane,
+		count: 1,
+		memory_ids: [entry.id],
+		write_outcome: entry.storeWriteOutcome,
+		created_count: entry.storeWriteOutcome === "created" ? 1 : 0,
+		existing_count: entry.storeWriteOutcome === "existing" ? 1 : 0
+	};
+}
+//#endregion
+export { ObservableMemoryStore };

package/dist/internal/engine/observability/observable-retriever.d.ts

@@ -0,0 +1,2 @@
+import { t as ObservableMemoryRetriever } from "../../../observable-retriever-Cooc62Qw.js";
+export { ObservableMemoryRetriever };