nano-git 0.2.0 → 0.2.2

package/dist/workdir/session-internal.mjs

@@ -0,0 +1,141 @@
+import { VirtualNotDirectoryError } from "../core/errors.mjs";
+import { VIRTUAL_ROOT_NODE_ID, originBackedNodeId } from "./ids.mjs";
+import { mergeDirectoryChildren } from "./overlay.mjs";
+import { readRepoTree, treeEntryToNodeOrigin } from "./origin.mjs";
+import { assertValidVirtualPath, joinPath, splitPathSegments } from "./path.mjs";
+//#region src/workdir/session-internal.ts
+/**
+* Virtual Workdir session 内部共享逻辑
+*
+* 供 session.ts 与 write-tree.ts 复用：
+* - 路径解析（resolvePath）
+* - 目录子项展开（listDirectoryChildren）
+* - origin 节点懒注册（ensureNodeFromTreeEntry）
+*/
+function getRootNode(state) {
+	const root = state.getNode(VIRTUAL_ROOT_NODE_ID);
+	if (root === null) throw new Error("Virtual workdir session is missing root node");
+	return root;
+}
+/**
+* 从根目录沿路径分段解析到目标节点
+*/
+function resolvePath(source, state, path) {
+	assertValidVirtualPath(path);
+	const segments = splitPathSegments(path);
+	let current = getRootNode(state);
+	let currentPath = "";
+	for (const segment of segments) {
+		if (current.state.kind !== "directory") return {
+			found: false,
+			node: null
+		};
+		const child = listDirectoryChildren(source, state, current, currentPath).find((c) => c.name === segment);
+		if (child === void 0) return {
+			found: false,
+			node: null
+		};
+		currentPath = joinPath(currentPath === "" ? null : currentPath, segment);
+		const childNode = state.getNode(child.nodeId);
+		if (childNode === null) return {
+			found: false,
+			node: null
+		};
+		current = childNode;
+	}
+	return {
+		found: true,
+		node: current
+	};
+}
+/**
+* 根据父节点与子条目名解析子节点
+*/
+function resolveChild(source, state, parentNode, parentPath, name) {
+	if (parentNode.state.kind !== "directory") return {
+		found: false,
+		node: null
+	};
+	const child = listDirectoryChildren(source, state, parentNode, parentPath).find((c) => c.name === name);
+	if (child === void 0) return {
+		found: false,
+		node: null
+	};
+	const childNode = state.getNode(child.nodeId);
+	if (childNode === null) return {
+		found: false,
+		node: null
+	};
+	return {
+		found: true,
+		node: childNode
+	};
+}
+/**
+* 确保 origin 条目对应的 session 节点已懒注册
+*/
+function ensureNodeFromTreeEntry(state, entry) {
+	const id = originBackedNodeId(entry.hash);
+	if (state.getNode(id) === null) {
+		const origin = treeEntryToNodeOrigin(entry);
+		let nodeState;
+		if (entry.mode === "40000") nodeState = {
+			kind: "directory",
+			overlay: {
+				addedEntries: /* @__PURE__ */ new Map(),
+				deletedNames: /* @__PURE__ */ new Set()
+			}
+		};
+		else if (entry.mode === "120000") nodeState = {
+			kind: "symlink",
+			mode: "120000"
+		};
+		else nodeState = {
+			kind: "file",
+			mode: entry.mode === "100755" ? "100755" : "100644"
+		};
+		state.setNode({
+			id,
+			origin,
+			state: nodeState
+		});
+	}
+	return id;
+}
+/**
+* 展开目录的完整子项列表（origin + overlay 合成）
+*/
+function listDirectoryChildren(source, state, dirNode, dirPath) {
+	if (dirNode.state.kind !== "directory") throw new VirtualNotDirectoryError(dirPath);
+	let originChildren = [];
+	if (dirNode.origin.kind === "repo-tree") originChildren = readRepoTree(source, dirNode.origin.hash, dirPath).entries.map((entry) => {
+		const childNodeId = ensureNodeFromTreeEntry(state, entry);
+		return {
+			name: entry.name,
+			mode: entry.mode,
+			nodeId: childNodeId
+		};
+	});
+	const addedModes = buildAddedModes(state, dirNode);
+	return mergeDirectoryChildren(originChildren, dirNode.state.overlay, addedModes);
+}
+/**
+* 构建 overlay addedEntries 对应的 mode map
+*/
+function buildAddedModes(state, dirNode) {
+	if (dirNode.state.kind !== "directory") return /* @__PURE__ */ new Map();
+	const addedModes = /* @__PURE__ */ new Map();
+	for (const name of dirNode.state.overlay.addedEntries.keys()) {
+		const nodeId = dirNode.state.overlay.addedEntries.get(name);
+		const node = state.getNode(nodeId);
+		if (node !== null) addedModes.set(name, sessionNodeMode(node));
+	}
+	return addedModes;
+}
+function sessionNodeMode(node) {
+	if (node.state.kind === "directory") return "40000";
+	if (node.state.kind === "symlink") return "120000";
+	return node.state.mode;
+}
+//#endregion
+export { listDirectoryChildren, resolveChild, resolvePath };

