@aigne/afs-did-space 1.12.0-beta.5

package/dist/metadata-db.d.mts

@@ -0,0 +1,102 @@
+import { PutOpts } from "./tree-index.mjs";
+import * as _libsql_client0 from "@libsql/client";
+
+//#region src/metadata-db.d.ts
+interface EntryRow {
+  scope: string;
+  path: string;
+  parent: string;
+  name: string;
+  kind: "file" | "dir";
+  cid: string | null;
+  size: number;
+  mime_type: string | null;
+  ctime: number;
+  mtime: number;
+}
+interface CidCacheRow {
+  path: string;
+  cid: string;
+  size: number;
+  mtime_ms: number;
+  computed_at: number;
+}
+interface CheckpointRow {
+  session_id: string;
+  direction: string;
+  remote_url: string;
+  base_path: string;
+  status: string;
+  diff_json: string;
+  /** JSON-encoded string[] of completed file paths */
+  completed: string;
+  created_at: number;
+  updated_at: number;
+}
+declare class MetadataDB {
+  private client;
+  readonly dbPath: string;
+  private constructor();
+  /**
+   * Internal: the raw libsql client, for `SQLiteTreeIndex` to run the same
+   * atomic batches / queries D1TreeIndex runs on D1 (shared `entries` +
+   * `changelog` tables). Kept package-internal — application code must go
+   * through AFS / the TreeIndex interface, never this client directly.
+   */
+  get rawClient(): _libsql_client0.Client;
+  /**
+   * Open (or create) _metadata.db in the given directory.
+   * Creates the directory if it does not exist.
+   *
+   * Executes the core schema (entries / cid_cache / sync_checkpoint) AND the
+   * Phase 2 changelog table DDL. Changelog DDL is imported from
+   * `changelog-schema.ts` so that D1, desktop SQLite, and the Swift/Kotlin
+   * runtimes share byte-identical statements (verified by the CI parity
+   * check).
+   */
+  static open(userDir: string): Promise<MetadataDB>;
+  /** Return all file entries (kind='file') for the given scope. */
+  getFiles(scope: string, basePath?: string): Promise<EntryRow[]>;
+  /**
+   * Read the current cid for (scope, path). Internal helper for atomic
+   * changelog writes — callers need the old_cid to populate the changelog
+   * row. Returns null if the row does not exist OR if its cid is null
+   * (directory row).
+   */
+  private getCurrentCid;
+  /**
+   * Upsert a single entry. Writes `entries` + `changelog` atomically via libsql batch.
+   *
+   * Directory rows (kind='dir') and rows with cid=null never produce a
+   * changelog entry — the changelog tracks file content mutations only.
+   */
+  upsertEntry(row: EntryRow, opts: PutOpts): Promise<void>;
+  /** Upsert multiple entries in a single atomic transaction. */
+  upsertEntries(rows: EntryRow[], opts: PutOpts): Promise<void>;
+  /** Delete an entry by scope + path. Writes changelog delete row atomically. */
+  deleteEntry(scope: string, path: string, opts: PutOpts): Promise<void>;
+  /** Delete all file entries for a scope whose paths are NOT in the given set. */
+  deleteEntriesNotIn(scope: string, keepPaths: Set<string>, opts: PutOpts): Promise<void>;
+  /** Get CID cache entry for a filesystem path. Returns null on cache miss. */
+  getCidCache(path: string): Promise<CidCacheRow | null>;
+  /** Set (insert or replace) a CID cache entry. */
+  setCidCache(row: CidCacheRow): Promise<void>;
+  /**
+   * Get the most recent active checkpoint for the given (direction, remoteUrl, basePath).
+   * Returns null when no active session exists.
+   */
+  getActiveCheckpoint(direction: string, remoteUrl: string, basePath: string): Promise<CheckpointRow | null>;
+  /** Insert a new checkpoint record. */
+  createCheckpoint(row: CheckpointRow): Promise<void>;
+  /** Update the completed paths list for an active checkpoint. */
+  updateCheckpointCompleted(sessionId: string, completedPaths: string[]): Promise<void>;
+  /** Mark a checkpoint as done. */
+  completeCheckpoint(sessionId: string): Promise<void>;
+  /** Get a checkpoint by session_id (for test assertions). */
+  getCheckpoint(sessionId: string): Promise<CheckpointRow | null>;
+  /** Close the database connection. */
+  close(): void;
+}
+//#endregion
+export { CidCacheRow, EntryRow, MetadataDB };
+//# sourceMappingURL=metadata-db.d.mts.map

