nano-git 0.2.1 → 0.2.3

package/dist/workdir/sqlite-backend.mjs

@@ -0,0 +1,363 @@
+import { sha1 } from "../core/types.mjs";
+import { createRootDirectoryNode } from "./nodes.mjs";
+import { createVirtualWorkdirSessionId } from "./session-id.mjs";
+import { openVirtualWorkdirSession } from "./session.mjs";
+import { Database } from "bun:sqlite";
+//#region src/workdir/sqlite-backend.ts
+/**
+* Virtual Workdir SQLite backend
+*/
+const WORKDIR_SQLITE_SCHEMA_VERSION = 1;
+const WORKDIR_CHANGES_SESSION_ORDER_INDEX = "workdir_changes_session_id_id_idx";
+/**
+* 创建基于 SQLite 的 Virtual Workdir backend
+*
+* @example
+* ```ts
+* using backend = createSqliteVirtualWorkdirBackend(":memory:");
+* const sessionId = backend.createSession({ baseTree: tree });
+* const session = backend.openSession(repo.objects, sessionId);
+* expect(session.baseTree).toBe(tree);
+* ```
+*/
+function createSqliteVirtualWorkdirBackend(dbPath, options = {}) {
+	const db = new Database(dbPath);
+	let disposed = false;
+	if (options.walMode !== false) db.run("PRAGMA journal_mode = WAL");
+	ensureSchema(db);
+	return {
+		kind: "sqlite",
+		createSession(options) {
+			assertBackendAvailable(disposed);
+			const sessionId = createVirtualWorkdirSessionId();
+			createSqliteVirtualWorkdirStateStore(db, sessionId).reset(options.baseTree);
+			return sessionId;
+		},
+		openSession(source, sessionId) {
+			assertBackendAvailable(disposed);
+			if (!hasSession(db, sessionId)) throw new Error(`Virtual workdir session not found: ${sessionId}`);
+			validateSessionIntegrity(db, sessionId);
+			return openVirtualWorkdirSession(source, createSqliteVirtualWorkdirStateStore(db, sessionId));
+		},
+		deleteSession(sessionId) {
+			assertBackendAvailable(disposed);
+			if (!hasSession(db, sessionId)) throw new Error(`Virtual workdir session not found: ${sessionId}`);
+			deleteSessionRows(db, sessionId);
+		},
+		listSessions() {
+			assertBackendAvailable(disposed);
+			return db.query("SELECT session_id FROM workdir_sessions ORDER BY session_id").all().map((row) => row.session_id).filter((sessionId) => {
+				try {
+					validateSessionIntegrity(db, sessionId);
+					return true;
+				} catch {
+					return false;
+				}
+			});
+		},
+		[Symbol.dispose]() {
+			if (disposed) return;
+			disposed = true;
+			db.close();
+		}
+	};
+}
+function assertBackendAvailable(disposed) {
+	if (disposed) throw new Error("SQLite virtual workdir backend is disposed");
+}
+/**
+* 创建单个 session 的 SQLite 状态存储
+*
+* @example
+* ```ts
+* const store = createSqliteVirtualWorkdirStateStore(db, sessionId);
+* expect(store.kind).toBe("sqlite");
+* ```
+*/
+function createSqliteVirtualWorkdirStateStore(db, sessionId) {
+	const transactImpl = db.transaction((fn) => fn());
+	const readBaseTreeStmt = db.query("SELECT base_tree FROM workdir_sessions WHERE session_id = ?");
+	const upsertSessionStmt = db.query("INSERT INTO workdir_sessions (session_id, base_tree) VALUES (?, ?) ON CONFLICT(session_id) DO UPDATE SET base_tree = excluded.base_tree");
+	const getNodeStmt = db.query(`SELECT node_id, origin_kind, origin_hash, origin_mode, state_kind, state_mode, content, target, directory_overlay
+     FROM workdir_nodes
+     WHERE session_id = ? AND node_id = ?`);
+	const setNodeStmt = db.query(`INSERT INTO workdir_nodes (
+        session_id, node_id, origin_kind, origin_hash, origin_mode,
+        state_kind, state_mode, content, target, directory_overlay
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(session_id, node_id) DO UPDATE SET
+        origin_kind = excluded.origin_kind,
+        origin_hash = excluded.origin_hash,
+        origin_mode = excluded.origin_mode,
+        state_kind = excluded.state_kind,
+        state_mode = excluded.state_mode,
+        content = excluded.content,
+        target = excluded.target,
+        directory_overlay = excluded.directory_overlay`);
+	const deleteNodeStmt = db.query("DELETE FROM workdir_nodes WHERE session_id = ? AND node_id = ?");
+	const listChangesStmt = db.query("SELECT op, path, old_path FROM workdir_changes WHERE session_id = ? ORDER BY id");
+	const insertChangeStmt = db.query("INSERT INTO workdir_changes (session_id, op, path, old_path) VALUES (?, ?, ?, ?)");
+	const clearNodesStmt = db.query("DELETE FROM workdir_nodes WHERE session_id = ?");
+	const clearChangesStmt = db.query("DELETE FROM workdir_changes WHERE session_id = ?");
+	const resetTx = db.transaction((baseTree) => {
+		upsertSessionStmt.run(sessionId, baseTree);
+		clearNodesStmt.run(sessionId);
+		clearChangesStmt.run(sessionId);
+		writeNode(setNodeStmt, sessionId, createRootDirectoryNode(baseTree));
+	});
+	return {
+		kind: "sqlite",
+		transact(fn) {
+			return transactImpl(fn);
+		},
+		readBaseTree() {
+			const row = readBaseTreeStmt.get(sessionId);
+			if (row === null) throw new Error(`Virtual workdir session not found: ${sessionId}`);
+			return readBaseTreeValue(row.base_tree);
+		},
+		writeBaseTree(baseTree) {
+			upsertSessionStmt.run(sessionId, baseTree);
+		},
+		getNode(id) {
+			const row = getNodeStmt.get(sessionId, id);
+			if (row === null) return null;
+			return readNode(row);
+		},
+		setNode(node) {
+			writeNode(setNodeStmt, sessionId, node);
+		},
+		deleteNode(id) {
+			deleteNodeStmt.run(sessionId, id);
+		},
+		appendChange(record) {
+			insertChangeStmt.run(sessionId, record.op, getRecordPath(record), getRecordOldPath(record));
+		},
+		listChangeRecords() {
+			return listChangesStmt.all(sessionId).map(readChangeRecord);
+		},
+		clearChanges() {
+			clearChangesStmt.run(sessionId);
+		},
+		reset(baseTree) {
+			resetTx(baseTree);
+		}
+	};
+}
+function ensureSchema(db) {
+	const currentVersion = readSchemaVersion(db);
+	if (currentVersion !== 0 && currentVersion !== WORKDIR_SQLITE_SCHEMA_VERSION) throw new Error(`Unsupported virtual workdir SQLite schema version: expected ${WORKDIR_SQLITE_SCHEMA_VERSION}, got ${currentVersion}`);
+	db.run(`
+    CREATE TABLE IF NOT EXISTS workdir_sessions (
+      session_id TEXT PRIMARY KEY,
+      base_tree TEXT NOT NULL
+    )
+  `);
+	db.run(`
+    CREATE TABLE IF NOT EXISTS workdir_nodes (
+      session_id TEXT NOT NULL,
+      node_id TEXT NOT NULL,
+      origin_kind TEXT NOT NULL,
+      origin_hash TEXT,
+      origin_mode TEXT,
+      state_kind TEXT NOT NULL,
+      state_mode TEXT,
+      content BLOB,
+      target BLOB,
+      directory_overlay TEXT,
+      PRIMARY KEY (session_id, node_id)
+    )
+  `);
+	db.run(`
+    CREATE TABLE IF NOT EXISTS workdir_changes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      op TEXT NOT NULL,
+      path TEXT,
+      old_path TEXT
+    )
+  `);
+	db.run(`
+    CREATE INDEX IF NOT EXISTS ${WORKDIR_CHANGES_SESSION_ORDER_INDEX}
+    ON workdir_changes (session_id, id)
+  `);
+	writeSchemaVersion(db, WORKDIR_SQLITE_SCHEMA_VERSION);
+}
+function hasSession(db, sessionId) {
+	return db.query("SELECT 1 FROM workdir_sessions WHERE session_id = ?").get(sessionId) !== null;
+}
+function deleteSessionRows(db, sessionId) {
+	db.transaction(() => {
+		db.query("DELETE FROM workdir_changes WHERE session_id = ?").run(sessionId);
+		db.query("DELETE FROM workdir_nodes WHERE session_id = ?").run(sessionId);
+		db.query("DELETE FROM workdir_sessions WHERE session_id = ?").run(sessionId);
+	})();
+}
+function readSchemaVersion(db) {
+	return db.query("PRAGMA user_version").get()?.user_version ?? 0;
+}
+function writeSchemaVersion(db, version) {
+	db.run(`PRAGMA user_version = ${version}`);
+}
+function validateSessionIntegrity(db, sessionId) {
+	const sessionRow = db.query("SELECT base_tree FROM workdir_sessions WHERE session_id = ?").get(sessionId);
+	if (sessionRow === null) throw new Error(`Virtual workdir session not found: ${sessionId}`);
+	readBaseTreeValue(sessionRow.base_tree);
+	const rootRow = db.query(`SELECT node_id, origin_kind, origin_hash, origin_mode, state_kind, state_mode, content, target, directory_overlay
+     FROM workdir_nodes
+     WHERE session_id = ? AND node_id = ?`).get(sessionId, "root");
+	if (rootRow === null) throw new Error(`Virtual workdir session is corrupted: missing root node for ${sessionId}`);
+	if (readNode(rootRow).state.kind !== "directory") throw new Error(`Virtual workdir session is corrupted: root node is not a directory for ${sessionId}`);
+	const allNodesStmt = db.query(`SELECT node_id, origin_kind, origin_hash, origin_mode, state_kind, state_mode, content, target, directory_overlay
+     FROM workdir_nodes
+     WHERE session_id = ?`);
+	for (const row of allNodesStmt.all(sessionId)) readNode(row);
+}
+function writeNode(stmt, sessionId, node) {
+	if (node.state.kind === "directory") {
+		stmt.run(sessionId, node.id, node.origin.kind, node.origin.kind === "none" ? null : node.origin.hash, node.origin.kind === "repo-blob" ? node.origin.mode : null, "directory", null, null, null, JSON.stringify({
+			addedEntries: Array.from(node.state.overlay.addedEntries.entries()),
+			deletedNames: Array.from(node.state.overlay.deletedNames.values())
+		}));
+		return;
+	}
+	if (node.state.kind === "file") {
+		stmt.run(sessionId, node.id, node.origin.kind, node.origin.kind === "none" ? null : node.origin.hash, node.origin.kind === "repo-blob" ? node.origin.mode : null, "file", node.state.mode, node.state.content ?? null, null, null);
+		return;
+	}
+	stmt.run(sessionId, node.id, node.origin.kind, node.origin.kind === "none" ? null : node.origin.hash, node.origin.kind === "repo-blob" ? node.origin.mode : null, "symlink", "120000", null, node.state.target ?? null, null);
+}
+function readNode(row) {
+	const origin = readNodeOrigin(row);
+	if (row.state_kind === "directory") {
+		if (row.state_mode !== null || row.content !== null || row.target !== null) throw new Error("Invalid SQLite workdir directory node payload columns");
+		const overlay = readDirectoryOverlay(row.directory_overlay);
+		return {
+			id: row.node_id,
+			origin,
+			state: {
+				kind: "directory",
+				overlay
+			}
+		};
+	}
+	if (row.state_kind === "file") {
+		if (row.state_mode !== "100644" && row.state_mode !== "100755") throw new Error(`Invalid SQLite workdir node state mode: ${row.state_mode ?? "null"}`);
+		if (row.target !== null || row.directory_overlay !== null) throw new Error("Invalid SQLite workdir file node payload columns");
+		return {
+			id: row.node_id,
+			origin,
+			state: {
+				kind: "file",
+				mode: row.state_mode,
+				content: readBlobColumn(row.content, "content")
+			}
+		};
+	}
+	if (row.state_kind !== "symlink") throw new Error(`Invalid SQLite workdir node state kind: ${row.state_kind}`);
+	if (row.state_mode !== "120000") throw new Error(`Invalid SQLite workdir node state mode: ${row.state_mode ?? "null"}`);
+	if (row.content !== null || row.directory_overlay !== null) throw new Error("Invalid SQLite workdir symlink node payload columns");
+	return {
+		id: row.node_id,
+		origin,
+		state: {
+			kind: "symlink",
+			mode: "120000",
+			target: readBlobColumn(row.target, "target")
+		}
+	};
+}
+function readNodeOrigin(row) {
+	if (row.origin_kind === "none") return { kind: "none" };
+	if (row.origin_kind === "repo-tree") {
+		if (row.origin_hash === null) throw new Error("Invalid SQLite workdir node: repo-tree origin is missing hash");
+		return {
+			kind: "repo-tree",
+			hash: row.origin_hash
+		};
+	}
+	if (row.origin_kind === "repo-blob") {
+		if (row.origin_hash === null) throw new Error("Invalid SQLite workdir node: repo-blob origin is missing hash");
+		if (row.origin_mode !== "100644" && row.origin_mode !== "100755" && row.origin_mode !== "120000") throw new Error(`Invalid SQLite workdir node origin mode: ${row.origin_mode ?? "null"}`);
+		return {
+			kind: "repo-blob",
+			mode: row.origin_mode,
+			hash: row.origin_hash
+		};
+	}
+	throw new Error(`Invalid SQLite workdir node origin kind: ${row.origin_kind}`);
+}
+function readDirectoryOverlay(raw) {
+	if (raw === null) return {
+		addedEntries: /* @__PURE__ */ new Map(),
+		deletedNames: /* @__PURE__ */ new Set()
+	};
+	if (typeof raw !== "string") throw new Error("Invalid SQLite workdir directory overlay column type");
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (error) {
+		throw new Error(`Invalid SQLite workdir directory overlay JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!isDirectoryOverlayPayload(parsed)) throw new Error("Invalid SQLite workdir directory overlay payload");
+	const addedEntries = parsed.addedEntries.map(([name, nodeId]) => [name, nodeId]);
+	return {
+		addedEntries: new Map(addedEntries),
+		deletedNames: new Set(parsed.deletedNames)
+	};
+}
+function readBlobColumn(raw, column) {
+	if (raw === null) return;
+	if (!(raw instanceof Uint8Array)) throw new Error(`Invalid SQLite workdir ${column} column type`);
+	return Buffer.from(raw);
+}
+function readBaseTreeValue(raw) {
+	if (typeof raw !== "string") throw new Error("Invalid SQLite workdir session base_tree");
+	try {
+		return sha1(raw);
+	} catch {
+		throw new Error("Invalid SQLite workdir session base_tree");
+	}
+}
+function isDirectoryOverlayPayload(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const maybe = value;
+	if (!Array.isArray(maybe.addedEntries) || !Array.isArray(maybe.deletedNames)) return false;
+	const hasValidAddedEntries = maybe.addedEntries.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && typeof entry[1] === "string");
+	const hasValidDeletedNames = maybe.deletedNames.every((name) => typeof name === "string");
+	return hasValidAddedEntries && hasValidDeletedNames;
+}
+function getRecordPath(record) {
+	switch (record.op) {
+		case "add":
+		case "modify":
+		case "delete":
+		case "revert": return record.path;
+		case "rename":
+		case "copy": return record.to;
+		default: return record;
+	}
+}
+function getRecordOldPath(record) {
+	if (record.op === "rename" || record.op === "copy") return record.from;
+	return null;
+}
+function readChangeRecord(row) {
+	switch (row.op) {
+		case "add":
+		case "modify":
+		case "delete":
+		case "revert": return {
+			op: row.op,
+			path: row.path
+		};
+		case "rename":
+		case "copy": return {
+			op: row.op,
+			from: row.old_path,
+			to: row.path
+		};
+		default: throw new Error(`Unknown workdir change op: ${row.op}`);
+	}
+}
+//#endregion
+export { createSqliteVirtualWorkdirBackend };

package/dist/workdir/sqlite.d.mts

@@ -0,0 +1,2 @@
+import { CreateSqliteVirtualWorkdirBackendOptions, SqliteVirtualWorkdirBackend, createSqliteVirtualWorkdirBackend } from "./sqlite-backend.mjs";
+export { type CreateSqliteVirtualWorkdirBackendOptions, type SqliteVirtualWorkdirBackend, createSqliteVirtualWorkdirBackend };

package/dist/workdir/sqlite.mjs

@@ -0,0 +1,2 @@
+import { createSqliteVirtualWorkdirBackend } from "./sqlite-backend.mjs";
+export { createSqliteVirtualWorkdirBackend };

package/dist/workdir/state-store.d.mts

@@ -0,0 +1,44 @@
+import { SHA1 } from "../core/types.mjs";
+import { InternalChangeRecord } from "./change-log.mjs";
+import { NodeId } from "./ids.mjs";
+import { SessionNode } from "./nodes.mjs";
+
+//#region src/workdir/state-store.d.ts
+/**
+ * Virtual Workdir 内部状态存储接口
+ */
+interface VirtualWorkdirStateStore {
+  /** 后端类型 */
+  readonly kind: "memory" | "file" | "sqlite";
+  /**
+   * 在单次提交边界内执行状态变更
+   *
+   * 用于把一次 session 写操作封装为单个内部事务。
+   * 若回调抛错，store 应尽力恢复到调用前状态。
+   */
+  transact<T>(fn: () => T): T;
+  /** 读取当前基线 tree */
+  readBaseTree(): SHA1;
+  /** 覆盖当前基线 tree */
+  writeBaseTree(baseTree: SHA1): void;
+  /** 读取节点，不存在时返回 null */
+  getNode(id: NodeId): SessionNode | null;
+  /** 写入或覆盖节点 */
+  setNode(node: SessionNode): void;
+  /** 删除节点 */
+  deleteNode(id: NodeId): void;
+  /** 追加内部变更记录 */
+  appendChange(record: InternalChangeRecord): void;
+  /** 列出内部变更记录快照 */
+  listChangeRecords(): readonly InternalChangeRecord[];
+  /** 清空变更记录 */
+  clearChanges(): void;
+  /**
+   * 重置为新的基线 tree
+   *
+   * 需要同时清空节点状态与变更记录，并重新建立根节点。
+   */
+  reset(baseTree: SHA1): void;
+}
+//#endregion
+export { VirtualWorkdirStateStore };

package/dist/workdir/write-tree.mjs

@@ -26,8 +26,8 @@ import { listDirectoryChildren } from "./session-internal.mjs";
 * ```
 */
 function writeTreeFromSession(source, state) {
-	const root = state.nodes.get("root");
-	if (!root || root.state.kind !== "directory") throw new Error("Virtual workdir: root node is missing or not a directory");
+	const root = state.getNode("root");
+	if (root === null || root.state.kind !== "directory") throw new Error("Virtual workdir: root node is missing or not a directory");
 	return compileDirectory(source, source, state, root);
 }
 /**
@@ -41,8 +41,8 @@ function compileDirectory(writeSource, readSource, state, dirNode) {
 	let anyChanged = false;
 	const newEntries = [];
 	for (const child of children) {
-		const node = state.nodes.get(child.nodeId);
-		if (!node) continue;
+		const node = state.getNode(child.nodeId);
+		if (node === null) continue;
 		if (node.state.kind === "directory") {
 			const newHash = compileDirectory(writeSource, readSource, state, node);
 			if (newHash !== (node.origin.kind === "repo-tree" ? node.origin.hash : null)) anyChanged = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nano-git",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "files": [
     "dist"
   ],
@@ -43,47 +43,168 @@
     "./transport/server/upload-pack": "./src/transport/server/upload-pack/index.ts",
     "./transport/upload-pack": "./src/transport/upload-pack.ts",
     "./workdir/core": "./src/workdir/core.ts",
-    "./workdir/memory": "./src/workdir/memory.ts"
+    "./workdir/file": "./src/workdir/file.ts",
+    "./workdir/memory": "./src/workdir/memory.ts",
+    "./workdir/sqlite": "./src/workdir/sqlite.ts"
   },
   "publishConfig": {
     "exports": {
-      ".": "./dist/index.mjs",
-      "./backend": "./dist/backend/index.mjs",
-      "./backend/file": "./dist/backend/file.mjs",
-      "./backend/memory": "./dist/backend/memory.mjs",
-      "./backend/sqlite": "./dist/backend/sqlite.mjs",
-      "./errors": "./dist/errors.mjs",
-      "./hash-file": "./dist/hash-file.mjs",
-      "./log": "./dist/log/index.mjs",
-      "./objects": "./dist/objects/index.mjs",
-      "./odb/file": "./dist/odb/file.mjs",
-      "./odb/memory": "./dist/odb/memory.mjs",
-      "./odb/sqlite": "./dist/odb/sqlite.mjs",
-      "./pack": "./dist/pack/index.mjs",
-      "./refs/file": "./dist/refs/file.mjs",
-      "./refs/memory": "./dist/refs/memory.mjs",
-      "./refs/names": "./dist/refs/names.mjs",
-      "./refs/resolve": "./dist/refs/resolve.mjs",
-      "./refs/shallow/file": "./dist/refs/shallow/file.mjs",
-      "./refs/shallow/memory": "./dist/refs/shallow/memory.mjs",
-      "./refs/shallow/sqlite": "./dist/refs/shallow/sqlite.mjs",
-      "./refs/sqlite": "./dist/refs/sqlite.mjs",
-      "./remote/http": "./dist/remote/http.mjs",
-      "./repository/core": "./dist/repository/core.mjs",
-      "./repository/file": "./dist/repository/file.mjs",
-      "./repository/memory": "./dist/repository/memory.mjs",
-      "./repository/sqlite": "./dist/repository/sqlite.mjs",
-      "./repository/tree/tree-patch": "./dist/repository/tree/tree-patch.mjs",
-      "./repository/tree/tree-walk": "./dist/repository/tree/tree-walk.mjs",
-      "./sha1": "./dist/sha1.mjs",
-      "./transport": "./dist/transport/index.mjs",
-      "./transport/http": "./dist/transport/http/index.mjs",
-      "./transport/receive-pack": "./dist/transport/receive-pack.mjs",
-      "./transport/server/receive-pack": "./dist/transport/server/receive-pack/index.mjs",
-      "./transport/server/upload-pack": "./dist/transport/server/upload-pack/index.mjs",
-      "./transport/upload-pack": "./dist/transport/upload-pack.mjs",
-      "./workdir/core": "./dist/workdir/core.mjs",
-      "./workdir/memory": "./dist/workdir/memory.mjs"
+      ".": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "./backend": {
+        "types": "./dist/backend/index.d.mts",
+        "default": "./dist/backend/index.mjs"
+      },
+      "./backend/file": {
+        "types": "./dist/backend/file.d.mts",
+        "default": "./dist/backend/file.mjs"
+      },
+      "./backend/memory": {
+        "types": "./dist/backend/memory.d.mts",
+        "default": "./dist/backend/memory.mjs"
+      },
+      "./backend/sqlite": {
+        "types": "./dist/backend/sqlite.d.mts",
+        "default": "./dist/backend/sqlite.mjs"
+      },
+      "./errors": {
+        "types": "./dist/errors.d.mts",
+        "default": "./dist/errors.mjs"
+      },
+      "./hash-file": {
+        "types": "./dist/hash-file.d.mts",
+        "default": "./dist/hash-file.mjs"
+      },
+      "./log": {
+        "types": "./dist/log/index.d.mts",
+        "default": "./dist/log/index.mjs"
+      },
+      "./objects": {
+        "types": "./dist/objects/index.d.mts",
+        "default": "./dist/objects/index.mjs"
+      },
+      "./odb/file": {
+        "types": "./dist/odb/file.d.mts",
+        "default": "./dist/odb/file.mjs"
+      },
+      "./odb/memory": {
+        "types": "./dist/odb/memory.d.mts",
+        "default": "./dist/odb/memory.mjs"
+      },
+      "./odb/sqlite": {
+        "types": "./dist/odb/sqlite.d.mts",
+        "default": "./dist/odb/sqlite.mjs"
+      },
+      "./pack": {
+        "types": "./dist/pack/index.d.mts",
+        "default": "./dist/pack/index.mjs"
+      },
+      "./refs/file": {
+        "types": "./dist/refs/file.d.mts",
+        "default": "./dist/refs/file.mjs"
+      },
+      "./refs/memory": {
+        "types": "./dist/refs/memory.d.mts",
+        "default": "./dist/refs/memory.mjs"
+      },
+      "./refs/names": {
+        "types": "./dist/refs/names.d.mts",
+        "default": "./dist/refs/names.mjs"
+      },
+      "./refs/resolve": {
+        "types": "./dist/refs/resolve.d.mts",
+        "default": "./dist/refs/resolve.mjs"
+      },
+      "./refs/shallow/file": {
+        "types": "./dist/refs/shallow/file.d.mts",
+        "default": "./dist/refs/shallow/file.mjs"
+      },
+      "./refs/shallow/memory": {
+        "types": "./dist/refs/shallow/memory.d.mts",
+        "default": "./dist/refs/shallow/memory.mjs"
+      },
+      "./refs/shallow/sqlite": {
+        "types": "./dist/refs/shallow/sqlite.d.mts",
+        "default": "./dist/refs/shallow/sqlite.mjs"
+      },
+      "./refs/sqlite": {
+        "types": "./dist/refs/sqlite.d.mts",
+        "default": "./dist/refs/sqlite.mjs"
+      },
+      "./remote/http": {
+        "types": "./dist/remote/http.d.mts",
+        "default": "./dist/remote/http.mjs"
+      },
+      "./repository/core": {
+        "types": "./dist/repository/core.d.mts",
+        "default": "./dist/repository/core.mjs"
+      },
+      "./repository/file": {
+        "types": "./dist/repository/file.d.mts",
+        "default": "./dist/repository/file.mjs"
+      },
+      "./repository/memory": {
+        "types": "./dist/repository/memory.d.mts",
+        "default": "./dist/repository/memory.mjs"
+      },
+      "./repository/sqlite": {
+        "types": "./dist/repository/sqlite.d.mts",
+        "default": "./dist/repository/sqlite.mjs"
+      },
+      "./repository/tree/tree-patch": {
+        "types": "./dist/repository/tree/tree-patch.d.mts",
+        "default": "./dist/repository/tree/tree-patch.mjs"
+      },
+      "./repository/tree/tree-walk": {
+        "types": "./dist/repository/tree/tree-walk.d.mts",
+        "default": "./dist/repository/tree/tree-walk.mjs"
+      },
+      "./sha1": {
+        "types": "./dist/sha1.d.mts",
+        "default": "./dist/sha1.mjs"
+      },
+      "./transport": {
+        "types": "./dist/transport/index.d.mts",
+        "default": "./dist/transport/index.mjs"
+      },
+      "./transport/http": {
+        "types": "./dist/transport/http/index.d.mts",
+        "default": "./dist/transport/http/index.mjs"
+      },
+      "./transport/receive-pack": {
+        "types": "./dist/transport/receive-pack.d.mts",
+        "default": "./dist/transport/receive-pack.mjs"
+      },
+      "./transport/server/receive-pack": {
+        "types": "./dist/transport/server/receive-pack/index.d.mts",
+        "default": "./dist/transport/server/receive-pack/index.mjs"
+      },
+      "./transport/server/upload-pack": {
+        "types": "./dist/transport/server/upload-pack/index.d.mts",
+        "default": "./dist/transport/server/upload-pack/index.mjs"
+      },
+      "./transport/upload-pack": {
+        "types": "./dist/transport/upload-pack.d.mts",
+        "default": "./dist/transport/upload-pack.mjs"
+      },
+      "./workdir/core": {
+        "types": "./dist/workdir/core.d.mts",
+        "default": "./dist/workdir/core.mjs"
+      },
+      "./workdir/file": {
+        "types": "./dist/workdir/file.d.mts",
+        "default": "./dist/workdir/file.mjs"
+      },
+      "./workdir/memory": {
+        "types": "./dist/workdir/memory.d.mts",
+        "default": "./dist/workdir/memory.mjs"
+      },
+      "./workdir/sqlite": {
+        "types": "./dist/workdir/sqlite.d.mts",
+        "default": "./dist/workdir/sqlite.mjs"
+      }
     }
   },
   "scripts": {