@tekmidian/pai 0.66.0 → 0.66.2

package/dist/registry-sqlite-DrCW1aRK.mjs

@@ -1,593 +0,0 @@
-import { t as MergeError } from "./merge-DgU9OgZy.mjs";
-
-//#region src/storage/sqlite/registry-merge.ts
-/**
-* What a merge would do, without doing it.
-*
-* Built as a plan first because the session renumbering is the part a reader will
-* not predict, and printing "0001 -> 0016" is the difference between a command
-* that can be trusted and one that has to be taken on faith.
-*/
-function planMerge(db, fromSlug, intoSlug) {
-	if (fromSlug === intoSlug) throw new MergeError(`Cannot merge ${fromSlug} into itself.`);
-	const from = db.prepare("SELECT id, slug FROM projects WHERE slug = ?").get(fromSlug);
-	const into = db.prepare("SELECT id, slug FROM projects WHERE slug = ?").get(intoSlug);
-	if (!from) throw new MergeError(`No project with slug "${fromSlug}".`);
-	if (!into) throw new MergeError(`No project with slug "${intoSlug}".`);
-	let next = db.prepare("SELECT COALESCE(MAX(number), 0) AS n FROM sessions WHERE project_id = ?").get(into.id).n;
-	const sessions = db.prepare("SELECT id, number FROM sessions WHERE project_id = ? ORDER BY number ASC").all(from.id).map((s) => ({
-		id: s.id,
-		from: s.number,
-		to: ++next
-	}));
-	const count = (sql, ...args) => db.prepare(sql).get(...args).n;
-	const aliasTaken = count("SELECT COUNT(*) AS n FROM aliases WHERE alias = ?", from.slug) > 0 || count("SELECT COUNT(*) AS n FROM projects WHERE slug = ?", from.slug) > 1;
-	return {
-		fromId: from.id,
-		fromSlug: from.slug,
-		intoId: into.id,
-		intoSlug: into.slug,
-		sessions,
-		tags: count("SELECT COUNT(*) AS n FROM project_tags WHERE project_id = ?", from.id),
-		aliases: count("SELECT COUNT(*) AS n FROM aliases WHERE project_id = ?", from.id),
-		compactions: count("SELECT COUNT(*) AS n FROM compaction_log WHERE project_id = ?", from.id),
-		links: count("SELECT COUNT(*) AS n FROM links WHERE target_project_id = ?", from.id),
-		aliasToAdd: aliasTaken ? void 0 : from.slug
-	};
-}
-/**
-* Apply a plan. One transaction: either the whole row is folded in or nothing is.
-*
-* A half-merged project is the worst outcome available here — sessions moved but
-* the row still present, or the row gone and its tags orphaned — and with foreign
-* keys off nothing would complain.
-*/
-function applyMerge(db, plan) {
-	db.transaction(() => {
-		const move = db.prepare("UPDATE sessions SET project_id = ?, number = ? WHERE id = ?");
-		for (const s of plan.sessions) move.run(plan.intoId, s.to, s.id);
-		db.prepare(`INSERT OR IGNORE INTO project_tags (project_id, tag_id)
-       SELECT ?, tag_id FROM project_tags WHERE project_id = ?`).run(plan.intoId, plan.fromId);
-		db.prepare("DELETE FROM project_tags WHERE project_id = ?").run(plan.fromId);
-		db.prepare("UPDATE aliases SET project_id = ? WHERE project_id = ?").run(plan.intoId, plan.fromId);
-		db.prepare("UPDATE compaction_log SET project_id = ? WHERE project_id = ?").run(plan.intoId, plan.fromId);
-		db.prepare(`UPDATE OR IGNORE links SET target_project_id = ? WHERE target_project_id = ?`).run(plan.intoId, plan.fromId);
-		db.prepare("DELETE FROM links WHERE target_project_id = ?").run(plan.fromId);
-		db.prepare(`DELETE FROM links WHERE target_project_id = ?
-         AND session_id IN (SELECT id FROM sessions WHERE project_id = ?)`).run(plan.intoId, plan.intoId);
-		if (plan.aliasToAdd) db.prepare("INSERT OR IGNORE INTO aliases (alias, project_id) VALUES (?, ?)").run(plan.aliasToAdd, plan.intoId);
-		db.prepare("DELETE FROM projects WHERE id = ?").run(plan.fromId);
-	})();
-}
-
-//#endregion
-//#region src/storage/registry-sqlite.ts
-var SQLiteRegistryBackend = class {
-	backendType = "sqlite";
-	db;
-	constructor(db) {
-		this.db = db;
-	}
-	/** Expose the raw better-sqlite3 Database handle for not-yet-converted callers. */
-	getRawDb() {
-		return this.db;
-	}
-	async close() {
-		try {
-			this.db.close();
-		} catch {}
-	}
-	async resetRegistry() {
-		this.db.transaction(() => {
-			this.db.prepare("DELETE FROM links").run();
-			this.db.prepare("DELETE FROM compaction_log").run();
-			this.db.prepare("DELETE FROM session_tags").run();
-			this.db.prepare("DELETE FROM project_tags").run();
-			this.db.prepare("DELETE FROM aliases").run();
-			this.db.prepare("DELETE FROM sessions").run();
-			this.db.prepare("DELETE FROM tags").run();
-			this.db.prepare("DELETE FROM projects").run();
-		})();
-	}
-	async getProjectById(id) {
-		return this.db.prepare("SELECT * FROM projects WHERE id = ?").get(id) ?? null;
-	}
-	async getProjectBySlug(slug, opts = {}) {
-		let sql = opts.caseInsensitive ? "SELECT * FROM projects WHERE lower(slug) = lower(?)" : "SELECT * FROM projects WHERE slug = ?";
-		const params = [slug];
-		if (opts.excludeId !== void 0) {
-			sql += " AND id != ?";
-			params.push(opts.excludeId);
-		}
-		return this.db.prepare(sql).get(...params) ?? null;
-	}
-	async getProjectByAlias(alias, opts = {}) {
-		const sql = opts.caseInsensitive ? "SELECT p.* FROM projects p JOIN aliases a ON a.project_id = p.id WHERE lower(a.alias) = lower(?)" : "SELECT p.* FROM projects p JOIN aliases a ON a.project_id = p.id WHERE a.alias = ?";
-		return this.db.prepare(sql).get(alias) ?? null;
-	}
-	async getProjectByRootPath(rootPath, opts = {}) {
-		let sql = "SELECT * FROM projects WHERE root_path = ?";
-		const params = [rootPath];
-		if (opts.excludeId !== void 0) {
-			sql += " AND id != ?";
-			params.push(opts.excludeId);
-		}
-		return this.db.prepare(sql).get(...params) ?? null;
-	}
-	async getProjectByEncodedDir(encodedDir, opts = {}) {
-		let sql = "SELECT * FROM projects WHERE encoded_dir = ?";
-		const params = [encodedDir];
-		if (opts.excludeId !== void 0) {
-			sql += " AND id != ?";
-			params.push(opts.excludeId);
-		}
-		return this.db.prepare(sql).get(...params) ?? null;
-	}
-	async findProjectByCwdPrefix(cwd) {
-		return this.db.prepare(`SELECT * FROM projects WHERE status = 'active' AND ? LIKE root_path || '%'
-         ORDER BY length(root_path) DESC LIMIT 1`).get(cwd) ?? null;
-	}
-	async listProjects(opts = {}) {
-		const where = [];
-		const params = [];
-		if (opts.status) {
-			where.push("p.status = ?");
-			params.push(opts.status);
-		}
-		if (opts.excludeArchived) where.push("p.status != 'archived'");
-		if (opts.tagName) {
-			where.push("p.id IN (SELECT pt.project_id FROM project_tags pt JOIN tags t ON pt.tag_id = t.id WHERE t.name = ?)");
-			params.push(opts.tagName);
-		}
-		let sql = "SELECT p.* FROM projects p";
-		if (where.length) sql += " WHERE " + where.join(" AND ");
-		switch (opts.orderBy) {
-			case "updated_desc":
-				sql += " ORDER BY p.updated_at DESC";
-				break;
-			case "slug":
-				sql += " ORDER BY p.slug ASC";
-				break;
-			case "id":
-				sql += " ORDER BY p.id";
-				break;
-			default:
-				sql += " ORDER BY p.status ASC, p.updated_at DESC";
-				break;
-		}
-		if (opts.limit !== void 0) {
-			sql += " LIMIT ?";
-			params.push(opts.limit);
-		}
-		return this.db.prepare(sql).all(...params);
-	}
-	async listProjectsByPathLengthDesc(opts = {}) {
-		const where = opts.excludeArchived ? "WHERE status != 'archived'" : "";
-		return this.db.prepare(`SELECT * FROM projects ${where} ORDER BY LENGTH(root_path) DESC`).all();
-	}
-	async listProjectsWithSessionStats(opts = {}) {
-		const where = [];
-		const params = [];
-		if (opts.status) {
-			where.push("p.status = ?");
-			params.push(opts.status);
-		}
-		if (opts.tagId !== void 0) {
-			where.push("p.id IN (SELECT project_id FROM project_tags WHERE tag_id = ?)");
-			params.push(opts.tagId);
-		}
-		let sql = `
-      SELECT p.*,
-        (SELECT COUNT(*) FROM sessions s WHERE s.project_id = p.id) AS session_count,
-        (SELECT MAX(s.created_at) FROM sessions s WHERE s.project_id = p.id) AS last_active
-      FROM projects p
-    `;
-		if (where.length) sql += " WHERE " + where.join(" AND ");
-		sql += opts.orderBy === "updated_desc" ? " ORDER BY p.updated_at DESC" : " ORDER BY p.status ASC, p.updated_at DESC";
-		return this.db.prepare(sql).all(...params);
-	}
-	async listNamedProjects(opts = {}) {
-		const sql = `
-      SELECT p.*, a.alias AS name,
-        (SELECT COUNT(*) FROM sessions s WHERE s.project_id = p.id) AS session_count,
-        (SELECT MAX(s.created_at) FROM sessions s WHERE s.project_id = p.id) AS last_active
-      FROM projects p
-      ${opts.includeUnnamed ? "LEFT JOIN" : "JOIN"} aliases a ON a.project_id = p.id
-      WHERE p.status = 'active'
-      ORDER BY p.updated_at DESC
-    `;
-		return this.db.prepare(sql).all();
-	}
-	async searchProjects(query, limit = 20) {
-		const q = `%${query}%`;
-		return this.db.prepare(`SELECT * FROM projects WHERE slug LIKE ? OR display_name LIKE ? OR root_path LIKE ?
-         ORDER BY updated_at DESC LIMIT ?`).all(q, q, q, limit);
-	}
-	async countProjects(opts = {}) {
-		const sql = opts.status ? "SELECT COUNT(*) AS n FROM projects WHERE status = ?" : "SELECT COUNT(*) AS n FROM projects";
-		return (opts.status ? this.db.prepare(sql).get(opts.status) : this.db.prepare(sql).get()).n;
-	}
-	async getMostRecentProjectUpdatedAt() {
-		return this.db.prepare("SELECT updated_at FROM projects ORDER BY updated_at DESC LIMIT 1").get()?.updated_at ?? null;
-	}
-	async countChildProjects(parentId) {
-		return this.db.prepare("SELECT COUNT(*) AS n FROM projects WHERE parent_id = ?").get(parentId).n;
-	}
-	async findSiblingProjectsBySlugPattern(excludeProjectId, slug, limit = 3) {
-		return this.db.prepare(`SELECT p.slug, p.root_path, COUNT(s.id) AS session_count
-         FROM projects p LEFT JOIN sessions s ON s.project_id = p.id
-         WHERE p.id != ? AND (p.slug = ? OR p.slug LIKE ? || '-%' OR ? LIKE p.slug || '-%')
-         GROUP BY p.id HAVING session_count > 0 ORDER BY session_count DESC LIMIT ?`).all(excludeProjectId, slug, slug, slug, limit);
-	}
-	async createProject(input) {
-		const type = input.type ?? "local";
-		const status = input.status ?? "active";
-		const result = this.db.prepare(`INSERT INTO projects (slug, display_name, root_path, encoded_dir, type, status, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(input.slug, input.displayName, input.rootPath, input.encodedDir, type, status, input.createdAt, input.updatedAt);
-		return await this.getProjectById(result.lastInsertRowid);
-	}
-	async createProjectWithSlugRetry(input) {
-		let slug = input.baseSlug;
-		let attempt = 0;
-		const insert = this.db.prepare(`INSERT OR IGNORE INTO projects (slug, display_name, root_path, encoded_dir, type, status, created_at, updated_at)
-       VALUES (?, ?, ?, ?, 'local', 'active', ?, ?)`);
-		while (true) {
-			const info = insert.run(slug, input.displayName, input.rootPath, input.encodedDir, input.createdAt, input.updatedAt);
-			if (info.changes > 0) return {
-				id: info.lastInsertRowid,
-				slug,
-				created: true
-			};
-			const existing = this.db.prepare("SELECT id FROM projects WHERE root_path = ?").get(input.rootPath);
-			if (existing) return {
-				id: existing.id,
-				slug,
-				created: false
-			};
-			attempt++;
-			slug = `${input.baseSlug}-${attempt}`;
-		}
-	}
-	async updateProjectPath(id, patch, updatedAt) {
-		const sets = [];
-		const params = [];
-		if (patch.rootPath !== void 0) {
-			sets.push("root_path = ?");
-			params.push(patch.rootPath);
-		}
-		if (patch.encodedDir !== void 0) {
-			sets.push("encoded_dir = ?");
-			params.push(patch.encodedDir);
-		}
-		if (updatedAt !== void 0) {
-			sets.push("updated_at = ?");
-			params.push(updatedAt);
-		}
-		if (!sets.length) return;
-		params.push(id);
-		this.db.prepare(`UPDATE projects SET ${sets.join(", ")} WHERE id = ?`).run(...params);
-	}
-	async updateProjectStatus(id, status, opts = {}) {
-		const sets = ["status = ?"];
-		const params = [status];
-		if (opts.archivedAt !== void 0) {
-			sets.push("archived_at = ?");
-			params.push(opts.archivedAt);
-		}
-		if (opts.updatedAt !== void 0) {
-			sets.push("updated_at = ?");
-			params.push(opts.updatedAt);
-		}
-		let sql = `UPDATE projects SET ${sets.join(", ")} WHERE id = ?`;
-		params.push(id);
-		if (opts.requireCurrentStatus) {
-			sql += " AND status = ?";
-			params.push(opts.requireCurrentStatus);
-		}
-		this.db.prepare(sql).run(...params);
-	}
-	async updateProjectDisplayName(id, displayName, updatedAt) {
-		if (updatedAt !== void 0) this.db.prepare("UPDATE projects SET display_name = ?, updated_at = ? WHERE id = ?").run(displayName, updatedAt, id);
-		else this.db.prepare("UPDATE projects SET display_name = ? WHERE id = ?").run(displayName, id);
-	}
-	async updateProjectType(id, type, updatedAt) {
-		if (updatedAt !== void 0) this.db.prepare("UPDATE projects SET type = ?, updated_at = ? WHERE id = ?").run(type, updatedAt, id);
-		else this.db.prepare("UPDATE projects SET type = ? WHERE id = ?").run(type, id);
-	}
-	async updateProjectSessionConfig(id, config, updatedAt) {
-		if (updatedAt !== void 0) this.db.prepare("UPDATE projects SET session_config = ?, updated_at = ? WHERE id = ?").run(config, updatedAt, id);
-		else this.db.prepare("UPDATE projects SET session_config = ? WHERE id = ?").run(config, id);
-	}
-	async updateProjectClaudeNotesDir(id, dir, updatedAt) {
-		if (updatedAt !== void 0) this.db.prepare("UPDATE projects SET claude_notes_dir = ?, updated_at = ? WHERE id = ?").run(dir, updatedAt, id);
-		else this.db.prepare("UPDATE projects SET claude_notes_dir = ? WHERE id = ?").run(dir, id);
-	}
-	async updateProjectObsidianLink(id, link, updatedAt) {
-		if (updatedAt !== void 0) this.db.prepare("UPDATE projects SET obsidian_link = ?, updated_at = ? WHERE id = ?").run(link, updatedAt, id);
-		else this.db.prepare("UPDATE projects SET obsidian_link = ? WHERE id = ?").run(link, id);
-	}
-	async updateProjectSlug(id, slug, updatedAt) {
-		this.db.prepare("UPDATE projects SET slug = ?, updated_at = ? WHERE id = ?").run(slug, updatedAt, id);
-	}
-	async reassignProjectParent(fromParentId, toParentId) {
-		return this.db.prepare("UPDATE projects SET parent_id = ? WHERE parent_id = ?").run(toParentId, fromParentId).changes;
-	}
-	async deleteProject(id) {
-		this.db.prepare("DELETE FROM projects WHERE id = ?").run(id);
-	}
-	async deleteProjectCascade(id) {
-		this.db.transaction(() => {
-			this.db.prepare("DELETE FROM links WHERE target_project_id = ?").run(id);
-			this.db.prepare("DELETE FROM links WHERE session_id IN (SELECT id FROM sessions WHERE project_id = ?)").run(id);
-			this.db.prepare("DELETE FROM compaction_log WHERE project_id = ?").run(id);
-			this.db.prepare("DELETE FROM project_tags WHERE project_id = ?").run(id);
-			this.db.prepare("DELETE FROM aliases WHERE project_id = ?").run(id);
-			this.db.prepare("DELETE FROM sessions WHERE project_id = ?").run(id);
-			this.db.prepare("DELETE FROM projects WHERE id = ?").run(id);
-		})();
-	}
-	async listTagsForProject(projectId) {
-		return this.db.prepare("SELECT t.name FROM tags t JOIN project_tags pt ON pt.tag_id = t.id WHERE pt.project_id = ? ORDER BY t.name").all(projectId).map((r) => r.name);
-	}
-	async listAllTags() {
-		return this.db.prepare("SELECT id, name FROM tags ORDER BY name").all();
-	}
-	async upsertTag(name) {
-		this.db.prepare("INSERT OR IGNORE INTO tags (name) VALUES (?)").run(name);
-		return this.db.prepare("SELECT id FROM tags WHERE name = ?").get(name).id;
-	}
-	async addProjectTag(projectId, tagId) {
-		this.db.prepare("INSERT INTO project_tags (project_id, tag_id) VALUES (?, ?)").run(projectId, tagId);
-	}
-	async projectHasTag(projectId, tagId) {
-		return !!this.db.prepare("SELECT 1 FROM project_tags WHERE project_id = ? AND tag_id = ?").get(projectId, tagId);
-	}
-	async deleteProjectTag(projectId, tagId) {
-		this.db.prepare("DELETE FROM project_tags WHERE project_id = ? AND tag_id = ?").run(projectId, tagId);
-	}
-	async reassignProjectTag(fromProjectId, toProjectId, tagId) {
-		this.db.prepare("UPDATE project_tags SET project_id = ? WHERE project_id = ? AND tag_id = ?").run(toProjectId, fromProjectId, tagId);
-	}
-	async listProjectTagIds(projectId) {
-		return this.db.prepare("SELECT tag_id FROM project_tags WHERE project_id = ?").all(projectId).map((r) => r.tag_id);
-	}
-	async countProjectTagsForProject(projectId) {
-		return this.db.prepare("SELECT COUNT(*) AS n FROM project_tags WHERE project_id = ?").get(projectId).n;
-	}
-	async copyProjectTags(fromProjectId, toProjectId) {
-		this.db.prepare("INSERT OR IGNORE INTO project_tags (project_id, tag_id) SELECT ?, tag_id FROM project_tags WHERE project_id = ?").run(toProjectId, fromProjectId);
-	}
-	async deleteProjectTagsForProject(projectId) {
-		this.db.prepare("DELETE FROM project_tags WHERE project_id = ?").run(projectId);
-	}
-	async resolveAlias(alias) {
-		return this.db.prepare("SELECT project_id FROM aliases WHERE alias = ?").get(alias)?.project_id ?? null;
-	}
-	async listAliasesForProject(projectId) {
-		return this.db.prepare("SELECT alias FROM aliases WHERE project_id = ? ORDER BY alias").all(projectId).map((r) => r.alias);
-	}
-	async addAlias(alias, projectId) {
-		this.db.prepare("INSERT INTO aliases (alias, project_id) VALUES (?, ?)").run(alias, projectId);
-	}
-	async removeAlias(alias) {
-		this.db.prepare("DELETE FROM aliases WHERE alias = ?").run(alias);
-	}
-	async countAliasesForProject(projectId) {
-		return this.db.prepare("SELECT COUNT(*) AS n FROM aliases WHERE project_id = ?").get(projectId).n;
-	}
-	async moveProjectAliases(fromProjectId, toProjectId) {
-		this.db.prepare("UPDATE aliases SET project_id = ? WHERE project_id = ?").run(toProjectId, fromProjectId);
-	}
-	async reassignAlias(alias, toProjectId) {
-		this.db.prepare("UPDATE aliases SET project_id = ? WHERE alias = ?").run(toProjectId, alias);
-	}
-	async listAliasMap() {
-		return this.db.prepare(`SELECT a.alias AS alias, p.slug AS slug, p.root_path AS root_path
-         FROM aliases a JOIN projects p ON p.id = a.project_id WHERE p.status != 'archived'`).all();
-	}
-	async getSessionById(id) {
-		return this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id) ?? null;
-	}
-	async getSessionByNumber(projectId, number) {
-		return this.db.prepare("SELECT * FROM sessions WHERE project_id = ? AND number = ?").get(projectId, number) ?? null;
-	}
-	async getLatestSessionForProject(projectId) {
-		return this.db.prepare("SELECT * FROM sessions WHERE project_id = ? ORDER BY number DESC LIMIT 1").get(projectId) ?? null;
-	}
-	async getMaxSessionNumber(projectId) {
-		return this.db.prepare("SELECT COALESCE(MAX(number), 0) AS n FROM sessions WHERE project_id = ?").get(projectId).n;
-	}
-	async listSessionsForProject(projectId, opts = {}) {
-		let sql = `SELECT * FROM sessions WHERE project_id = ? ORDER BY ${opts.orderBy === "created_desc" ? "created_at DESC" : "number ASC"}`;
-		const params = [projectId];
-		if (opts.limit !== void 0) {
-			sql += " LIMIT ?";
-			params.push(opts.limit);
-		}
-		return this.db.prepare(sql).all(...params);
-	}
-	async listSessions(opts = {}) {
-		const where = [];
-		const params = [];
-		if (opts.projectId !== void 0) {
-			where.push("s.project_id = ?");
-			params.push(opts.projectId);
-		}
-		if (opts.status) {
-			where.push("s.status = ?");
-			params.push(opts.status);
-		}
-		let sql = `
-      SELECT s.*, p.slug AS project_slug, p.display_name AS project_name
-      FROM sessions s JOIN projects p ON p.id = s.project_id
-    `;
-		if (where.length) sql += " WHERE " + where.join(" AND ");
-		sql += " ORDER BY s.date DESC, s.number DESC";
-		const limit = opts.limit ?? 20;
-		sql += ` LIMIT ${limit}`;
-		return this.db.prepare(sql).all(...params);
-	}
-	async findSessionByFilename(projectId, filename) {
-		return this.db.prepare("SELECT id FROM sessions WHERE project_id = ? AND filename = ? LIMIT 1").get(projectId, filename) ?? null;
-	}
-	async sessionNumberTaken(projectId, number) {
-		return !!this.db.prepare("SELECT 1 FROM sessions WHERE project_id = ? AND number = ? LIMIT 1").get(projectId, number);
-	}
-	async createSession(input) {
-		const status = input.status ?? "completed";
-		const result = this.db.prepare(`INSERT INTO sessions (project_id, number, date, slug, title, filename, status, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(input.projectId, input.number, input.date, input.slug, input.title, input.filename, status, input.createdAt);
-		return await this.getSessionById(result.lastInsertRowid);
-	}
-	async upsertSessionIfAbsent(input) {
-		if (this.db.prepare("SELECT id FROM sessions WHERE project_id = ? AND number = ?").get(input.projectId, input.number)) return false;
-		const status = input.status ?? "completed";
-		this.db.prepare(`INSERT INTO sessions (project_id, number, date, slug, title, filename, status, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(input.projectId, input.number, input.date, input.slug, input.title, input.filename, status, input.createdAt);
-		return true;
-	}
-	async updateSessionMeta(id, patch) {
-		const sets = [];
-		const params = [];
-		if (patch.slug !== void 0) {
-			sets.push("slug = ?");
-			params.push(patch.slug);
-		}
-		if (patch.title !== void 0) {
-			sets.push("title = ?");
-			params.push(patch.title);
-		}
-		if (patch.filename !== void 0) {
-			sets.push("filename = ?");
-			params.push(patch.filename);
-		}
-		if (!sets.length) return;
-		params.push(id);
-		this.db.prepare(`UPDATE sessions SET ${sets.join(", ")} WHERE id = ?`).run(...params);
-	}
-	async updateSessionNumber(id, number, opts = {}) {
-		if (opts.filename !== void 0) this.db.prepare("UPDATE sessions SET number = ?, filename = ? WHERE id = ?").run(number, opts.filename, id);
-		else this.db.prepare("UPDATE sessions SET number = ? WHERE id = ?").run(number, id);
-	}
-	async updateSessionFilename(id, filename) {
-		this.db.prepare("UPDATE sessions SET filename = ? WHERE id = ?").run(filename, id);
-	}
-	async updateSessionStatus(id, status, opts = {}) {
-		if (opts.closedAt !== void 0) this.db.prepare("UPDATE sessions SET status = ?, closed_at = ? WHERE id = ?").run(status, opts.closedAt, id);
-		else this.db.prepare("UPDATE sessions SET status = ? WHERE id = ?").run(status, id);
-	}
-	async moveSessionToProject(id, projectId, opts = {}) {
-		if (opts.number !== void 0) this.db.prepare("UPDATE sessions SET project_id = ?, number = ? WHERE id = ?").run(projectId, opts.number, id);
-		else this.db.prepare("UPDATE sessions SET project_id = ? WHERE id = ?").run(projectId, id);
-	}
-	async deleteSession(id) {
-		this.db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
-	}
-	async backfillFoldedSession(keepId, dropId) {
-		this.db.prepare(`UPDATE sessions SET
-           claude_session_id = COALESCE(claude_session_id,
-                                        (SELECT claude_session_id FROM sessions WHERE id = ?)),
-           token_count       = COALESCE(token_count,
-                                        (SELECT token_count FROM sessions WHERE id = ?)),
-           closed_at         = COALESCE(closed_at,
-                                        (SELECT closed_at FROM sessions WHERE id = ?)),
-           status            = CASE WHEN status = 'open'
-                                     AND (SELECT status FROM sessions WHERE id = ?) != 'open'
-                                    THEN (SELECT status FROM sessions WHERE id = ?)
-                                    ELSE status END
-         WHERE id = ?`).run(dropId, dropId, dropId, dropId, dropId, keepId);
-	}
-	async countSessionsForProject(projectId) {
-		return this.db.prepare("SELECT COUNT(*) AS n FROM sessions WHERE project_id = ?").get(projectId).n;
-	}
-	async countSessions() {
-		return this.db.prepare("SELECT COUNT(*) AS n FROM sessions").get().n;
-	}
-	async getMostRecentSessionDate(projectId) {
-		return this.db.prepare("SELECT date FROM sessions WHERE project_id = ? ORDER BY date DESC LIMIT 1").get(projectId)?.date ?? null;
-	}
-	async getMostRecentSessionCreatedAt() {
-		return this.db.prepare("SELECT created_at FROM sessions ORDER BY created_at DESC LIMIT 1").get()?.created_at ?? null;
-	}
-	async listSessionTagIds(sessionId) {
-		return this.db.prepare("SELECT tag_id FROM session_tags WHERE session_id = ?").all(sessionId).map((r) => r.tag_id);
-	}
-	async sessionHasTag(sessionId, tagId) {
-		return !!this.db.prepare("SELECT 1 FROM session_tags WHERE session_id = ? AND tag_id = ?").get(sessionId, tagId);
-	}
-	async addSessionTag(sessionId, tagId) {
-		this.db.prepare("INSERT INTO session_tags (session_id, tag_id) VALUES (?, ?)").run(sessionId, tagId);
-	}
-	async deleteSessionTag(sessionId, tagId) {
-		this.db.prepare("DELETE FROM session_tags WHERE session_id = ? AND tag_id = ?").run(sessionId, tagId);
-	}
-	async reassignSessionTag(fromSessionId, toSessionId, tagId) {
-		this.db.prepare("UPDATE session_tags SET session_id = ? WHERE session_id = ? AND tag_id = ?").run(toSessionId, fromSessionId, tagId);
-	}
-	async listTagsForSession(sessionId) {
-		return this.db.prepare("SELECT t.name FROM tags t JOIN session_tags st ON st.tag_id = t.id WHERE st.session_id = ? ORDER BY t.name").all(sessionId).map((r) => r.name);
-	}
-	async addLink(input) {
-		this.db.prepare("INSERT INTO links (session_id, target_project_id, link_type, created_at) VALUES (?, ?, ?, ?)").run(input.sessionId, input.targetProjectId, input.linkType, input.createdAt);
-	}
-	async listLinksForSession(sessionId) {
-		return this.db.prepare("SELECT id, target_project_id FROM links WHERE session_id = ?").all(sessionId);
-	}
-	async listLinksForProject(projectId) {
-		return this.db.prepare("SELECT id, session_id FROM links WHERE target_project_id = ?").all(projectId);
-	}
-	async linkExists(sessionId, targetProjectId) {
-		return !!this.db.prepare("SELECT 1 FROM links WHERE session_id = ? AND target_project_id = ? LIMIT 1").get(sessionId, targetProjectId);
-	}
-	async deleteLink(id) {
-		this.db.prepare("DELETE FROM links WHERE id = ?").run(id);
-	}
-	async deleteLinksTargetingProject(projectId) {
-		this.db.prepare("DELETE FROM links WHERE target_project_id = ?").run(projectId);
-	}
-	async deleteLinksFromProjectSessions(projectId) {
-		this.db.prepare("DELETE FROM links WHERE session_id IN (SELECT id FROM sessions WHERE project_id = ?)").run(projectId);
-	}
-	async retargetLink(id, targetProjectId) {
-		this.db.prepare("UPDATE links SET target_project_id = ? WHERE id = ?").run(targetProjectId, id);
-	}
-	async moveLinkToSession(id, sessionId) {
-		this.db.prepare("UPDATE links SET session_id = ? WHERE id = ?").run(sessionId, id);
-	}
-	async reassignLinksTarget(fromProjectId, toProjectId) {
-		this.db.prepare("UPDATE OR IGNORE links SET target_project_id = ? WHERE target_project_id = ?").run(toProjectId, fromProjectId);
-	}
-	async countLinksForProject(projectId) {
-		return this.db.prepare("SELECT COUNT(*) AS n FROM links WHERE target_project_id = ?").get(projectId).n;
-	}
-	async deleteSelfLinksForProject(projectId) {
-		this.db.prepare(`DELETE FROM links WHERE target_project_id = ?
-           AND session_id IN (SELECT id FROM sessions WHERE project_id = ?)`).run(projectId, projectId);
-	}
-	async appendCompactionLog(entry) {
-		this.db.prepare(`INSERT INTO compaction_log (project_id, session_id, trigger, files_written, token_count, created_at)
-         VALUES (?, ?, ?, ?, ?, ?)`).run(entry.projectId, entry.sessionId, entry.trigger, entry.filesWritten, entry.tokenCount, entry.createdAt);
-	}
-	async countCompactionLogsForProject(projectId) {
-		return this.db.prepare("SELECT COUNT(*) AS n FROM compaction_log WHERE project_id = ?").get(projectId).n;
-	}
-	async moveCompactionLogsByProject(fromProjectId, toProjectId) {
-		return this.db.prepare("UPDATE compaction_log SET project_id = ? WHERE project_id = ?").run(toProjectId, fromProjectId).changes;
-	}
-	async moveCompactionLogsBySession(fromSessionId, toSessionId) {
-		this.db.prepare("UPDATE compaction_log SET session_id = ? WHERE session_id = ?").run(toSessionId, fromSessionId);
-	}
-	async deleteCompactionLogsForProject(projectId) {
-		this.db.prepare("DELETE FROM compaction_log WHERE project_id = ?").run(projectId);
-	}
-	async planProjectMerge(fromSlug, intoSlug) {
-		return planMerge(this.db, fromSlug, intoSlug);
-	}
-	async applyProjectMerge(plan) {
-		applyMerge(this.db, plan);
-	}
-};
-
-//#endregion
-export { SQLiteRegistryBackend };
-//# sourceMappingURL=registry-sqlite-DrCW1aRK.mjs.map