@snoai/memory 0.0.0-stage → 1.0.0

package/dist/memory-scope-policy-1gg5QlWZ.d.ts

@@ -0,0 +1,67 @@
+//#region src/engine/security/scope-policy-types.d.ts
+/** @file scope-policy-types.ts
+ * @purpose Defines scope policy contracts, defaults, and identifier patterns.
+ * @boundary Types and static scope constants only.
+ */
+interface ScopeDefinition {
+  description?: string;
+  metadata?: Record<string, unknown>;
+}
+interface ScopeConfig {
+  default: string;
+  definitions: Record<string, ScopeDefinition>;
+  agentAccess: Record<string, string[]>;
+  extraAccessibleScopes: string[];
+}
+interface ScopePolicy {
+  getAccessibleScopes(agentId?: string): string[];
+  /** Store-layer filter: undefined = full bypass, [] = deny-all, array = restrict. */
+  getScopeFilter?(agentId?: string): string[] | undefined;
+  getDefaultScope(agentId?: string): string;
+  isAccessible(scope: string, agentId?: string): boolean;
+  validateScope(scope: string): boolean;
+  getAllScopes(): string[];
+  getScopeDefinition(scope: string): ScopeDefinition | undefined;
+}
+declare const DEFAULT_SCOPE_CONFIG: ScopeConfig;
+declare const SCOPE_PATTERNS: {
+  readonly GLOBAL: "global";
+  readonly AGENT: (agentId: string) => string;
+  readonly CUSTOM: (name: string) => string;
+  readonly REFLECTION: (agentId: string) => string;
+  readonly PROJECT: (projectId: string) => string;
+  readonly USER: (userId: string) => string;
+};
+//#endregion
+//#region src/engine/security/memory-scope-policy.d.ts
+declare class MemoryScopePolicy implements ScopePolicy {
+  private config;
+  private readonly warn?;
+  constructor(config?: Partial<ScopeConfig>, warn?: (message: string, fields?: Record<string, unknown>) => void);
+  private validateConfiguration;
+  private isBuiltInScope;
+  getAccessibleScopes(agentId?: string): string[];
+  resolveAgentScopes(agentId?: string): string[];
+  getScopeFilter(agentId?: string): string[] | undefined;
+  getDefaultScope(agentId?: string): string;
+  isAccessible(scope: string, agentId?: string): boolean;
+  validateScope(scope: string): boolean;
+  getAllScopes(): string[];
+  getScopeDefinition(scope: string): ScopeDefinition | undefined;
+  addScopeDefinition(scope: string, definition: ScopeDefinition): void;
+  removeScopeDefinition(scope: string): boolean;
+  setAgentAccess(agentId: string, scopes: string[]): void;
+  removeAgentAccess(agentId: string): boolean;
+  setExtraAccessibleScopes(scopes: string[]): void;
+  private validateScopeFormat;
+  exportConfig(): ScopeConfig;
+  importConfig(config: Partial<ScopeConfig>): void;
+  getStats(): {
+    totalScopes: number;
+    agentsWithCustomAccess: number;
+    scopesByType: Record<string, number>;
+  };
+}
+declare function createScopePolicy(config?: Partial<ScopeConfig>, warn?: (message: string, fields?: Record<string, unknown>) => void): MemoryScopePolicy;
+//#endregion
+export { ScopeConfig as a, SCOPE_PATTERNS as i, createScopePolicy as n, ScopeDefinition as o, DEFAULT_SCOPE_CONFIG as r, ScopePolicy as s, MemoryScopePolicy as t };

package/dist/memory-scope-policy-DICSCURA.js

