@snoai/memory 0.0.0-stage → 1.0.0

package/dist/internal/store/memory-kinds-cutover-migrator.d.ts

@@ -0,0 +1,28 @@
+import { r as SqliteDatabaseLike } from "../../sqlite-runtime-L_ywirTm.js";
+//#region src/store/memory-kinds-cutover-migrator.d.ts
+export declare const MEMORY_KINDS_FOUNDATION_MARKER = "nodix_memory_kinds_foundation_v1";
+export interface MemoryKindsCutoverResult {
+  status: "migrated" | "noop";
+  rewrittenRows: number;
+  checkedRows: number;
+}
+export interface ResetMemoryKindsCutoverDatabaseOptions {
+  dbPath: string;
+  projectId: string;
+  args: string[];
+  timestamp?: number;
+  log?: (record: Record<string, unknown>) => void;
+}
+export interface ResetMemoryKindsCutoverDatabaseResult {
+  removedFiles: number;
+  dbPath: string;
+  projectId: string;
+  timestamp: number;
+}
+export declare function assertMemoryKindsCutoverStartupGuard(db: SqliteDatabaseLike): void;
+export declare function runMemoryKindsCutoverMigration(args: {
+  dbPath: string;
+  now?: number;
+}): MemoryKindsCutoverResult;
+export declare function resetMemoryKindsCutoverDatabase(options: ResetMemoryKindsCutoverDatabaseOptions): ResetMemoryKindsCutoverDatabaseResult;
+//#endregion

package/dist/internal/store/memory-kinds-cutover-migrator.js