package/dist/workdir/session.d.mts

@@ -0,0 +1,30 @@
+import { ObjectDatabase } from "../core/types/odb.mjs";
+import { CreateVirtualWorkdirSessionOptions, VirtualWorkdirSession } from "./core.mjs";
+import { VirtualWorkdirStateStore } from "./state-store.mjs";
+
+//#region src/workdir/session.d.ts
+/**
+ * 基于 ObjectDatabase 创建 VirtualWorkdirSession
+ *
+ * @example
+ * ```ts
+ * const repo = createMemoryRepository();
+ * const tree = repo.createTree([]);
+ * const session = createVirtualWorkdirSession(repo.objects, { baseTree: tree });
+ * expect(session.readdir()).toEqual([]);
+ * ```
+ */
+declare function createVirtualWorkdirSession(source: ObjectDatabase, options: CreateVirtualWorkdirSessionOptions): VirtualWorkdirSession;
+/**
+ * 基于已有状态存储打开 session
+ *
+ * @example
+ * ```ts
+ * const store = createVirtualWorkdirMemoryStateStore(tree);
+ * const session = openVirtualWorkdirSession(repo.objects, store);
+ * expect(session.baseTree).toBe(tree);
+ * ```
+ */
+declare function openVirtualWorkdirSession(source: ObjectDatabase, state: VirtualWorkdirStateStore): VirtualWorkdirSession;
+//#endregion
+export { createVirtualWorkdirSession, openVirtualWorkdirSession };

package/dist/workdir/session.mjs