package/dist/metadata-db.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata-db.d.mts","names":[],"sources":["../src/metadata-db.ts"],"mappings":";;;;UA6CiB,QAAA;EACf,KAAA;EACA,IAAA;EACA,MAAA;EACA,IAAA;EACA,IAAA;EACA,GAAA;EACA,IAAA;EACA,SAAA;EACA,KAAA;EACA,KAAA;AAAA;AAAA,UAGe,WAAA;EACf,IAAA;EACA,GAAA;EACA,IAAA;EACA,QAAA;EACA,WAAA;AAAA;AAAA,UAGe,aAAA;EACf,UAAA;EACA,SAAA;EACA,UAAA;EACA,SAAA;EACA,MAAA;EACA,SAAA;EADA;EAGA,SAAA;EACA,UAAA;EACA,UAAA;AAAA;AAAA,cA0GW,UAAA;EAAA,QACH,MAAA;EAAA,SACC,MAAA;EAAA,QAEF,WAAA,CAAA;;;;;;;MAWH,SAAA,CAAA,GAfiB,eAAA,CAeqB,MAAA;EAmOH;;;;;;;;;;EAAA,OArN1B,IAAA,CAAK,OAAA,WAAkB,OAAA,CAAQ,UAAA;EAmaX;EAvP3B,QAAA,CAAS,KAAA,UAAe,QAAA,YAAoB,OAAA,CAAQ,QAAA;EAiQrB;;;;;;EAAA,QAxOvB,aAAA;EAsSkC;;;;;;EAtR1C,WAAA,CAAY,GAAA,EAAK,QAAA,EAAU,IAAA,EAAM,OAAA,GAAU,OAAA;EAnO7C;EA+QE,aAAA,CAAc,IAAA,EAAM,QAAA,IAAY,IAAA,EAAM,OAAA,GAAU,OAAA;EAjQzC;EAqUP,WAAA,CAAY,KAAA,UAAe,IAAA,UAAc,IAAA,EAAM,OAAA,GAAU,OAAA;EArU3B;EA+V9B,kBAAA,CAAmB,KAAA,UAAe,SAAA,EAAW,GAAA,UAAa,IAAA,EAAM,OAAA,GAAU,OAAA;EAnL1E;EAuPA,WAAA,CAAY,IAAA,WAAe,OAAA,CAAQ,WAAA;EAvPX;EAiQxB,WAAA,CAAY,GAAA,EAAK,WAAA,GAAc,OAAA;EAjQqB;;;;EA+QpD,mBAAA,CACJ,SAAA,UACA,SAAA,UACA,QAAA,WACC,OAAA,CAAQ,aAAA;EA1O4B;EAoPjC,gBAAA,CAAiB,GAAA,EAAK,aAAA,GAAgB,OAAA;EApPK;EAsQ3C,yBAAA,CAA0B,SAAA,UAAmB,cAAA,aAA2B,OAAA;EA1NpD;EAkOpB,kBAAA,CAAmB,SAAA,WAAoB,OAAA;EAlOD;EA0OtC,aAAA,CAAc,SAAA,WAAoB,OAAA,CAAQ,aAAA;EA1OM;EAsPtD,KAAA,CAAA;AAAA"}

package/dist/metadata-db.mjs