@@ -0,0 +1,415 @@
+import { St as PERSISTED_CONTENT_HASH_V1 } from "../../signed-registry-constants-yq3DlG3B.js";
+import { MEMORY_CATEGORIES } from "../engine/shared/types.js";
+import { StorageError } from "../engine/shared/errors.js";
+import { a as buildInsightMetadata, c as stringifyInsightMetadata, s as parseInsightMetadata } from "../../memory-metadata-codec-DL1sbJiN.js";
+import { stableHash } from "../engine/shared/utils.js";
+import { u as runWithMemoryAuditSync } from "../../runtime-audit-log-BCeujlEp.js";
+import { getSnoStationMemStateDir } from "../contract/profile.js";
+import { openSqliteDatabase } from "./sqlite-runtime.js";
+import { resolve } from "node:path";
+import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { readManifestIfPresent, resolveConfigPaths } from "@snoai/sqlite-crypto";
+//#region src/store/memory-kinds-cutover-migrator.ts
+/** @file memory-kinds-cutover-migrator.ts
+* @purpose Offline one-time memory-kind cutover and startup invariants.
+* @boundary Raw SQLite migration path only; runtime startup may call the guard.
+*/
+const MEMORY_KINDS_FOUNDATION_MARKER = "nodix_memory_kinds_foundation_v1";
+const OLD_MEMORY_CATEGORIES = [
+	"identity",
+	"preference",
+	"entity",
+	"event"
+];
+const FOUNDATION_CATEGORY_SET = new Set(MEMORY_CATEGORIES);
+const OLD_CATEGORY_SET = new Set(OLD_MEMORY_CATEGORIES);
+const MIGRATABLE_SOURCES = /* @__PURE__ */ new Set([
+	"manual",
+	"ambient-learning",
+	"reflection",
+	"session-summary"
+]);
+function createMarkerTable(db) {
+	db.exec("CREATE TABLE IF NOT EXISTS nodix_memory_migration_markers (name TEXT PRIMARY KEY, applied_at INTEGER NOT NULL, payload TEXT NOT NULL)");
+}
+function markerExists(db) {
+	if (!db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1").get("nodix_memory_migration_markers")) return false;
+	return db.prepare("SELECT name FROM nodix_memory_migration_markers WHERE name = ? LIMIT 1").get(MEMORY_KINDS_FOUNDATION_MARKER) !== void 0;
+}
+function readRows(db) {
+	return db.prepare("SELECT id, text, category, project_id AS projectId, importance, timestamp, metadata, content_hash FROM nodix_memories ORDER BY id ASC").all();
+}
+function parseJsonObject(raw) {
+	if (!raw) return {};
+	try {
+		const parsed = JSON.parse(raw);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function metadataWithoutCategoryFields(metadata) {
+	const sanitized = { ...metadata };
+	delete sanitized.kind;
+	delete sanitized.memory_category;
+	delete sanitized.category;
+	return sanitized;
+}
+function safeTimestamp(value, fallback) {
+	const n = typeof value === "number" ? value : Number(value);
+	return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+function optionalString(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function isMigratableSource(value) {
+	return MIGRATABLE_SOURCES.has(value);
+}
+function migratableSource(value) {
+	const source = optionalString(value);
+	if (!source || source === "legacy") return "ambient-learning";
+	return isMigratableSource(source) ? source : "ambient-learning";
+}
+function numericOr(value, fallback) {
+	const n = typeof value === "number" ? value : Number(value);
+	return Number.isFinite(n) ? n : fallback;
+}
+function countOr(value, fallback) {
+	const n = numericOr(value, fallback);
+	return n >= 0 ? Math.floor(n) : fallback;
+}
+function slugSectionToken(value) {
+	return value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function stripPrefix(value, prefix) {
+	return value.startsWith(prefix) ? value.slice(prefix.length) : void 0;
+}
+function resolvePreferenceSection(metadata) {
+	const sectionName = optionalString(metadata.section_name);
+	if (sectionName?.startsWith("preferences.")) return sectionName;
+	const topic = optionalString(metadata.topic ?? metadata.preference_topic ?? metadata.preferenceTopic);
+	if (topic) {
+		const slug = slugSectionToken(topic);
+		return slug ? `preferences.${slug}` : void 0;
+	}
+	const factKey = optionalString(metadata.fact_key);
+	if (factKey) {
+		const profileSection = stripPrefix(factKey, "profile:");
+		if (profileSection?.startsWith("preferences.")) return profileSection;
+		const preferenceTopic = stripPrefix(factKey, "preference:");
+		if (preferenceTopic) {
+			const slug = slugSectionToken(preferenceTopic);
+			return slug ? `preferences.${slug}` : void 0;
+		}
+	}
+}
+function resolveEntitySection(metadata) {
+	const sectionName = optionalString(metadata.section_name);
+	if (sectionName?.startsWith("entities.")) return sectionName;
+	const factKey = optionalString(metadata.fact_key);
+	if (factKey) {
+		const profileSection = stripPrefix(factKey, "profile:");
+		if (profileSection?.startsWith("entities.")) return profileSection;
+		const entityFactKey = stripPrefix(factKey, "entity:");
+		if (entityFactKey) {
+			const slug = slugSectionToken(entityFactKey);
+			return slug ? `entities.${slug}` : void 0;
+		}
+	}
+	for (const key of [
+		"entity_id",
+		"entityId",
+		"canonical_id",
+		"entity_name",
+		"entityName",
+		"name"
+	]) {
+		const value = optionalString(metadata[key]);
+		if (!value) continue;
+		const slug = slugSectionToken(value);
+		if (slug) return `entities.${slug}`;
+	}
+}
+function resolveLessonSignature(metadata) {
+	const signature = optionalString(metadata.anti_pattern_signature);
+	if (signature) return signature;
+	const factKey = optionalString(metadata.fact_key);
+	return optionalString(factKey ? stripPrefix(factKey, "lesson:") : void 0);
+}
+function mapRowCategory(row, metadata) {
+	if (FOUNDATION_CATEGORY_SET.has(row.category)) return {
+		category: row.category,
+		variantPatch: {},
+		changed: false
+	};
+	if (!OLD_CATEGORY_SET.has(row.category)) throw new StorageError(`memory-kinds-foundation offline migrator cannot map row ${row.id}: unknown category "${row.category}"`);
+	const oldCategory = row.category;
+	if (oldCategory === "identity") return {
+		category: "profile",
+		variantPatch: { section_name: "identity" },
+		changed: true
+	};
+	if (oldCategory === "preference") {
+		const sectionName = resolvePreferenceSection(metadata);
+		if (!sectionName) throw new StorageError(`memory-kinds-foundation offline migrator cannot map row ${row.id}: missing preference topic/section_name`);
+		return {
+			category: "profile",
+			variantPatch: { section_name: sectionName },
+			changed: true
+		};
+	}
+	if (oldCategory === "entity") {
+		const sectionName = resolveEntitySection(metadata);
+		if (sectionName) return {
+			category: "profile",
+			variantPatch: { section_name: sectionName },
+			changed: true
+		};
+		return {
+			category: "episodic",
+			variantPatch: { entity_kind: optionalString(metadata.entity_kind) },
+			changed: true
+		};
+	}
+	if (oldCategory === "event") return {
+		category: "episodic",
+		variantPatch: { event_at: metadata.event_at },
+		changed: true
+	};
+	throw new StorageError(`memory-kinds-foundation offline migrator cannot map row ${row.id}: unsupported category "${row.category}"`);
+}
+function buildBasePatch(row, metadata, category, migrationStartTime) {
+	const rowTimestamp = safeTimestamp(row.timestamp, migrationStartTime);
+	const source = optionalString(metadata.source);
+	const patch = {
+		kind: category,
+		memory_category: category,
+		l0_abstract: optionalString(metadata.l0_abstract) ?? row.text,
+		l1_overview: optionalString(metadata.l1_overview) ?? `- ${row.text}`,
+		l2_content: optionalString(metadata.l2_content) ?? row.text,
+		tier: "core",
+		access_count: countOr(metadata.access_count ?? metadata.accessCount, 0),
+		confidence: numericOr(metadata.confidence, .5),
+		last_accessed_at: rowTimestamp,
+		asserted_at: rowTimestamp,
+		valid_from: rowTimestamp,
+		state: "confirmed",
+		source: migratableSource(metadata.source),
+		injected_count: countOr(metadata.injected_count, 0),
+		bad_recall_count: countOr(metadata.bad_recall_count, 0),
+		suppressed_until_turn: countOr(metadata.suppressed_until_turn, 0)
+	};
+	if (source === "legacy") patch.migrated_from_source = "legacy";
+	return patch;
+}
+function buildMigratedRow(row, migrationStartTime) {
+	const parsedMetadata = parseJsonObject(row.metadata);
+	const mapped = mapRowCategory(row, parsedMetadata);
+	const patch = {
+		...buildBasePatch(row, parsedMetadata, mapped.category, migrationStartTime),
+		...mapped.variantPatch
+	};
+	if (mapped.category === "lesson") {
+		const antiPatternSignature = resolveLessonSignature(parsedMetadata) ?? optionalString(mapped.variantPatch.anti_pattern_signature);
+		if (!antiPatternSignature) throw new StorageError(`memory-kinds-foundation offline migrator cannot map row ${row.id}: missing anti_pattern_signature`);
+		patch.anti_pattern_signature = antiPatternSignature;
+	}
+	const timestamp = safeTimestamp(row.timestamp, migrationStartTime);
+	let metadata;
+	try {
+		const sanitizedMetadata = metadataWithoutCategoryFields(parsedMetadata);
+		metadata = buildInsightMetadata({
+			text: row.text,
+			category: mapped.category,
+			timestamp,
+			metadata: JSON.stringify(sanitizedMetadata)
+		}, patch);
+	} catch (error) {
+		throw new StorageError(`memory-kinds-foundation offline migrator failed row ${row.id}: ${error.message}`, error);
+	}
+	const serialized = stringifyInsightMetadata(metadata);
+	return {
+		category: mapped.category,
+		metadata: serialized,
+		contentHash: stableHash(hashInputForMigratedEntry(row.text, serialized)),
+		changed: mapped.changed || row.metadata !== serialized || row.content_hash !== stableHash(hashInputForMigratedEntry(row.text, serialized))
+	};
+}
+function hashInputForMigratedEntry(text, metadata) {
+	const parsed = parseJsonObject(metadata);
+	const mergeLineage = Array.isArray(parsed.merge_lineage) ? parsed.merge_lineage.filter((item) => typeof item === "string") : [];
+	if (mergeLineage.length > 0) return JSON.stringify([
+		PERSISTED_CONTENT_HASH_V1,
+		text,
+		{ merge_lineage: mergeLineage }
+	]);
+	const mappedKind = parsed.mappedKind;
+	if (typeof mappedKind === "string" && mappedKind.length > 0) return JSON.stringify([
+		PERSISTED_CONTENT_HASH_V1,
+		text,
+		mappedKind
+	]);
+	return text;
+}
+function validateFoundationInvariants(db) {
+	const rows = readRows(db);
+	for (const row of rows) {
+		if (!FOUNDATION_CATEGORY_SET.has(row.category)) throw new StorageError(`memory-kinds-foundation startup guard failed row ${row.id}: category "${row.category}" is not a foundation kind; run the offline migrator`);
+		try {
+			parseInsightMetadata(row.metadata ?? void 0, {
+				text: row.text,
+				category: row.category,
+				timestamp: row.timestamp
+			});
+		} catch (error) {
+			throw new StorageError(`memory-kinds-foundation startup guard failed row ${row.id}: ${error.message}; run the offline migrator`, error);
+		}
+	}
+	return rows.length;
+}
+function countNonFoundationRows(db) {
+	const rawCount = db.prepare(`SELECT COUNT(*) AS count FROM nodix_memories WHERE category NOT IN (${MEMORY_CATEGORIES.map(() => "?").join(", ")})`).get(...MEMORY_CATEGORIES)?.count ?? 0;
+	return typeof rawCount === "bigint" ? Number(rawCount) : Number(rawCount);
+}
+function assertMemoryKindsCutoverStartupGuard(db) {
+	if (markerExists(db)) return;
+	const nonFoundationRows = countNonFoundationRows(db);
+	if (nonFoundationRows > 0) throw new StorageError(`memory-kinds-foundation startup guard found ${nonFoundationRows} old/unknown category row(s) without marker ${MEMORY_KINDS_FOUNDATION_MARKER}; run the offline migrator before starting the runtime`);
+}
+function runMemoryKindsCutoverMigration(args) {
+	return runWithMemoryAuditSync({
+		stateDir: getSnoStationMemStateDir(),
+		event: "memory_updated",
+		operation: "runMemoryKindsCutoverMigration",
+		run: () => runMemoryKindsCutoverMigrationUnaudited(args),
+		completedDetails: (result) => ({
+			migration_status: result.status,
+			rewritten_rows: result.rewrittenRows,
+			checked_rows: result.checkedRows
+		})
+	});
+}
+function runMemoryKindsCutoverMigrationUnaudited(args) {
+	const migrationStartTime = args.now ?? Date.now();
+	const sqlite = openSqliteDatabase(args.dbPath);
+	try {
+		return sqlite.db.transaction(() => {
+			createMarkerTable(sqlite.db);
+			if (markerExists(sqlite.db)) return {
+				status: "noop",
+				rewrittenRows: 0,
+				checkedRows: validateFoundationInvariants(sqlite.db)
+			};
+			const rows = readRows(sqlite.db);
+			let rewrittenRows = 0;
+			for (const row of rows) {
+				const migrated = buildMigratedRow(row, migrationStartTime);
+				if (migrated.changed) rewrittenRows += 1;
+				sqlite.db.prepare("UPDATE nodix_memories SET category = ?, metadata = ?, content_hash = ? WHERE id = ?").run(migrated.category, migrated.metadata, migrated.contentHash, row.id);
+			}
+			sqlite.db.prepare("INSERT INTO nodix_memory_migration_markers (name, applied_at, payload) VALUES (?, ?, ?)").run(MEMORY_KINDS_FOUNDATION_MARKER, migrationStartTime, JSON.stringify({
+				rewrittenRows,
+				checkedRows: rows.length
+			}));
+			const checkedRows = validateFoundationInvariants(sqlite.db);
+			return {
+				status: "migrated",
+				rewrittenRows,
+				checkedRows
+			};
+		}).immediate();
+	} finally {
+		sqlite.db.close();
+	}
+}
+function removeDbManifestEntry(dbPath) {
+	const manifest = readManifestIfPresent();
+	if (!manifest) return;
+	const normalizedDbPath = resolve(dbPath);
+	const nextDbs = manifest.dbs.filter((entry) => entry.path !== normalizedDbPath);
+	if (nextDbs.length === manifest.dbs.length) return;
+	const { manifestFile, configDir } = resolveConfigPaths();
+	mkdirSync(configDir, {
+		recursive: true,
+		mode: 448
+	});
+	const tmp = `${manifestFile}.tmp-${process.pid}-${Date.now().toString(36)}`;
+	writeFileSync(tmp, JSON.stringify({
+		schemaVersion: manifest.schemaVersion,
+		createdAt: manifest.createdAt,
+		dbs: nextDbs
+	}));
+	renameSync(tmp, manifestFile);
+}
+function resetMemoryKindsCutoverDatabase(options) {
+	let memoryCount;
+	return runWithMemoryAuditSync({
+		stateDir: getSnoStationMemStateDir(),
+		event: "memory_deleted",
+		operation: "resetMemoryKindsCutoverDatabase",
+		scope: options.projectId,
+		startedDetails: {
+			scope: options.projectId,
+			delete_reason: "memory_kinds_cutover_reset"
+		},
+		run: () => {
+			memoryCount = readResetMemoryCount(options.dbPath);
+			return resetMemoryKindsCutoverDatabaseUnaudited(options);
+		},
+		completedDetails: (result) => {
+			const outcome = result.removedFiles > 0 ? "deleted" : "noop";
+			return {
+				scope: options.projectId,
+				delete_reason: "memory_kinds_cutover_reset",
+				outcome,
+				removed_files: result.removedFiles,
+				...memoryCount === void 0 ? {} : { count: memoryCount }
+			};
+		}
+	});
+}
+function readResetMemoryCount(dbPath) {
+	if (!existsSync(dbPath)) return 0;
+	let sqlite;
+	try {
+		sqlite = openSqliteDatabase(dbPath);
+		const count = sqlite.db.prepare("SELECT COUNT(*) AS count FROM nodix_memories").get()?.count;
+		if (typeof count === "bigint") return Number(count);
+		return typeof count === "number" ? count : void 0;
+	} catch {
+		return;
+	} finally {
+		sqlite?.db.close();
+	}
+}
+function resetMemoryKindsCutoverDatabaseUnaudited(options) {
+	const timestamp = options.timestamp ?? Date.now();
+	const record = {
+		event: "memory_kinds_foundation_destructive_reset",
+		dbPath: options.dbPath,
+		projectId: options.projectId,
+		timestamp,
+		args: options.args
+	};
+	options.log?.(record);
+	removeDbManifestEntry(options.dbPath);
+	let removedFiles = 0;
+	for (const suffix of [
+		"",
+		"-shm",
+		"-wal"
+	]) {
+		const target = `${options.dbPath}${suffix}`;
+		if (!existsSync(target)) continue;
+		rmSync(target);
+		removedFiles += 1;
+	}
+	return {
+		removedFiles,
+		dbPath: options.dbPath,
+		projectId: options.projectId,
+		timestamp
+	};
+}
+//#endregion
+export { MEMORY_KINDS_FOUNDATION_MARKER, assertMemoryKindsCutoverStartupGuard, resetMemoryKindsCutoverDatabase, runMemoryKindsCutoverMigration };

package/dist/internal/store/migrations.d.ts

@@ -0,0 +1,27 @@
+import { u as RemDatabaseLike } from "../../types-pVomjzqR.js";
+//#region src/store/migrations.d.ts
+type RemMigrationDecision = {
+  decision: "allow";
+  reasonCode: null;
+} | {
+  decision: "refuse";
+  reasonCode: "post_migration_writes";
+};
+/**
+ * Apply drizzle migrations against the encrypted DB at `dbPath`. Idempotent —
+ * drizzle's `__drizzle_migrations` table tracks applied migrations by hash, so
+ * a second call is a no-op. The self-upgrade smoke test calls this against a
+ * new ephemeral database; the plugin runtime opens its configured database
+ * through `initDb()` instead.
+ *
+ * The key comes from settings. Caller is responsible for closing nothing; this
+ * function opens its own connection and closes it on exit.
+ */
+export declare function runMigrations(dbPath: string): void;
+export declare function applyRemTwoFacetMigration(input: {
+  database: RemDatabaseLike;
+}): void;
+export declare function rollbackRemTwoFacetMigration(input: {
+  database: RemDatabaseLike;
+}): RemMigrationDecision;
+//#endregion

package/dist/internal/store/migrations.js

@@ -0,0 +1,201 @@
+import { readSettings } from "../contract/profile.js";
+import { installRemSchema } from "../engine/rem/index.js";
+import { a as schema_exports, i as migrateLegacyDatabaseNamespace, n as loadSqliteVecExtension, o as applyEntityNameKeyMigration, r as resolveSimpleTokenizerPath, t as migrateUnplacedCandidates } from "../../unplaced-candidate-migration-CbQHzcEM.js";
+import { initSqliteRuntime, openSqliteDatabase } from "./sqlite-runtime.js";
+import { dirname, join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+//#region src/store/migrations.ts
+/** @file migrations.ts
+* @purpose Public, idempotent migration entry point used by the self-upgrade
+*   smoke test. Walks the SQLCipher chokepoint, loads
+*   sqlite-vec + simple-tokenizer, then applies drizzle migrations.
+* @boundary Standalone — does not depend on the rest of the storage runtime
+*   beyond the chokepoint and migrations directory resolution.
+*/
+const remTwoFacetBaselines = /* @__PURE__ */ new WeakMap();
+const MIGRATIONS_DIR = resolveMigrationsDir();
+/**
+* Apply drizzle migrations against the encrypted DB at `dbPath`. Idempotent —
+* drizzle's `__drizzle_migrations` table tracks applied migrations by hash, so
+* a second call is a no-op. The self-upgrade smoke test calls this against a
+* new ephemeral database; the plugin runtime opens its configured database
+* through `initDb()` instead.
+*
+* The key comes from settings. Caller is responsible for closing nothing; this
+* function opens its own connection and closes it on exit.
+*/
+function runMigrations(dbPath) {
+	initSqliteRuntime(readSettings().store.encryptionKey);
+	mkdirSync(dirname(dbPath), { recursive: true });
+	const sqlite = openSqliteDatabase(dbPath);
+	try {
+		loadSqliteVecExtension(sqlite.raw);
+		const { extensionPath, dictPath } = resolveSimpleTokenizerPath();
+		sqlite.db.loadExtension(extensionPath);
+		sqlite.db.prepare("SELECT jieba_dict(?)").get(dictPath);
+		sqlite.db.exec("PRAGMA journal_mode=WAL;");
+		sqlite.db.exec("PRAGMA busy_timeout=5000;");
+		sqlite.db.exec("PRAGMA foreign_keys=ON;");
+		migrateLegacyDatabaseNamespace(sqlite.db);
+		const db = drizzle(sqlite.raw, { schema: schema_exports });
+		migrate(db, { migrationsFolder: MIGRATIONS_DIR });
+		applyEntityNameKeyMigration(sqlite.db);
+		migrateUnplacedCandidates(sqlite.db);
+		installRemSchema(sqlite.db);
+	} finally {
+		try {
+			sqlite.db.close();
+		} catch {}
+	}
+}
+function applyRemTwoFacetMigration(input) {
+	const facetTableMissing = !tableExists(input.database, "nodix_rem_memory_facets");
+	const facetRecoveryMissing = !tableExists(input.database, "nodix_rem_facet_recovery");
+	const chunkFacetMissing = !columnExists(input.database, "nodix_memory_chunks", "facet");
+	const facetIndexMissing = !indexExists(input.database, "rem_memory_facets_by_facet");
+	const chunkFacetIndexMissing = !indexExists(input.database, "nodix_idx_memory_chunks_memory_facet");
+	const oldChunkIndexPresent = indexExists(input.database, "nodix_idx_memory_chunks_memory");
+	const insertTriggerMissing = !triggerExists(input.database, "rem_memory_facets_after_insert");
+	const updateTriggerMissing = !triggerExists(input.database, "rem_memory_facets_after_text_update");
+	const changed = facetTableMissing || facetRecoveryMissing || chunkFacetMissing || facetIndexMissing || chunkFacetIndexMissing || oldChunkIndexPresent || insertTriggerMissing || updateTriggerMissing;
+	const databasePath = changed ? readDatabasePath(input.database) : void 0;
+	const databaseBytes = databasePath === void 0 ? void 0 : readFileSync(databasePath);
+	const walBytes = readOptionalFile(databasePath === void 0 ? void 0 : `${databasePath}-wal`);
+	const shmBytes = readOptionalFile(databasePath === void 0 ? void 0 : `${databasePath}-shm`);
+	if (changed) input.database.transaction(() => {
+		if (facetTableMissing) input.database.exec(`
+					CREATE TABLE nodix_rem_memory_facets (
+				memory_id TEXT NOT NULL,
+				facet TEXT NOT NULL CHECK (facet IN ('current', 'history')),
+				text TEXT NOT NULL,
+				updated_at_ms INTEGER NOT NULL,
+				PRIMARY KEY (memory_id, facet),
+				FOREIGN KEY (memory_id) REFERENCES nodix_memories(id) ON DELETE CASCADE
+					);
+					INSERT INTO nodix_rem_memory_facets(memory_id, facet, text, updated_at_ms)
+						SELECT id, 'current', text, timestamp FROM nodix_memories;
+				`);
+		if (facetIndexMissing) input.database.exec("CREATE INDEX rem_memory_facets_by_facet ON nodix_rem_memory_facets(facet, memory_id)");
+		if (insertTriggerMissing) input.database.exec(`
+					CREATE TRIGGER rem_memory_facets_after_insert
+					AFTER INSERT ON nodix_memories BEGIN
+						INSERT INTO nodix_rem_memory_facets(memory_id, facet, text, updated_at_ms)
+							VALUES (NEW.id, 'current', NEW.text, NEW.timestamp);
+					END
+				`);
+		if (updateTriggerMissing) input.database.exec(`
+					CREATE TRIGGER rem_memory_facets_after_text_update
+					AFTER UPDATE OF text ON nodix_memories BEGIN
+						INSERT INTO nodix_rem_memory_facets(memory_id, facet, text, updated_at_ms)
+							VALUES (NEW.id, 'current', NEW.text, NEW.timestamp)
+						ON CONFLICT(memory_id, facet) DO UPDATE SET
+							text = excluded.text, updated_at_ms = excluded.updated_at_ms;
+					END
+				`);
+		if (chunkFacetMissing) input.database.exec("ALTER TABLE nodix_memory_chunks ADD COLUMN facet TEXT NOT NULL DEFAULT 'current' CHECK (facet IN ('current', 'history'))");
+		if (oldChunkIndexPresent) input.database.exec("DROP INDEX nodix_idx_memory_chunks_memory");
+		if (chunkFacetIndexMissing) input.database.exec("CREATE UNIQUE INDEX nodix_idx_memory_chunks_memory_facet ON nodix_memory_chunks(memory_id, facet, chunk_index)");
+		if (facetRecoveryMissing) input.database.exec(`
+					CREATE TABLE nodix_rem_facet_recovery (
+						recovery_handle TEXT PRIMARY KEY,
+						prior_facets_json TEXT NOT NULL,
+						prior_chunk_facets_json TEXT NOT NULL,
+						expected_facets_json TEXT NOT NULL,
+						expected_chunk_facets_json TEXT NOT NULL,
+						FOREIGN KEY (recovery_handle)
+							REFERENCES nodix_rem_recovery_history(recovery_handle)
+					)
+				`);
+	}).immediate();
+	remTwoFacetBaselines.set(input.database, {
+		...readConnectionVersion(input.database),
+		changed,
+		databasePath,
+		databaseBytes,
+		walBytes,
+		shmBytes
+	});
+}
+function rollbackRemTwoFacetMigration(input) {
+	const baseline = remTwoFacetBaselines.get(input.database);
+	if (baseline === void 0) return {
+		decision: "refuse",
+		reasonCode: "post_migration_writes"
+	};
+	const current = readConnectionVersion(input.database);
+	if (current.dataVersion !== baseline.dataVersion || current.totalChanges !== baseline.totalChanges) return {
+		decision: "refuse",
+		reasonCode: "post_migration_writes"
+	};
+	if (baseline.changed) {
+		if (baseline.databasePath === void 0 || baseline.databaseBytes === void 0) return {
+			decision: "refuse",
+			reasonCode: "post_migration_writes"
+		};
+		input.database.close?.();
+		restoreFile(baseline.databasePath, baseline.databaseBytes);
+		restoreOptionalFile(`${baseline.databasePath}-wal`, baseline.walBytes);
+		restoreOptionalFile(`${baseline.databasePath}-shm`, baseline.shmBytes);
+	}
+	remTwoFacetBaselines.delete(input.database);
+	return {
+		decision: "allow",
+		reasonCode: null
+	};
+}
+function readDatabasePath(database) {
+	const main = database.prepare("PRAGMA database_list").all().find(({ name }) => name === "main");
+	return main?.file === void 0 || main.file.length === 0 ? void 0 : main.file;
+}
+function readOptionalFile(path) {
+	return path !== void 0 && existsSync(path) ? readFileSync(path) : void 0;
+}
+function restoreFile(path, bytes) {
+	writeFileSync(path, bytes);
+}
+function restoreOptionalFile(path, bytes) {
+	if (bytes === void 0) {
+		if (existsSync(path)) unlinkSync(path);
+		return;
+	}
+	writeFileSync(path, bytes);
+}
+function tableExists(database, tableName) {
+	return database.prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName) !== void 0;
+}
+function columnExists(database, tableName, columnName) {
+	if (!tableExists(database, tableName)) return false;
+	return database.prepare(`PRAGMA table_info(${tableName})`).all().some(({ name }) => name === columnName);
+}
+function indexExists(database, indexName) {
+	return schemaObjectExists(database, "index", indexName);
+}
+function triggerExists(database, triggerName) {
+	return schemaObjectExists(database, "trigger", triggerName);
+}
+function schemaObjectExists(database, type, name) {
+	return database.prepare("SELECT 1 FROM sqlite_master WHERE type = ? AND name = ?").get(type, name) !== void 0;
+}
+function readConnectionVersion(database) {
+	const dataVersion = database.prepare("PRAGMA data_version").get();
+	const totalChanges = database.prepare("SELECT total_changes() AS total_changes").get();
+	return {
+		dataVersion: dataVersion.data_version,
+		totalChanges: totalChanges.total_changes
+	};
+}
+function resolveMigrationsDir() {
+	const moduleDir = dirname(fileURLToPath(import.meta.url));
+	const candidates = [
+		join(moduleDir, "../../drizzle"),
+		join(moduleDir, "../drizzle"),
+		join(moduleDir, "../../../drizzle")
+	];
+	for (const dir of candidates) if (existsSync(join(dir, "meta/_journal.json"))) return dir;
+	throw new Error(`drizzle migrations folder not found; checked: ${candidates.join(", ")}`);
+}
+//#endregion
+export { applyRemTwoFacetMigration, rollbackRemTwoFacetMigration, runMigrations };

package/dist/internal/store/sqlite-runtime.d.ts

@@ -0,0 +1,2 @@
+import { a as SqliteOpenOptions, c as SqliteTransactionLike, d as openSqliteDatabase, f as openSqliteDatabaseReadonly, i as SqliteFileMissingError, l as _resetSqliteRuntimeForTest, n as RuntimeNotInitialized, o as SqliteRuntimeHandle, r as SqliteDatabaseLike, s as SqliteStatementLike, t as RawSqliteDatabase, u as initSqliteRuntime } from "../../sqlite-runtime-L_ywirTm.js";
+export { RawSqliteDatabase, RuntimeNotInitialized, SqliteDatabaseLike, SqliteFileMissingError, SqliteOpenOptions, SqliteRuntimeHandle, SqliteStatementLike, SqliteTransactionLike, _resetSqliteRuntimeForTest, initSqliteRuntime, openSqliteDatabase, openSqliteDatabaseReadonly };