@@ -0,0 +1,407 @@
+import { VirtualNotDirectoryError, VirtualNotFileError, VirtualNotSymlinkError, VirtualPathAlreadyExistsError, VirtualPathNotFoundError, VirtualRevertNotSupportedError } from "../core/errors.mjs";
+import { mapInternalChangesToVirtualChanges } from "./change-log.mjs";
+import { VIRTUAL_ROOT_NODE_ID, createNodeId } from "./ids.mjs";
+import { overlayBindEntry, overlayRenameEntry, overlayTombstoneEntry } from "./overlay.mjs";
+import { cloneSessionNodeForCopy, revertNodeState } from "./nodes.mjs";
+import { modeToVirtualEntryKind, readRepoBlobContent } from "./origin.mjs";
+import { assertValidVirtualPath, baseName, normalizeDirectoryPath, parentPath } from "./path.mjs";
+import { listDirectoryChildren, resolveChild, resolvePath } from "./session-internal.mjs";
+import { writeTreeFromSession } from "./write-tree.mjs";
+import { createVirtualWorkdirMemoryStateStore } from "./memory-backend.mjs";
+//#region src/workdir/session.ts
+/**
+* VirtualWorkdirSession 行为编排
+*
+* Phase 5：完整文件/目录 rename 与 copy 语义。
+*/
+/**
+* 基于 ObjectDatabase 创建 VirtualWorkdirSession
+*
+* @example
+* ```ts
+* const repo = createMemoryRepository();
+* const tree = repo.createTree([]);
+* const session = createVirtualWorkdirSession(repo.objects, { baseTree: tree });
+* expect(session.readdir()).toEqual([]);
+* ```
+*/
+function createVirtualWorkdirSession(source, options) {
+	return openVirtualWorkdirSession(source, createVirtualWorkdirMemoryStateStore(options.baseTree));
+}
+/**
+* 基于已有状态存储打开 session
+*
+* @example
+* ```ts
+* const store = createVirtualWorkdirMemoryStateStore(tree);
+* const session = openVirtualWorkdirSession(repo.objects, store);
+* expect(session.baseTree).toBe(tree);
+* ```
+*/
+function openVirtualWorkdirSession(source, state) {
+	return {
+		get baseTree() {
+			return state.readBaseTree();
+		},
+		exists(path) {
+			if (path === "") return true;
+			return resolvePath(source, state, path).found;
+		},
+		stat(path) {
+			if (path === "") return statDirectoryNode(getRootNode(state));
+			const resolved = resolvePath(source, state, path);
+			if (!resolved.found || resolved.node === null) return null;
+			return statNode(source, resolved.node, path);
+		},
+		readdir(dirPath) {
+			const normalized = normalizeDirectoryPath(dirPath);
+			const resolved = normalized === "" ? {
+				found: true,
+				node: getRootNode(state)
+			} : resolvePath(source, state, normalized);
+			if (!resolved.found || resolved.node === null) throw new VirtualPathNotFoundError(normalized);
+			if (resolved.node.state.kind !== "directory") throw new VirtualNotDirectoryError(normalized);
+			return listDirectoryChildren(source, state, resolved.node, normalized).map((child) => ({
+				name: child.name,
+				kind: modeToVirtualEntryKind(child.mode),
+				mode: child.mode
+			}));
+		},
+		readFile(path) {
+			assertValidVirtualPath(path);
+			const resolved = resolvePath(source, state, path);
+			if (!resolved.found || resolved.node === null) throw new VirtualPathNotFoundError(path);
+			const node = resolved.node;
+			if (node.state.kind === "file") {
+				if (node.state.content !== void 0) return node.state.content;
+				if (node.origin.kind === "repo-blob") return readRepoBlobContent(source, node.origin.hash, path);
+				throw new VirtualPathNotFoundError(path);
+			}
+			if (node.state.kind === "symlink") throw new VirtualNotFileError(path);
+			throw new VirtualNotFileError(path);
+		},
+		readLink(path) {
+			assertValidVirtualPath(path);
+			const resolved = resolvePath(source, state, path);
+			if (!resolved.found || resolved.node === null) throw new VirtualPathNotFoundError(path);
+			const node = resolved.node;
+			if (node.state.kind !== "symlink") throw new VirtualNotSymlinkError(path);
+			if (node.state.target !== void 0) return node.state.target.toString("utf-8");
+			if (node.origin.kind === "repo-blob") return readRepoBlobContent(source, node.origin.hash, path).toString("utf-8");
+			throw new VirtualPathNotFoundError(path);
+		},
+		mkdir(path) {
+			runInWriteTransaction(state, () => {
+				assertValidVirtualPath(path);
+				const parent = parentPath(path);
+				const name = baseName(path);
+				const parentResolved = parent !== null ? resolvePath(source, state, parent) : {
+					found: true,
+					node: getRootNode(state)
+				};
+				if (!parentResolved.found || parentResolved.node === null) throw new VirtualPathNotFoundError(parent ?? path);
+				const parentNode = parentResolved.node;
+				if (parentNode.state.kind !== "directory") throw new VirtualNotDirectoryError(parent ?? path);
+				const existing = resolveChild(source, state, parentNode, parent ?? "", name);
+				if (existing.found && existing.node !== null) throw new VirtualPathAlreadyExistsError(path);
+				const nodeId = createNodeId();
+				const newNode = {
+					id: nodeId,
+					origin: { kind: "none" },
+					state: {
+						kind: "directory",
+						overlay: {
+							addedEntries: /* @__PURE__ */ new Map(),
+							deletedNames: /* @__PURE__ */ new Set()
+						}
+					}
+				};
+				state.setNode(newNode);
+				updateParentOverlay(state, parentNode.id, overlayBindEntry(parentNode.state.overlay, name, nodeId));
+				state.appendChange({
+					op: "add",
+					path
+				});
+			});
+		},
+		writeFile(path, content, options) {
+			runInWriteTransaction(state, () => {
+				assertValidVirtualPath(path);
+				const mode = options?.mode ?? "100644";
+				const parent = parentPath(path);
+				const name = baseName(path);
+				const parentResolved = parent !== null ? resolvePath(source, state, parent) : {
+					found: true,
+					node: getRootNode(state)
+				};
+				if (!parentResolved.found || parentResolved.node === null) throw new VirtualPathNotFoundError(parent ?? path);
+				const parentNode = parentResolved.node;
+				if (parentNode.state.kind !== "directory") throw new VirtualNotDirectoryError(parent ?? path);
+				const existing = resolveChild(source, state, parentNode, parent ?? "", name);
+				if (existing.found && existing.node !== null) {
+					if (existing.node.state.kind === "directory") throw new VirtualNotFileError(path);
+				}
+				const isNew = !existing.found || existing.node === null;
+				const nodeId = existing.found ? existing.node.id : createNodeId();
+				const fileNode = {
+					id: nodeId,
+					origin: existing.found ? existing.node.origin : { kind: "none" },
+					state: {
+						kind: "file",
+						mode,
+						content
+					}
+				};
+				state.setNode(fileNode);
+				updateParentOverlay(state, parentNode.id, overlayBindEntry(parentNode.state.overlay, name, nodeId));
+				state.appendChange({
+					op: isNew ? "add" : "modify",
+					path
+				});
+			});
+		},
+		writeLink(path, target) {
+			runInWriteTransaction(state, () => {
+				assertValidVirtualPath(path);
+				const parent = parentPath(path);
+				const name = baseName(path);
+				const parentResolved = parent !== null ? resolvePath(source, state, parent) : {
+					found: true,
+					node: getRootNode(state)
+				};
+				if (!parentResolved.found || parentResolved.node === null) throw new VirtualPathNotFoundError(parent ?? path);
+				const parentNode = parentResolved.node;
+				if (parentNode.state.kind !== "directory") throw new VirtualNotDirectoryError(parent ?? path);
+				const existing = resolveChild(source, state, parentNode, parent ?? "", name);
+				if (existing.found && existing.node !== null) {
+					if (existing.node.state.kind === "directory") throw new VirtualNotFileError(path);
+				}
+				const isNew = !existing.found || existing.node === null;
+				const nodeId = existing.found ? existing.node.id : createNodeId();
+				const linkNode = {
+					id: nodeId,
+					origin: existing.found ? existing.node.origin : { kind: "none" },
+					state: {
+						kind: "symlink",
+						mode: "120000",
+						target: Buffer.from(target)
+					}
+				};
+				state.setNode(linkNode);
+				updateParentOverlay(state, parentNode.id, overlayBindEntry(parentNode.state.overlay, name, nodeId));
+				state.appendChange({
+					op: isNew ? "add" : "modify",
+					path
+				});
+			});
+		},
+		delete(path) {
+			runInWriteTransaction(state, () => {
+				assertValidVirtualPath(path);
+				const parent = parentPath(path);
+				const name = baseName(path);
+				const parentResolved = parent !== null ? resolvePath(source, state, parent) : {
+					found: true,
+					node: getRootNode(state)
+				};
+				if (!parentResolved.found || parentResolved.node === null) throw new VirtualPathNotFoundError(parent ?? path);
+				const parentNode = parentResolved.node;
+				if (parentNode.state.kind !== "directory") throw new VirtualNotDirectoryError(parent ?? path);
+				const existing = resolveChild(source, state, parentNode, parent ?? "", name);
+				if (!existing.found || existing.node === null) throw new VirtualPathNotFoundError(path);
+				updateParentOverlay(state, parentNode.id, overlayTombstoneEntry(parentNode.state.overlay, name));
+				state.appendChange({
+					op: "delete",
+					path
+				});
+			});
+		},
+		rename(from, to) {
+			runInWriteTransaction(state, () => {
+				assertValidVirtualPath(from);
+				assertValidVirtualPath(to);
+				if (from === to) return;
+				const fromParent = parentPath(from);
+				const fromName = baseName(from);
+				const fromParentResolved = fromParent !== null ? resolvePath(source, state, fromParent) : {
+					found: true,
+					node: getRootNode(state)
+				};
+				if (!fromParentResolved.found || fromParentResolved.node === null) throw new VirtualPathNotFoundError(from);
+				const fromParentNode = fromParentResolved.node;
+				if (fromParentNode.state.kind !== "directory") throw new VirtualNotDirectoryError(from);
+				const fromChild = resolveChild(source, state, fromParentNode, fromParent ?? "", fromName);
+				if (!fromChild.found || fromChild.node === null) throw new VirtualPathNotFoundError(from);
+				const sourceNode = fromChild.node;
+				const toParent = parentPath(to);
+				const toName = baseName(to);
+				const toParentResolved = toParent !== null ? resolvePath(source, state, toParent) : {
+					found: true,
+					node: getRootNode(state)
+				};
+				if (!toParentResolved.found || toParentResolved.node === null) throw new VirtualPathNotFoundError(to);
+				const toParentNode = toParentResolved.node;
+				if (toParentNode.state.kind !== "directory") throw new VirtualNotDirectoryError(to);
+				const toExisting = resolveChild(source, state, toParentNode, toParent ?? "", toName);
+				if (toExisting.found && toExisting.node !== null) throw new VirtualPathAlreadyExistsError(to);
+				if (sourceNode.state.kind === "directory") {
+					const toPath = to;
+					const fromPath = from;
+					if (toPath.startsWith(fromPath + "/") || toPath === fromPath) throw new Error(`Cannot rename '${from}' to '${to}': destination is a subdirectory of source`);
+				}
+				if (fromParentNode.id === toParentNode.id) updateParentOverlay(state, fromParentNode.id, overlayRenameEntry(fromParentNode.state.overlay, fromName, toName, sourceNode.id));
+				else {
+					updateParentOverlay(state, fromParentNode.id, overlayTombstoneEntry(fromParentNode.state.overlay, fromName));
+					updateParentOverlay(state, toParentNode.id, overlayBindEntry(toParentNode.state.overlay, toName, sourceNode.id));
+				}
+				state.appendChange({
+					op: "rename",
+					from,
+					to
+				});
+			});
+		},
+		copy(from, to) {
+			runInWriteTransaction(state, () => {
+				assertValidVirtualPath(from);
+				assertValidVirtualPath(to);
+				if (from === to) throw new VirtualPathAlreadyExistsError(to);
+				const fromParent = parentPath(from);
+				const fromName = baseName(from);
+				const fromParentResolved = fromParent !== null ? resolvePath(source, state, fromParent) : {
+					found: true,
+					node: getRootNode(state)
+				};
+				if (!fromParentResolved.found || fromParentResolved.node === null) throw new VirtualPathNotFoundError(from);
+				const fromParentNode = fromParentResolved.node;
+				if (fromParentNode.state.kind !== "directory") throw new VirtualNotDirectoryError(from);
+				const fromChild = resolveChild(source, state, fromParentNode, fromParent ?? "", fromName);
+				if (!fromChild.found || fromChild.node === null) throw new VirtualPathNotFoundError(from);
+				const sourceNode = fromChild.node;
+				const toParent = parentPath(to);
+				const toName = baseName(to);
+				const toParentResolved = toParent !== null ? resolvePath(source, state, toParent) : {
+					found: true,
+					node: getRootNode(state)
+				};
+				if (!toParentResolved.found || toParentResolved.node === null) throw new VirtualPathNotFoundError(to);
+				const toParentNode = toParentResolved.node;
+				if (toParentNode.state.kind !== "directory") throw new VirtualNotDirectoryError(to);
+				const toExisting = resolveChild(source, state, toParentNode, toParent ?? "", toName);
+				if (toExisting.found && toExisting.node !== null) throw new VirtualPathAlreadyExistsError(to);
+				const newNodeId = cloneNodeGraphForCopy(source, state, sourceNode, from);
+				updateParentOverlay(state, toParentNode.id, overlayBindEntry(toParentNode.state.overlay, toName, newNodeId));
+				state.appendChange({
+					op: "copy",
+					from,
+					to
+				});
+			});
+		},
+		revert(path) {
+			runInWriteTransaction(state, () => {
+				assertValidVirtualPath(path);
+				const resolved = resolvePath(source, state, path);
+				if (!resolved.found || resolved.node === null) throw new VirtualPathNotFoundError(path);
+				const node = resolved.node;
+				const reverted = revertNodeState(node);
+				if (reverted === node) throw new VirtualRevertNotSupportedError(path);
+				state.setNode(reverted);
+				state.appendChange({
+					op: "revert",
+					path
+				});
+			});
+		},
+		writeTree() {
+			return writeTreeFromSession(source, state);
+		},
+		reset(baseTree) {
+			runInWriteTransaction(state, () => {
+				state.reset(baseTree);
+			});
+		},
+		listChanges() {
+			return mapInternalChangesToVirtualChanges(state.listChangeRecords());
+		}
+	};
+}
+function getRootNode(state) {
+	const root = state.getNode(VIRTUAL_ROOT_NODE_ID);
+	if (root === null) throw new Error("Virtual workdir session is missing root node");
+	return root;
+}
+function runInWriteTransaction(state, fn) {
+	return state.transact(fn);
+}
+/**
+* 更新父节点的 overlay（创建新节点对象替代 Map 中的旧引用）
+*/
+function updateParentOverlay(state, parentId, newOverlay) {
+	const parentNode = state.getNode(parentId);
+	if (parentNode === null || parentNode.state.kind !== "directory") throw new Error("updateParentOverlay: parent is not a directory");
+	state.setNode({
+		...parentNode,
+		state: {
+			...parentNode.state,
+			overlay: newOverlay
+		}
+	});
+}
+function statNode(source, node, path) {
+	if (node.state.kind === "directory") return statDirectoryNode(node);
+	if (node.state.kind === "symlink") {
+		const hash = node.origin.kind === "repo-blob" ? node.origin.hash : null;
+		let size = 0;
+		if (node.state.target !== void 0) size = node.state.target.length;
+		else if (hash !== null) size = readRepoBlobContent(source, hash, path).length;
+		return {
+			kind: "symlink",
+			mode: "120000",
+			size,
+			hash
+		};
+	}
+	const hash = node.origin.kind === "repo-blob" ? node.origin.hash : null;
+	let size = 0;
+	if (node.state.content !== void 0) size = node.state.content.length;
+	else if (hash !== null) size = readRepoBlobContent(source, hash, path).length;
+	return {
+		kind: "blob",
+		mode: node.state.mode,
+		size,
+		hash
+	};
+}
+function statDirectoryNode(node) {
+	return {
+		kind: "tree",
+		mode: "40000",
+		size: 0,
+		hash: node.origin.kind === "repo-tree" ? node.origin.hash : null
+	};
+}
+function cloneNodeGraphForCopy(source, state, node, path) {
+	const newNodeId = createNodeId();
+	const cloned = cloneSessionNodeForCopy(node, newNodeId);
+	state.setNode(cloned);
+	if (node.state.kind !== "directory" || cloned.state.kind !== "directory") return newNodeId;
+	let overlay = cloned.state.overlay;
+	const children = listDirectoryChildren(source, state, node, path);
+	for (const child of children) {
+		const childNode = state.getNode(child.nodeId);
+		if (childNode === null) continue;
+		const clonedChildId = cloneNodeGraphForCopy(source, state, childNode, path === "" ? child.name : `${path}/${child.name}`);
+		overlay = overlayBindEntry(overlay, child.name, clonedChildId);
+	}
+	state.setNode({
+		...cloned,
+		state: {
+			kind: "directory",
+			overlay
+		}
+	});
+	return newNodeId;
+}
+//#endregion
+export { createVirtualWorkdirSession, openVirtualWorkdirSession };

package/dist/workdir/sqlite-backend.d.mts

@@ -0,0 +1,30 @@
+import { VirtualWorkdirBackend } from "./core.mjs";
+import { Database } from "bun:sqlite";
+
+//#region src/workdir/sqlite-backend.d.ts
+/** 创建 SQLite Virtual Workdir backend 的可选参数 */
+interface CreateSqliteVirtualWorkdirBackendOptions {
+  /** 开启 WAL 模式，默认 true */
+  readonly walMode?: boolean;
+}
+/**
+ * SQLite Virtual Workdir backend（含资源释放能力）
+ */
+interface SqliteVirtualWorkdirBackend extends VirtualWorkdirBackend {
+  /** 释放 SQLite 数据库连接 */
+  [Symbol.dispose](): void;
+}
+/**
+ * 创建基于 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);
+ * ```
+ */
+declare function createSqliteVirtualWorkdirBackend(dbPath: string, options?: CreateSqliteVirtualWorkdirBackendOptions): SqliteVirtualWorkdirBackend;
+//#endregion
+export { CreateSqliteVirtualWorkdirBackendOptions, SqliteVirtualWorkdirBackend, createSqliteVirtualWorkdirBackend };