@@ -0,0 +1,283 @@
+import { createLogger } from "@snoai/utils/logger";
+//#region src/engine/security/scope-policy-types.ts
+const DEFAULT_SCOPE_CONFIG = {
+	default: "global",
+	definitions: { global: { description: "Shared knowledge across all agents" } },
+	agentAccess: {},
+	extraAccessibleScopes: []
+};
+const SCOPE_PATTERNS = {
+	GLOBAL: "global",
+	AGENT: (agentId) => `agent:${agentId}`,
+	CUSTOM: (name) => `custom:${name}`,
+	REFLECTION: (agentId) => `reflection:agent:${agentId}`,
+	PROJECT: (projectId) => `project:${projectId}`,
+	USER: (userId) => `user:${userId}`
+};
+//#endregion
+//#region src/engine/security/scope-identity.ts
+/** @file scope-identity.ts
+* @purpose Normalizes agent identities and configured access lists for scope policy.
+* @boundary Identity parsing, bypass detection, and config normalization only.
+*/
+const log = createLogger("sno-station-mem:scopes");
+const SYSTEM_BYPASS_IDS = /* @__PURE__ */ new Set(["system", "undefined"]);
+const warnedLegacyFallbackBypassIds = /* @__PURE__ */ new Set();
+const warnedLegacyStringBypassIds = /* @__PURE__ */ new Set();
+function normalizeExtraAccessibleScopes(extraAccessibleScopes) {
+	if (!Array.isArray(extraAccessibleScopes)) return [];
+	const normalized = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const rawScope of extraAccessibleScopes) {
+		if (typeof rawScope !== "string") continue;
+		const scope = rawScope.trim();
+		if (!scope || seen.has(scope)) continue;
+		seen.add(scope);
+		normalized.push(scope);
+	}
+	return normalized;
+}
+function isSystemBypassId(agentId) {
+	if (typeof agentId !== "string") return false;
+	if (agentId === "undefined" && !warnedLegacyStringBypassIds.has(agentId)) {
+		warnedLegacyStringBypassIds.add(agentId);
+		log.warn("legacy string agentId bypass detected", { reason_code: "legacy_undefined_string" }, {
+			event_name: "sno_station_mem.scope-identity.legacy.string.agentid.bypass.detected",
+			file: "packages/memory/src/engine/security/scope-identity.ts",
+			function: "isSystemBypassId",
+			site_id: "scope-identity.isSystemBypassId.1d89371f35"
+		});
+	}
+	return SYSTEM_BYPASS_IDS.has(agentId);
+}
+/** @internal Exported for tests that need to reset legacy warning throttles. */
+function _resetLegacyFallbackWarningState() {
+	warnedLegacyFallbackBypassIds.clear();
+	warnedLegacyStringBypassIds.clear();
+}
+function shouldWarnLegacyFallbackBypassId(agentId) {
+	if (warnedLegacyFallbackBypassIds.has(agentId)) return false;
+	warnedLegacyFallbackBypassIds.add(agentId);
+	return true;
+}
+function parseAgentIdFromSessionKey(sessionKey) {
+	if (!sessionKey) return void 0;
+	const sk = sessionKey.trim();
+	if (!sk.startsWith("agent:")) return void 0;
+	const rest = sk.slice(6);
+	const colonIdx = rest.indexOf(":");
+	const candidate = (colonIdx === -1 ? rest : rest.slice(0, colonIdx)).trim();
+	if (!candidate || isSystemBypassId(candidate)) return void 0;
+	return candidate;
+}
+function withOwnReflectionScope(scopes, agentId) {
+	const reflectionScope = SCOPE_PATTERNS.REFLECTION(agentId);
+	return scopes.includes(reflectionScope) ? [...scopes] : [...scopes, reflectionScope];
+}
+function normalizeAgentAccessMap(agentAccess) {
+	const normalized = {};
+	if (!agentAccess) return normalized;
+	for (const [rawAgentId, scopes] of Object.entries(agentAccess)) {
+		const agentId = rawAgentId.trim();
+		if (!agentId) continue;
+		normalized[agentId] = Array.isArray(scopes) ? [...scopes] : [];
+	}
+	return normalized;
+}
+//#endregion
+//#region src/engine/security/memory-scope-policy.ts
+/** @file memory-scope-policy.ts
+* @purpose Implements mutable memory scope policy management.
+* @boundary Scope config validation and access decisions only.
+*/
+var MemoryScopePolicy = class {
+	config;
+	warn;
+	constructor(config = {}, warn) {
+		this.warn = warn;
+		this.config = {
+			default: config.default ?? DEFAULT_SCOPE_CONFIG.default,
+			definitions: {
+				...DEFAULT_SCOPE_CONFIG.definitions,
+				...config.definitions ?? {}
+			},
+			agentAccess: {
+				...normalizeAgentAccessMap(DEFAULT_SCOPE_CONFIG.agentAccess),
+				...normalizeAgentAccessMap(config.agentAccess)
+			},
+			extraAccessibleScopes: normalizeExtraAccessibleScopes(config.extraAccessibleScopes ?? DEFAULT_SCOPE_CONFIG.extraAccessibleScopes)
+		};
+		if (!this.config.definitions.global) this.config.definitions.global = { description: "Shared knowledge across all agents" };
+		this.validateConfiguration();
+	}
+	validateConfiguration() {
+		if (!this.config.definitions[this.config.default] && !this.isBuiltInScope(this.config.default)) throw new Error(`Default scope '${this.config.default}' not found in definitions or built-in scopes`);
+		for (const [agentId, scopes] of Object.entries(this.config.agentAccess)) {
+			const trimmedAgentId = agentId.trim();
+			if (isSystemBypassId(trimmedAgentId)) throw new Error(`Reserved bypass agent ID '${trimmedAgentId}' cannot have explicit access configured.`);
+			for (const scope of scopes) if (!this.config.definitions[scope] && !this.isBuiltInScope(scope)) this.warn?.("invalid_scope_in_agent_access", {
+				agentId,
+				scope
+			});
+		}
+		for (const scope of this.config.extraAccessibleScopes) if (!this.config.definitions[scope] && !this.isBuiltInScope(scope)) this.warn?.("invalid_scope_in_extra_accessible_scopes", { scope });
+	}
+	isBuiltInScope(scope) {
+		if (scope === "global") return true;
+		return [
+			"agent:",
+			"custom:",
+			"project:",
+			"user:",
+			"reflection:"
+		].some((p) => scope.startsWith(p) && scope.length > p.length);
+	}
+	getAccessibleScopes(agentId) {
+		const mergeExtraAccessibleScopes = (scopes) => {
+			if (this.config.extraAccessibleScopes.length === 0) return scopes;
+			const merged = [...scopes];
+			for (const scope of this.config.extraAccessibleScopes) if (!merged.includes(scope)) merged.push(scope);
+			return merged;
+		};
+		if (isSystemBypassId(agentId)) return mergeExtraAccessibleScopes(this.getAllScopes());
+		if (!agentId?.trim()) return mergeExtraAccessibleScopes([this.config.default]);
+		const normalizedAgentId = agentId.trim();
+		if (isSystemBypassId(normalizedAgentId)) return mergeExtraAccessibleScopes(this.getAllScopes());
+		const explicitAccess = this.config.agentAccess[normalizedAgentId];
+		if (explicitAccess) return mergeExtraAccessibleScopes(withOwnReflectionScope(explicitAccess, normalizedAgentId));
+		return mergeExtraAccessibleScopes(withOwnReflectionScope(["global", SCOPE_PATTERNS.AGENT(normalizedAgentId)], normalizedAgentId));
+	}
+	resolveAgentScopes(agentId) {
+		return this.getAccessibleScopes(agentId);
+	}
+	getScopeFilter(agentId) {
+		if (isSystemBypassId(agentId)) return void 0;
+		if (!agentId?.trim()) return [this.config.default];
+		const normalizedAgentId = agentId.trim();
+		if (isSystemBypassId(normalizedAgentId)) return void 0;
+		return this.getAccessibleScopes(normalizedAgentId);
+	}
+	getDefaultScope(agentId) {
+		if (!agentId?.trim()) return this.config.default;
+		const normalizedAgentId = agentId.trim();
+		if (isSystemBypassId(normalizedAgentId)) throw new Error(`Reserved bypass agent ID '${normalizedAgentId}' must provide an explicit write scope.`);
+		const agentScope = SCOPE_PATTERNS.AGENT(normalizedAgentId);
+		return this.getAccessibleScopes(normalizedAgentId).includes(agentScope) ? agentScope : this.config.default;
+	}
+	isAccessible(scope, agentId) {
+		if (isSystemBypassId(agentId)) return this.validateScope(scope);
+		return this.getAccessibleScopes(agentId).includes(scope);
+	}
+	validateScope(scope) {
+		if (typeof scope !== "string" || scope.trim().length === 0) return false;
+		const trimmed = scope.trim();
+		return this.config.definitions[trimmed] !== void 0 || this.isBuiltInScope(trimmed);
+	}
+	getAllScopes() {
+		return Object.keys(this.config.definitions);
+	}
+	getScopeDefinition(scope) {
+		return this.config.definitions[scope];
+	}
+	addScopeDefinition(scope, definition) {
+		if (!this.validateScopeFormat(scope)) throw new Error(`Invalid scope format: ${scope}`);
+		this.config.definitions[scope] = definition;
+	}
+	removeScopeDefinition(scope) {
+		if (scope === "global") throw new Error("Cannot remove global scope");
+		if (!this.config.definitions[scope]) return false;
+		delete this.config.definitions[scope];
+		for (const [agentId, scopes] of Object.entries(this.config.agentAccess)) {
+			const filtered = scopes.filter((s) => s !== scope);
+			if (filtered.length !== scopes.length) this.config.agentAccess[agentId] = filtered;
+		}
+		return true;
+	}
+	setAgentAccess(agentId, scopes) {
+		if (!agentId || typeof agentId !== "string") throw new Error("Invalid agent ID");
+		const normalizedAgentId = agentId.trim();
+		if (!normalizedAgentId) throw new Error("Invalid agent ID");
+		if (isSystemBypassId(normalizedAgentId)) throw new Error(`Reserved bypass agent ID cannot have explicit access configured: ${agentId}`);
+		for (const scope of scopes) if (!this.validateScope(scope)) throw new Error(`Invalid scope: ${scope}`);
+		this.config.agentAccess[normalizedAgentId] = [...scopes];
+	}
+	removeAgentAccess(agentId) {
+		const normalizedAgentId = agentId.trim();
+		if (!this.config.agentAccess[normalizedAgentId]) return false;
+		delete this.config.agentAccess[normalizedAgentId];
+		return true;
+	}
+	setExtraAccessibleScopes(scopes) {
+		const normalizedScopes = normalizeExtraAccessibleScopes(scopes);
+		for (const scope of normalizedScopes) if (!this.validateScope(scope)) throw new Error(`Invalid scope: ${scope}`);
+		this.config.extraAccessibleScopes = normalizedScopes;
+	}
+	validateScopeFormat(scope) {
+		if (!scope || typeof scope !== "string") return false;
+		const trimmed = scope.trim();
+		if (trimmed.length === 0 || trimmed.length > 100) return false;
+		return /^[a-zA-Z0-9._:-]+$/.test(trimmed);
+	}
+	exportConfig() {
+		return {
+			default: this.config.default,
+			definitions: JSON.parse(JSON.stringify(this.config.definitions)),
+			agentAccess: JSON.parse(JSON.stringify(this.config.agentAccess)),
+			extraAccessibleScopes: [...this.config.extraAccessibleScopes]
+		};
+	}
+	importConfig(config) {
+		if (config.definitions) {
+			for (const key of Object.keys(config.definitions)) if (!this.validateScopeFormat(key) && !this.isBuiltInScope(key)) throw new Error(`Invalid scope format in imported config: ${key}`);
+		}
+		const previous = this.config;
+		const next = {
+			default: config.default ?? previous.default,
+			definitions: {
+				...previous.definitions,
+				...config.definitions ?? {}
+			},
+			agentAccess: {
+				...normalizeAgentAccessMap(previous.agentAccess),
+				...normalizeAgentAccessMap(config.agentAccess)
+			},
+			extraAccessibleScopes: normalizeExtraAccessibleScopes(config.extraAccessibleScopes ?? previous.extraAccessibleScopes)
+		};
+		this.config = next;
+		try {
+			this.validateConfiguration();
+		} catch (error) {
+			this.config = previous;
+			throw error;
+		}
+	}
+	getStats() {
+		const scopes = this.getAllScopes();
+		const scopesByType = {
+			global: 0,
+			agent: 0,
+			custom: 0,
+			project: 0,
+			user: 0,
+			reflection: 0,
+			other: 0
+		};
+		for (const scope of scopes) if (scope === "global") scopesByType.global = (scopesByType.global ?? 0) + 1;
+		else if (scope.startsWith("agent:")) scopesByType.agent = (scopesByType.agent ?? 0) + 1;
+		else if (scope.startsWith("custom:")) scopesByType.custom = (scopesByType.custom ?? 0) + 1;
+		else if (scope.startsWith("project:")) scopesByType.project = (scopesByType.project ?? 0) + 1;
+		else if (scope.startsWith("user:")) scopesByType.user = (scopesByType.user ?? 0) + 1;
+		else if (scope.startsWith("reflection:")) scopesByType.reflection = (scopesByType.reflection ?? 0) + 1;
+		else scopesByType.other = (scopesByType.other ?? 0) + 1;
+		return {
+			totalScopes: scopes.length,
+			agentsWithCustomAccess: Object.keys(this.config.agentAccess).length,
+			scopesByType
+		};
+	}
+};
+function createScopePolicy(config = {}, warn) {
+	return new MemoryScopePolicy(config, warn);
+}
+//#endregion
+export { parseAgentIdFromSessionKey as a, SCOPE_PATTERNS as c, isSystemBypassId as i, createScopePolicy as n, shouldWarnLegacyFallbackBypassId as o, _resetLegacyFallbackWarningState as r, DEFAULT_SCOPE_CONFIG as s, MemoryScopePolicy as t };