@@ -0,0 +1,562 @@
+import { CHANGELOG_INDEX_SQL, CHANGELOG_TABLE_SQL, PREFIX_WATERMARK_TABLE_SQL, SYNC_STATE_INDEX_SQL, SYNC_STATE_TABLE_SQL } from "./changelog-schema.mjs";
+import { ENTRIES_CONTENT_TYPE_COLUMN_SQL, ENTRIES_CONTENT_TYPE_INDEX_DROP_SQL, ENTRIES_DEDUP_INDEX_SQL, ENTRIES_DEDUP_KEY_COLUMN_SQL, ENTRIES_DEDUP_SCOPE_COLUMN_SQL, ENTRIES_INLINE_CONTENT_COLUMN_SQL, ENTRIES_METADATA_COLUMN_SQL, UPLOAD_SESSIONS_INDEX_SQL, UPLOAD_SESSIONS_TABLE_SQL, UPLOAD_SESSION_ENTRIES_TABLE_SQL } from "./d1-schema.mjs";
+import { CHANGELOG_INSERT_SQL, validateDeviceId } from "./changelog-write.mjs";
+import { DIRTY_PATH_INDEX_SQL, DIRTY_PATH_TABLE_SQL, DIRTY_PATH_TRIGGER_SQL } from "./dirty-path-schema.mjs";
+import { renameLegacyTable } from "./rename-guard.mjs";
+import { mkdirSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+//#region src/metadata-db.ts
+/**
+* MetadataDB — local SQLite index for DID Space files.
+*
+* Opened at: ~/.afs/spaces/{userDid}/_metadata.db
+*
+* Tables:
+*   entries        — same schema as D1 (entries table in scalability-design §4.1)
+*   cid_cache      — path → cid + mtime_ms for avoiding repeated hash computation
+*   sync_checkpoint — persistent sync state for resume-on-failure (Phase 3)
+*
+* SQLite tuning: WAL, cache_size 256 MB, mmap 1 GB, busy_timeout 30 s.
+*/
+const DB_FILENAME = "_metadata.db";
+const SCHEMA_SQL = `
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = NORMAL;
+PRAGMA cache_size = -262144;
+PRAGMA mmap_size = 1073741824;
+PRAGMA busy_timeout = 30000;
+PRAGMA wal_autocheckpoint = 10000;
+
+CREATE TABLE IF NOT EXISTS ds_entries (
+  scope       TEXT    NOT NULL,
+  path        TEXT    NOT NULL,
+  parent      TEXT    NOT NULL,
+  name        TEXT    NOT NULL,
+  kind        TEXT    NOT NULL DEFAULT 'file',
+  cid         TEXT,
+  size        INTEGER NOT NULL DEFAULT 0,
+  mime_type   TEXT,
+  ctime       INTEGER NOT NULL,
+  mtime       INTEGER NOT NULL,
+  PRIMARY KEY (scope, path),
+  CHECK (LENGTH(path) <= 4096),
+  CHECK (LENGTH(name) <= 255),
+  CHECK (kind IN ('file', 'dir')),
+  CHECK (LENGTH(scope) <= 128)
+) WITHOUT ROWID;
+
+CREATE INDEX IF NOT EXISTS idx_entries_children
+  ON ds_entries(scope, parent, name);
+
+CREATE INDEX IF NOT EXISTS idx_entries_mtime
+  ON ds_entries(scope, mtime DESC);
+
+CREATE INDEX IF NOT EXISTS idx_entries_kind
+  ON ds_entries(scope, kind);
+
+CREATE INDEX IF NOT EXISTS idx_entries_cid
+  ON ds_entries(cid) WHERE cid IS NOT NULL;
+
+-- Ordered listChildren (did-space-sorting Phase 2): scope+parent equality,
+-- mtime/ctime range order, name tiebreak — index-only ordered scans.
+CREATE INDEX IF NOT EXISTS idx_entries_parent_mtime
+  ON ds_entries(scope, parent, mtime, name);
+
+CREATE INDEX IF NOT EXISTS idx_entries_parent_ctime
+  ON ds_entries(scope, parent, ctime, name);
+
+CREATE TABLE IF NOT EXISTS cid_cache (
+  path         TEXT    PRIMARY KEY,
+  cid          TEXT    NOT NULL,
+  size         INTEGER NOT NULL,
+  mtime_ms     INTEGER NOT NULL,
+  computed_at  INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS sync_checkpoint (
+  session_id   TEXT    PRIMARY KEY,
+  direction    TEXT    NOT NULL,
+  remote_url   TEXT    NOT NULL,
+  base_path    TEXT    NOT NULL,
+  status       TEXT    NOT NULL DEFAULT 'active',
+  diff_json    TEXT    NOT NULL,
+  completed    TEXT    NOT NULL DEFAULT '[]',
+  created_at   INTEGER NOT NULL,
+  updated_at   INTEGER NOT NULL
+);
+`;
+var MetadataDB = class MetadataDB {
+	client;
+	dbPath;
+	constructor(client, dbPath) {
+		this.client = client;
+		this.dbPath = dbPath;
+	}
+	/**
+	* Internal: the raw libsql client, for `SQLiteTreeIndex` to run the same
+	* atomic batches / queries D1TreeIndex runs on D1 (shared `entries` +
+	* `changelog` tables). Kept package-internal — application code must go
+	* through AFS / the TreeIndex interface, never this client directly.
+	*/
+	get rawClient() {
+		return this.client;
+	}
+	/**
+	* Open (or create) _metadata.db in the given directory.
+	* Creates the directory if it does not exist.
+	*
+	* Executes the core schema (entries / cid_cache / sync_checkpoint) AND the
+	* Phase 2 changelog table DDL. Changelog DDL is imported from
+	* `changelog-schema.ts` so that D1, desktop SQLite, and the Swift/Kotlin
+	* runtimes share byte-identical statements (verified by the CI parity
+	* check).
+	*/
+	static async open(userDir) {
+		const dbPath = join(userDir, DB_FILENAME);
+		mkdirSync(dirname(dbPath), { recursive: true });
+		const { createClient } = await import("@libsql/client");
+		const statements = [
+			...SCHEMA_SQL.split(";").map((s) => s.trim()).filter((s) => s.length > 0),
+			CHANGELOG_TABLE_SQL,
+			...CHANGELOG_INDEX_SQL,
+			SYNC_STATE_TABLE_SQL,
+			...SYNC_STATE_INDEX_SQL,
+			PREFIX_WATERMARK_TABLE_SQL,
+			DIRTY_PATH_TABLE_SQL,
+			...DIRTY_PATH_INDEX_SQL,
+			...DIRTY_PATH_TRIGGER_SQL,
+			UPLOAD_SESSIONS_TABLE_SQL,
+			UPLOAD_SESSION_ENTRIES_TABLE_SQL,
+			...UPLOAD_SESSIONS_INDEX_SQL
+		];
+		async function tryOpen() {
+			const client$1 = createClient({ url: `file:${dbPath}` });
+			for (const [oldName, newName] of [
+				["entries", "ds_entries"],
+				["changelog", "ds_changelog"],
+				["gc_queue", "ds_gc_queue"],
+				["sync_state", "ds_sync_state"],
+				["prefix_watermark", "ds_prefix_watermark"],
+				["upload_sessions", "ds_upload_sessions"],
+				["upload_session_entries", "ds_upload_session_entries"],
+				["versioned_scopes", "ds_versioned_scopes"],
+				["scope_meta", "ds_scope_meta"],
+				["device_sync_state", "ds_device_sync_state"]
+			]) await renameLegacyTable(client$1, oldName, newName);
+			for (const stmt of statements) await client$1.execute(stmt);
+			const cols = await client$1.execute("SELECT name FROM pragma_table_info('ds_entries')");
+			const colNames = new Set(cols.rows.map((r) => String(r.name)));
+			if (!colNames.has("content")) try {
+				await client$1.execute(ENTRIES_INLINE_CONTENT_COLUMN_SQL);
+			} catch (err) {
+				if (!(err instanceof Error ? err.message : String(err)).includes("duplicate column name")) throw err;
+			}
+			if (!colNames.has("metadata")) try {
+				await client$1.execute(ENTRIES_METADATA_COLUMN_SQL);
+			} catch (err) {
+				if (!(err instanceof Error ? err.message : String(err)).includes("duplicate column name")) throw err;
+			}
+			if (!colNames.has("dedup_scope")) try {
+				await client$1.execute(ENTRIES_DEDUP_SCOPE_COLUMN_SQL);
+			} catch (err) {
+				if (!(err instanceof Error ? err.message : String(err)).includes("duplicate column name")) throw err;
+			}
+			if (!colNames.has("dedup_key")) try {
+				await client$1.execute(ENTRIES_DEDUP_KEY_COLUMN_SQL);
+			} catch (err) {
+				if (!(err instanceof Error ? err.message : String(err)).includes("duplicate column name")) throw err;
+			}
+			await client$1.execute(ENTRIES_DEDUP_INDEX_SQL);
+			if (!colNames.has("content_type")) try {
+				await client$1.execute(ENTRIES_CONTENT_TYPE_COLUMN_SQL);
+			} catch (err) {
+				if (!(err instanceof Error ? err.message : String(err)).includes("duplicate column name")) throw err;
+			}
+			await client$1.execute(ENTRIES_CONTENT_TYPE_INDEX_DROP_SQL);
+			await client$1.execute("SELECT COUNT(*) FROM ds_entries");
+			await client$1.execute("SELECT COUNT(*) FROM ds_changelog");
+			await client$1.execute("SELECT COUNT(*) FROM ds_sync_state");
+			await client$1.execute("SELECT COUNT(*) FROM ds_dirty_path");
+			return client$1;
+		}
+		let client;
+		try {
+			client = await tryOpen();
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			if (msg.includes("SQLITE_CORRUPT") || msg.includes("SQLITE_NOTADB") || msg.includes("database disk image is malformed") || msg.includes("file is not a database")) {
+				for (const suffix of [
+					"",
+					"-wal",
+					"-shm"
+				]) rmSync(dbPath + suffix, { force: true });
+				client = await tryOpen();
+			} else throw err;
+		}
+		return new MetadataDB(client, dbPath);
+	}
+	/** Return all file entries (kind='file') for the given scope. */
+	async getFiles(scope, basePath) {
+		let sql;
+		let args;
+		if (basePath) {
+			const end = basePath.slice(0, -1) + String.fromCharCode(basePath.charCodeAt(basePath.length - 1) + 1);
+			sql = `SELECT * FROM ds_entries WHERE scope = ? AND kind = 'file' AND path >= ? AND path < ? ORDER BY path`;
+			args = [
+				scope,
+				basePath,
+				end
+			];
+		} else {
+			sql = `SELECT * FROM ds_entries WHERE scope = ? AND kind = 'file' ORDER BY path`;
+			args = [scope];
+		}
+		return (await this.client.execute({
+			sql,
+			args
+		})).rows.map(toEntryRow);
+	}
+	/**
+	* Read the current cid for (scope, path). Internal helper for atomic
+	* changelog writes — callers need the old_cid to populate the changelog
+	* row. Returns null if the row does not exist OR if its cid is null
+	* (directory row).
+	*/
+	async getCurrentCid(scope, path) {
+		const result = await this.client.execute({
+			sql: `SELECT cid FROM ds_entries WHERE scope = ? AND path = ?`,
+			args: [scope, path]
+		});
+		if (result.rows.length === 0) return null;
+		return result.rows[0][0] ?? null;
+	}
+	/**
+	* Upsert a single entry. Writes `entries` + `changelog` atomically via libsql batch.
+	*
+	* Directory rows (kind='dir') and rows with cid=null never produce a
+	* changelog entry — the changelog tracks file content mutations only.
+	*/
+	async upsertEntry(row, opts) {
+		validateDeviceId(opts.deviceId);
+		const oldCid = !opts.skipChangelog && row.kind === "file" ? await this.getCurrentCid(row.scope, row.path) : null;
+		const stmts = [{
+			sql: `INSERT OR REPLACE INTO ds_entries
+        (scope, path, parent, name, kind, cid, size, mime_type, ctime, mtime)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			args: [
+				row.scope,
+				row.path,
+				row.parent,
+				row.name,
+				row.kind,
+				row.cid ?? null,
+				row.size,
+				row.mime_type ?? null,
+				row.ctime,
+				row.mtime
+			]
+		}];
+		if (!opts.skipChangelog && row.kind === "file" && row.cid) stmts.push({
+			sql: CHANGELOG_INSERT_SQL,
+			args: [
+				row.scope,
+				row.path,
+				"put",
+				row.cid,
+				oldCid,
+				row.size,
+				row.mtime,
+				opts.deviceId
+			]
+		});
+		await this.client.batch(stmts, "write");
+	}
+	/** Upsert multiple entries in a single atomic transaction. */
+	async upsertEntries(rows, opts) {
+		if (rows.length === 0) return;
+		validateDeviceId(opts.deviceId);
+		const oldCidMap = /* @__PURE__ */ new Map();
+		if (!opts.skipChangelog) {
+			const byScope = /* @__PURE__ */ new Map();
+			for (const r of rows) {
+				if (r.kind !== "file") continue;
+				const list = byScope.get(r.scope) ?? [];
+				list.push(r.path);
+				byScope.set(r.scope, list);
+			}
+			for (const [scope, paths] of byScope) {
+				if (paths.length === 0) continue;
+				const placeholders = paths.map(() => "?").join(",");
+				const result = await this.client.execute({
+					sql: `SELECT path, cid FROM ds_entries WHERE scope = ? AND path IN (${placeholders}) AND cid IS NOT NULL`,
+					args: [scope, ...paths]
+				});
+				for (const r of result.rows) {
+					const path = r[0];
+					const cid = r[1];
+					if (cid) oldCidMap.set(`${scope}\x00${path}`, cid);
+				}
+			}
+		}
+		const stmts = [];
+		for (const row of rows) {
+			stmts.push({
+				sql: `INSERT OR REPLACE INTO ds_entries
+        (scope, path, parent, name, kind, cid, size, mime_type, ctime, mtime)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+				args: [
+					row.scope,
+					row.path,
+					row.parent,
+					row.name,
+					row.kind,
+					row.cid ?? null,
+					row.size,
+					row.mime_type ?? null,
+					row.ctime,
+					row.mtime
+				]
+			});
+			if (!opts.skipChangelog && row.kind === "file" && row.cid) {
+				const oldCid = oldCidMap.get(`${row.scope}\x00${row.path}`) ?? null;
+				stmts.push({
+					sql: CHANGELOG_INSERT_SQL,
+					args: [
+						row.scope,
+						row.path,
+						"put",
+						row.cid,
+						oldCid,
+						row.size,
+						row.mtime,
+						opts.deviceId
+					]
+				});
+			}
+		}
+		await this.client.batch(stmts, "write");
+	}
+	/** Delete an entry by scope + path. Writes changelog delete row atomically. */
+	async deleteEntry(scope, path, opts) {
+		validateDeviceId(opts.deviceId);
+		const oldCid = opts.skipChangelog ? null : await this.getCurrentCid(scope, path);
+		const stmts = [{
+			sql: `DELETE FROM ds_entries WHERE scope = ? AND path = ?`,
+			args: [scope, path]
+		}];
+		if (!opts.skipChangelog && oldCid) stmts.push({
+			sql: CHANGELOG_INSERT_SQL,
+			args: [
+				scope,
+				path,
+				"delete",
+				null,
+				oldCid,
+				null,
+				Date.now(),
+				opts.deviceId
+			]
+		});
+		await this.client.batch(stmts, "write");
+	}
+	/** Delete all file entries for a scope whose paths are NOT in the given set. */
+	async deleteEntriesNotIn(scope, keepPaths, opts) {
+		validateDeviceId(opts.deviceId);
+		if (keepPaths.size === 0) {
+			let filesToLog = [];
+			if (!opts.skipChangelog) filesToLog = (await this.client.execute({
+				sql: `SELECT path, cid FROM ds_entries WHERE scope = ? AND kind = 'file' AND cid IS NOT NULL`,
+				args: [scope]
+			})).rows.map((r) => ({
+				path: r[0],
+				cid: r[1]
+			}));
+			const stmts$1 = [{
+				sql: `DELETE FROM ds_entries WHERE scope = ?`,
+				args: [scope]
+			}];
+			const now$1 = Date.now();
+			for (const row of filesToLog) stmts$1.push({
+				sql: CHANGELOG_INSERT_SQL,
+				args: [
+					scope,
+					row.path,
+					"delete",
+					null,
+					row.cid,
+					null,
+					now$1,
+					opts.deviceId
+				]
+			});
+			await this.client.batch(stmts$1, "write");
+			return;
+		}
+		const result = await this.client.execute({
+			sql: `SELECT path, cid FROM ds_entries WHERE scope = ? AND kind = 'file'`,
+			args: [scope]
+		});
+		const toDelete = [];
+		for (const r of result.rows) {
+			const path = r[0];
+			const cid = r[1];
+			if (!keepPaths.has(path)) toDelete.push({
+				path,
+				cid
+			});
+		}
+		if (toDelete.length === 0) return;
+		const stmts = [];
+		const now = Date.now();
+		for (const row of toDelete) {
+			stmts.push({
+				sql: `DELETE FROM ds_entries WHERE scope = ? AND path = ?`,
+				args: [scope, row.path]
+			});
+			if (!opts.skipChangelog && row.cid) stmts.push({
+				sql: CHANGELOG_INSERT_SQL,
+				args: [
+					scope,
+					row.path,
+					"delete",
+					null,
+					row.cid,
+					null,
+					now,
+					opts.deviceId
+				]
+			});
+		}
+		await this.client.batch(stmts, "write");
+	}
+	/** Get CID cache entry for a filesystem path. Returns null on cache miss. */
+	async getCidCache(path) {
+		const result = await this.client.execute({
+			sql: `SELECT path, cid, size, mtime_ms, computed_at FROM cid_cache WHERE path = ?`,
+			args: [path]
+		});
+		if (result.rows.length === 0) return null;
+		return toCidCacheRow(result.rows[0]);
+	}
+	/** Set (insert or replace) a CID cache entry. */
+	async setCidCache(row) {
+		await this.client.execute({
+			sql: `INSERT OR REPLACE INTO cid_cache (path, cid, size, mtime_ms, computed_at)
+            VALUES (?, ?, ?, ?, ?)`,
+			args: [
+				row.path,
+				row.cid,
+				row.size,
+				row.mtime_ms,
+				row.computed_at
+			]
+		});
+	}
+	/**
+	* Get the most recent active checkpoint for the given (direction, remoteUrl, basePath).
+	* Returns null when no active session exists.
+	*/
+	async getActiveCheckpoint(direction, remoteUrl, basePath) {
+		const result = await this.client.execute({
+			sql: `SELECT * FROM sync_checkpoint WHERE direction = ? AND remote_url = ? AND base_path = ? AND status = 'active' ORDER BY created_at DESC LIMIT 1`,
+			args: [
+				direction,
+				remoteUrl,
+				basePath
+			]
+		});
+		if (result.rows.length === 0) return null;
+		return toCheckpointRow(result.rows[0]);
+	}
+	/** Insert a new checkpoint record. */
+	async createCheckpoint(row) {
+		await this.client.execute({
+			sql: `INSERT INTO sync_checkpoint (session_id, direction, remote_url, base_path, status, diff_json, completed, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			args: [
+				row.session_id,
+				row.direction,
+				row.remote_url,
+				row.base_path,
+				row.status,
+				row.diff_json,
+				row.completed,
+				row.created_at,
+				row.updated_at
+			]
+		});
+	}
+	/** Update the completed paths list for an active checkpoint. */
+	async updateCheckpointCompleted(sessionId, completedPaths) {
+		await this.client.execute({
+			sql: `UPDATE sync_checkpoint SET completed = ?, updated_at = ? WHERE session_id = ?`,
+			args: [
+				JSON.stringify(completedPaths),
+				Date.now(),
+				sessionId
+			]
+		});
+	}
+	/** Mark a checkpoint as done. */
+	async completeCheckpoint(sessionId) {
+		await this.client.execute({
+			sql: `UPDATE sync_checkpoint SET status = 'done', updated_at = ? WHERE session_id = ?`,
+			args: [Date.now(), sessionId]
+		});
+	}
+	/** Get a checkpoint by session_id (for test assertions). */
+	async getCheckpoint(sessionId) {
+		const result = await this.client.execute({
+			sql: `SELECT * FROM sync_checkpoint WHERE session_id = ?`,
+			args: [sessionId]
+		});
+		if (result.rows.length === 0) return null;
+		return toCheckpointRow(result.rows[0]);
+	}
+	/** Close the database connection. */
+	close() {
+		this.client.close();
+	}
+};
+function toEntryRow(row) {
+	const r = row;
+	return {
+		scope: r.scope,
+		path: r.path,
+		parent: r.parent,
+		name: r.name,
+		kind: r.kind,
+		cid: r.cid,
+		size: r.size,
+		mime_type: r.mime_type,
+		ctime: r.ctime,
+		mtime: r.mtime
+	};
+}
+function toCidCacheRow(row) {
+	return {
+		path: row.path,
+		cid: row.cid,
+		size: row.size,
+		mtime_ms: row.mtime_ms,
+		computed_at: row.computed_at
+	};
+}
+function toCheckpointRow(row) {
+	const r = row;
+	return {
+		session_id: r.session_id,
+		direction: r.direction,
+		remote_url: r.remote_url,
+		base_path: r.base_path,
+		status: r.status,
+		diff_json: r.diff_json,
+		completed: r.completed,
+		created_at: r.created_at,
+		updated_at: r.updated_at
+	};
+}
+
+//#endregion
+export { MetadataDB };
+//# sourceMappingURL=metadata-db.mjs.map