package/dist/memory-snapshot-3e44ND2i.d.ts

@@ -0,0 +1,16 @@
+import { t as PluginConfig } from "./plugin-config-schema-C0UUbOmG.js";
+import "./types-DxKqU60b.js";
+import { r as SqliteDatabaseLike } from "./sqlite-runtime-L_ywirTm.js";
+//#region src/engine/observability/memory-snapshot.d.ts
+type SnapshotReason = "startup" | "session_end";
+type MemorySnapshotPayload = {
+  session_uuid: string;
+  snapshot_reason: SnapshotReason;
+  total_entries: number;
+  total_bytes: number;
+  oldest_entry_ts_ms?: number;
+  newest_entry_ts_ms?: number;
+};
+declare function readMemorySnapshotPayload(dbPath: string, _config: PluginConfig, snapshotUuid: string, reason: SnapshotReason, liveDb?: SqliteDatabaseLike): Promise<MemorySnapshotPayload>;
+//#endregion
+export { SnapshotReason as n, readMemorySnapshotPayload as r, MemorySnapshotPayload as t };

package/dist/memory-source-order-BtrIxaIt.js

@@ -0,0 +1,134 @@
+//#region src/store/memory-source-order.ts
+function compareNumber(left, right) {
+	if (left === right) return 0;
+	return left < right ? -1 : 1;
+}
+/**
+* The one number a row is ordered by. `valid_from` is the event time; when the model resolved
+* none, the row's own session moment stands in for it — exactly as the write sets
+* `timestamp = valid_from ?? sessionTimestampMs`. Folding both into a single monotone number is
+* what makes the comparison transitive: comparing `valid_from` only when both sides carried one
+* left mixed dated/undated rows able to form a cycle. A row with neither (written before this
+* field, or a hand-written key) sorts oldest.
+*/
+function orderTime(order) {
+	return order.valid_from ?? order.session_moment ?? Number.NEGATIVE_INFINITY;
+}
+function compareMemorySourceOrder(left, right) {
+	return compareNumber(orderTime(left), orderTime(right)) || compareNumber(left.session_ordinal, right.session_ordinal) || compareNumber(left.global_turn_index, right.global_turn_index) || compareNumber(left.rowid, right.rowid);
+}
+/** The latest correction assertion in this row's existing predecessor chain. */
+function readCorrectionMoment(database, rowId) {
+	const row = database.prepare(`WITH RECURSIVE predecessors(id, project_id, metadata) AS (
+		SELECT id, project_id, metadata FROM nodix_memories WHERE id = ?
+		UNION
+		SELECT parent.id, parent.project_id, parent.metadata FROM nodix_memories parent
+		JOIN predecessors child ON parent.project_id = child.project_id AND json_valid(parent.metadata)
+			AND json_extract(parent.metadata, '$.superseded_by') = child.id
+	) SELECT MAX(CASE WHEN json_valid(metadata)
+		AND json_extract(metadata, '$.source_order.correction') = 1
+		THEN json_extract(metadata, '$.source_order.session_moment') END) AS moment FROM predecessors`).get(rowId);
+	return typeof row === "object" && row !== null && "moment" in row && typeof row.moment === "number" ? row.moment : void 0;
+}
+/** Apply correction assertion time at retirement, preserving ordinary event ordering. */
+function compareMemoryRetirementOrder(database, leftId, left, rightId, right) {
+	const correctedAt = Math.max(readCorrectionMoment(database, leftId) ?? Number.NEGATIVE_INFINITY, readCorrectionMoment(database, rightId) ?? Number.NEGATIVE_INFINITY);
+	if (Number.isFinite(correctedAt) && left.session_moment !== void 0 && right.session_moment !== void 0) {
+		const leftPredates = left.session_moment < correctedAt;
+		if (leftPredates !== right.session_moment < correctedAt) return leftPredates ? -1 : 1;
+		if (left.correction || right.correction) {
+			const assertionOrder = compareNumber(left.session_moment, right.session_moment);
+			if (assertionOrder !== 0) return assertionOrder;
+		}
+	}
+	return compareMemorySourceOrder(left, right);
+}
+/**
+* Two rows born from one conversation turn: at arrival neither is older than the other. One
+* statement is extracted as several rows — a timeline and its phases, an ending and its
+* replacement — and the `rowid` tie-break below read them as successive, so a one-cardinality
+* attribute closed every facet but the last and an ending was offered its own replacement to
+* retire (measured 2026-09-07: 23 and 3 rows of one six-persona run). A same-turn revision is
+* the model's `ends_current` job, not an ordering question. The sentinel of a row with no
+* `source_order` never matches another sentinel.
+*/
+function sameSourceTurn(left, right) {
+	return left.conversation_id !== void 0 && left.conversation_id === right.conversation_id && Number.isFinite(left.session_ordinal) && left.session_ordinal === right.session_ordinal && left.global_turn_index === right.global_turn_index;
+}
+function isSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value);
+}
+/**
+* The order key a row carries, or the one a row written before this change is treated as having.
+*
+* A row from before REQ-2 has no `source_order` until the maintenance pass backfills it, and an
+* ordinary wave must keep running over such a store rather than throwing. Those rows are older
+* than everything written since — that is what "written before" means — so they read as the
+* lowest possible key: anything may close them, and they may close nothing.
+*/
+function readMemorySourceOrderOrOldest(metadata) {
+	try {
+		return readMemorySourceOrder(metadata);
+	} catch {
+		return {
+			valid_from: null,
+			session_ordinal: Number.NEGATIVE_INFINITY,
+			global_turn_index: Number.NEGATIVE_INFINITY,
+			rowid: Number.NEGATIVE_INFINITY
+		};
+	}
+}
+function readMemorySourceOrder(metadata) {
+	const parsed = JSON.parse(metadata);
+	if (typeof parsed !== "object" || parsed === null || !("source_order" in parsed)) throw new Error("Memory row has no source_order");
+	const sourceOrder = parsed.source_order;
+	if (typeof sourceOrder !== "object" || sourceOrder === null) throw new Error("Memory row has invalid source_order");
+	const validFrom = "valid_from" in sourceOrder ? sourceOrder.valid_from : void 0;
+	const sessionMoment = "session_moment" in sourceOrder ? sourceOrder.session_moment : void 0;
+	const sessionOrdinal = "session_ordinal" in sourceOrder ? sourceOrder.session_ordinal : void 0;
+	const globalTurnIndex = "global_turn_index" in sourceOrder ? sourceOrder.global_turn_index : void 0;
+	const rowid = "rowid" in sourceOrder ? sourceOrder.rowid : void 0;
+	const conversationId = "conversation_id" in sourceOrder && typeof sourceOrder.conversation_id === "string" ? sourceOrder.conversation_id : void 0;
+	if (validFrom !== null && !isSafeInteger(validFrom) || sessionMoment !== void 0 && !isSafeInteger(sessionMoment) || !isSafeInteger(sessionOrdinal) || !isSafeInteger(globalTurnIndex) || !isSafeInteger(rowid)) throw new Error("Memory row has invalid source_order");
+	return {
+		valid_from: validFrom,
+		...sessionMoment === void 0 ? {} : { session_moment: sessionMoment },
+		session_ordinal: sessionOrdinal,
+		global_turn_index: globalTurnIndex,
+		rowid,
+		...conversationId === void 0 ? {} : { conversation_id: conversationId },
+		..."correction" in sourceOrder && sourceOrder.correction === true ? { correction: true } : {}
+	};
+}
+function readMetadata(metadata) {
+	const parsed = JSON.parse(metadata);
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("Memory row has invalid metadata");
+	return { ...parsed };
+}
+function activeMergeId(metadata) {
+	return typeof metadata.merge_id === "string" ? metadata.merge_id : void 0;
+}
+function readClosableRow(database, rowId) {
+	const row = database.prepare("SELECT id, metadata, valid_from AS validFrom, valid_until AS validUntil FROM nodix_memories WHERE id = ?").get(rowId);
+	if (!row) throw new Error(`Memory row '${rowId}' does not exist`);
+	return row;
+}
+function closeMemoryRow(database, input) {
+	const row = readClosableRow(database, input.targetRowId);
+	const metadata = readMetadata(row.metadata);
+	if (metadata.superseded_by === input.closingRowId) return false;
+	if (metadata.superseded_by !== void 0 && metadata.superseded_by !== null) throw new Error(`Memory row '${input.targetRowId}' is already closed`);
+	if (input.targetRowId !== input.closingRowId && compareMemoryRetirementOrder(database, input.closingRowId, input.closingOrder, input.targetRowId, readMemorySourceOrderOrOldest(row.metadata)) < 0) throw new Error("Closing row source_order must be strictly greater than target source_order");
+	const validUntil = input.validUntilMode === "clear" ? null : row.validFrom !== null && input.closingValidFrom !== null && input.closingValidFrom > row.validFrom ? input.closingValidFrom : row.validUntil;
+	const closingMetadata = input.targetRowId === input.closingRowId ? metadata : readMetadata(readClosableRow(database, input.closingRowId).metadata);
+	const mergeId = activeMergeId(metadata) ?? activeMergeId(closingMetadata);
+	database.prepare("UPDATE nodix_memories SET metadata = ?, valid_until = ? WHERE id = ?").run(JSON.stringify({
+		...metadata,
+		superseded_by: input.closingRowId,
+		superseded_at: input.supersededAt,
+		...mergeId === void 0 ? {} : { close_merge_id: mergeId }
+	}), validUntil, input.targetRowId);
+	return true;
+}
+//#endregion
+export { readMemorySourceOrder as a, readCorrectionMoment as i, compareMemoryRetirementOrder as n, readMemorySourceOrderOrOldest as o, compareMemorySourceOrder as r, sameSourceTurn as s, closeMemoryRow as t };