nano-git 0.3.0 → 0.3.2

package/dist/workdir/file-backend.mjs

@@ -1,82 +1,71 @@
+import { sha1 } from "../core/types.mjs";
 import { createRootDirectoryNode } from "./nodes.mjs";
-import { createVirtualWorkdirSessionId } from "./session-id.mjs";
-import { openVirtualWorkdirSession } from "./session.mjs";
+import { openVirtualWorkdir } from "./workdir.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 //#region src/workdir/file-backend.ts
 /**
-* Virtual Workdir 文件系统 backend
+* Virtual Workdir 文件系统持久化实现
 */
-const FILE_WORKDIR_MANIFEST_VERSION = 1;
+const FILE_WORKDIR_MANIFEST_VERSION = 5;
 const FILE_WORKDIR_TRANSACTION_SNAPSHOT_SUFFIX = ".txn-snapshot";
 /**
-* 创建基于文件系统目录的 Virtual Workdir backend
+* 打开基于目录持久化的 VirtualWorkdir
 *
 * @example
 * ```ts
-* const backend = createFileVirtualWorkdirBackend("/tmp/workdirs");
-* const sessionId = backend.createSession({ baseTree: tree });
-* const session = backend.openSession(repo.objects, sessionId);
-* expect(session.baseTree).toBe(tree);
+* const workdir = openFileVirtualWorkdir(repo.objects, "/tmp/workdir", {
+*   baseTree: tree,
+*   create: true,
+* });
+* expect(workdir.baseTree).toBe(tree);
 * ```
 */
-function createFileVirtualWorkdirBackend(rootDir, options = {}) {
-	const sessionsRoot = join(rootDir, options.sessionsDirName ?? "sessions");
-	mkdirSync(sessionsRoot, { recursive: true });
-	return {
-		kind: "file",
-		createSession(options) {
-			const sessionId = createVirtualWorkdirSessionId();
-			createFileVirtualWorkdirStateStore(sessionsRoot, sessionId).reset(options.baseTree);
-			return sessionId;
-		},
-		openSession(source, sessionId) {
-			if (!hasSession(sessionsRoot, sessionId)) throw new Error(`Virtual workdir session not found: ${sessionId}`);
-			validateSessionIntegrity(sessionsRoot, sessionId);
-			return openVirtualWorkdirSession(source, createFileVirtualWorkdirStateStore(sessionsRoot, sessionId));
-		},
-		deleteSession(sessionId) {
-			if (!hasSession(sessionsRoot, sessionId)) throw new Error(`Virtual workdir session not found: ${sessionId}`);
-			rmSync(getSessionDir(sessionsRoot, sessionId), {
-				recursive: true,
-				force: true
-			});
-		},
-		listSessions() {
-			if (!existsSync(sessionsRoot)) return [];
-			return readdirSync(sessionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => !entry.name.endsWith(FILE_WORKDIR_TRANSACTION_SNAPSHOT_SUFFIX)).filter((entry) => existsSync(getManifestPath(join(sessionsRoot, entry.name)))).map((entry) => decodePathToken(entry.name)).filter((sessionId) => {
-				try {
-					validateSessionIntegrity(sessionsRoot, sessionId);
-					return true;
-				} catch {
-					return false;
-				}
-			}).sort();
-		}
-	};
+function openFileVirtualWorkdir(source, workdirDir, options) {
+	const store = createFileVirtualWorkdirStateStore(workdirDir);
+	if (!hasFileVirtualWorkdir(workdirDir)) {
+		if (options.create !== true) throw new Error(`Virtual workdir not found: ${workdirDir}`);
+		store.reset(options.baseTree);
+	}
+	validateFileVirtualWorkdirIntegrity(workdirDir);
+	return openVirtualWorkdir(source, store);
+}
+/**
+* 删除指定目录上的持久化 VirtualWorkdir
+*
+* @example
+* ```ts
+* deleteFileVirtualWorkdir("/tmp/workdir");
+* ```
+*/
+function deleteFileVirtualWorkdir(workdirDir) {
+	if (!hasFileVirtualWorkdir(workdirDir)) throw new Error(`Virtual workdir not found: ${workdirDir}`);
+	rmSync(workdirDir, {
+		recursive: true,
+		force: true
+	});
 }
 /**
-* 创建单个 session 的文件系统状态存储
+* 创建单个文件系统 VirtualWorkdir 的状态存储
 *
 * @example
 * ```ts
-* const store = createFileVirtualWorkdirStateStore("/tmp/workdirs/sessions", sessionId);
+* const store = createFileVirtualWorkdirStateStore("/tmp/workdir");
 * expect(store.kind).toBe("file");
 * ```
 */
-function createFileVirtualWorkdirStateStore(sessionsRoot, sessionId) {
-	const sessionDir = getSessionDir(sessionsRoot, sessionId);
-	const manifestPath = getManifestPath(sessionDir);
-	const contentDir = getContentDir(sessionDir);
+function createFileVirtualWorkdirStateStore(workdirDir) {
+	const manifestPath = getManifestPath(workdirDir);
+	const contentDir = getContentDir(workdirDir);
 	return {
 		kind: "file",
 		transact(fn) {
-			const snapshotDir = `${sessionDir}${FILE_WORKDIR_TRANSACTION_SNAPSHOT_SUFFIX}`;
+			const snapshotDir = `${workdirDir}${FILE_WORKDIR_TRANSACTION_SNAPSHOT_SUFFIX}`;
 			rmSync(snapshotDir, {
 				recursive: true,
 				force: true
 			});
-			if (existsSync(sessionDir)) copyDirectoryRecursive(sessionDir, snapshotDir);
+			if (existsSync(workdirDir)) copyDirectoryRecursive(workdirDir, snapshotDir);
 			try {
 				const result = fn();
 				rmSync(snapshotDir, {
@@ -85,11 +74,11 @@ function createFileVirtualWorkdirStateStore(sessionsRoot, sessionId) {
 				});
 				return result;
 			} catch (error) {
-				rmSync(sessionDir, {
+				rmSync(workdirDir, {
 					recursive: true,
 					force: true
 				});
-				if (existsSync(snapshotDir)) renameSync(snapshotDir, sessionDir);
+				if (existsSync(snapshotDir)) renameSync(snapshotDir, workdirDir);
 				throw error;
 			}
 		},
@@ -97,7 +86,7 @@ function createFileVirtualWorkdirStateStore(sessionsRoot, sessionId) {
 			return readManifest(manifestPath).baseTree;
 		},
 		writeBaseTree(baseTree) {
-			updateManifest(sessionDir, (manifest) => ({
+			updateManifest(workdirDir, (manifest) => ({
 				...manifest,
 				baseTree
 			}));
@@ -108,7 +97,7 @@ function createFileVirtualWorkdirStateStore(sessionsRoot, sessionId) {
 			return restoreNode(record, contentDir);
 		},
 		setNode(node) {
-			updateManifest(sessionDir, (manifest) => {
+			updateManifest(workdirDir, (manifest) => {
 				const record = persistNode(contentDir, node);
 				return {
 					...manifest,
@@ -120,7 +109,7 @@ function createFileVirtualWorkdirStateStore(sessionsRoot, sessionId) {
 			});
 		},
 		deleteNode(id) {
-			updateManifest(sessionDir, (manifest) => {
+			updateManifest(workdirDir, (manifest) => {
 				if (manifest.nodes[id] === void 0) return manifest;
 				const { [id]: _deleted, ...rest } = manifest.nodes;
 				return {
@@ -129,56 +118,79 @@ function createFileVirtualWorkdirStateStore(sessionsRoot, sessionId) {
 				};
 			});
 		},
-		appendChange(record) {
-			updateManifest(sessionDir, (manifest) => ({
+		listChangeRecords() {
+			return readManifest(manifestPath).changeRecords.map(restoreChangeRecord);
+		},
+		getChangeRecord(path) {
+			return readManifest(manifestPath).changeRecords.map(restoreChangeRecord).find((record) => record.path === path) ?? null;
+		},
+		setChangeRecord(record) {
+			updateManifest(workdirDir, (manifest) => {
+				const others = manifest.changeRecords.filter((item) => item.path !== record.path);
+				return {
+					...manifest,
+					changeRecords: [...others, serializeChangeRecord(record)].sort((left, right) => left.path.localeCompare(right.path))
+				};
+			});
+		},
+		deleteChangeRecord(path) {
+			updateManifest(workdirDir, (manifest) => ({
 				...manifest,
-				changes: [...manifest.changes, record]
+				changeRecords: manifest.changeRecords.filter((item) => item.path !== path)
 			}));
 		},
-		listChangeRecords() {
-			return readManifest(manifestPath).changes;
+		listDirtyDirSummaries() {
+			return readManifest(manifestPath).dirtyDirSummaries.map(restoreDirtyDirSummary);
+		},
+		getDirtyDirSummary(path) {
+			return readManifest(manifestPath).dirtyDirSummaries.map(restoreDirtyDirSummary).find((summary) => summary.path === path) ?? null;
+		},
+		setDirtyDirSummary(summary) {
+			updateManifest(workdirDir, (manifest) => {
+				const others = manifest.dirtyDirSummaries.filter((item) => item.path !== summary.path);
+				return {
+					...manifest,
+					dirtyDirSummaries: [...others, serializeDirtyDirSummary(summary)].sort((left, right) => left.path.localeCompare(right.path))
+				};
+			});
 		},
-		clearChanges() {
-			updateManifest(sessionDir, (manifest) => ({
+		deleteDirtyDirSummary(path) {
+			updateManifest(workdirDir, (manifest) => ({
 				...manifest,
-				changes: []
+				dirtyDirSummaries: manifest.dirtyDirSummaries.filter((item) => item.path !== path)
 			}));
 		},
 		reset(baseTree) {
-			rmSync(sessionDir, {
+			rmSync(workdirDir, {
 				recursive: true,
 				force: true
 			});
-			ensureSessionDirs(sessionDir, contentDir);
+			ensureWorkdirDirs(workdirDir, contentDir);
 			writeManifestAtomic(manifestPath, createManifest(baseTree, { [createRootDirectoryNode(baseTree).id]: serializeDirectoryNode(createRootDirectoryNode(baseTree)) }));
 		}
 	};
 }
-function hasSession(sessionsRoot, sessionId) {
-	return existsSync(getManifestPath(getSessionDir(sessionsRoot, sessionId)));
+function hasFileVirtualWorkdir(workdirDir) {
+	return existsSync(getManifestPath(workdirDir));
 }
-function validateSessionIntegrity(sessionsRoot, sessionId) {
-	const sessionDir = getSessionDir(sessionsRoot, sessionId);
-	const manifest = readManifest(getManifestPath(sessionDir));
+function validateFileVirtualWorkdirIntegrity(workdirDir) {
+	const manifest = readManifest(getManifestPath(workdirDir));
 	const root = manifest.nodes.root;
-	if (root === void 0) throw new Error(`Virtual workdir session is corrupted: missing root node for ${sessionId}`);
-	if (restoreNode(root, getContentDir(sessionDir)).state.kind !== "directory") throw new Error(`Virtual workdir session is corrupted: root node is not a directory for ${sessionId}`);
-	for (const record of Object.values(manifest.nodes)) restoreNode(record, getContentDir(sessionDir));
+	if (root === void 0) throw new Error(`Virtual workdir is corrupted: missing root node for ${workdirDir}`);
+	if (restoreNode(root, getContentDir(workdirDir)).state.kind !== "directory") throw new Error(`Virtual workdir is corrupted: root node is not a directory for ${workdirDir}`);
+	for (const record of Object.values(manifest.nodes)) restoreNode(record, getContentDir(workdirDir));
 }
-function getSessionDir(sessionsRoot, sessionId) {
-	return join(sessionsRoot, encodePathToken(sessionId));
+function getManifestPath(workdirDir) {
+	return join(workdirDir, "manifest.json");
 }
-function getManifestPath(sessionDir) {
-	return join(sessionDir, "manifest.json");
-}
-function getContentDir(sessionDir) {
-	return join(sessionDir, "content");
+function getContentDir(workdirDir) {
+	return join(workdirDir, "content");
 }
 function getContentPath(contentDir, payloadRef) {
 	return join(contentDir, `${encodePathToken(payloadRef)}.bin`);
 }
-function ensureSessionDirs(sessionDir, contentDir) {
-	mkdirSync(sessionDir, { recursive: true });
+function ensureWorkdirDirs(workdirDir, contentDir) {
+	mkdirSync(workdirDir, { recursive: true });
 	mkdirSync(contentDir, { recursive: true });
 }
 function copyDirectoryRecursive(sourceDir, targetDir) {
@@ -197,28 +209,30 @@ function createManifest(baseTree, nodes) {
 	return {
 		formatVersion: FILE_WORKDIR_MANIFEST_VERSION,
 		baseTree,
-		changes: [],
-		nodes
+		nodes,
+		changeRecords: [],
+		dirtyDirSummaries: []
 	};
 }
-function updateManifest(sessionDir, updater) {
-	const manifestPath = getManifestPath(sessionDir);
-	ensureSessionDirs(sessionDir, getContentDir(sessionDir));
+function updateManifest(workdirDir, updater) {
+	const manifestPath = getManifestPath(workdirDir);
+	ensureWorkdirDirs(workdirDir, getContentDir(workdirDir));
 	writeManifestAtomic(manifestPath, updater(readManifest(manifestPath)));
 }
 function writeManifestAtomic(path, manifest) {
 	writeJsonAtomic(path, manifest);
 }
 function readManifest(manifestPath) {
-	if (!existsSync(manifestPath)) throw new Error(`Virtual workdir session manifest not found: ${manifestPath}`);
+	if (!existsSync(manifestPath)) throw new Error(`Virtual workdir manifest not found: ${manifestPath}`);
 	const manifest = readJson(manifestPath);
 	validateManifest(manifest);
 	return manifest;
 }
 function validateManifest(manifest) {
 	if (typeof manifest.baseTree !== "string" || manifest.baseTree.length === 0) throw new Error("Invalid virtual workdir manifest baseTree");
-	if (!Array.isArray(manifest.changes)) throw new Error("Invalid virtual workdir manifest changes");
 	if (typeof manifest.nodes !== "object" || manifest.nodes === null || Array.isArray(manifest.nodes)) throw new Error("Invalid virtual workdir manifest nodes");
+	if (!Array.isArray(manifest.changeRecords)) throw new Error("Invalid virtual workdir manifest changeRecords");
+	if (!Array.isArray(manifest.dirtyDirSummaries)) throw new Error("Invalid virtual workdir manifest dirtyDirSummaries");
 	if (manifest.formatVersion !== FILE_WORKDIR_MANIFEST_VERSION) throw new Error(`Unsupported virtual workdir file manifest version: expected ${FILE_WORKDIR_MANIFEST_VERSION}, got ${manifest.formatVersion}`);
 }
 function persistNode(contentDir, node) {
@@ -339,6 +353,62 @@ function restoreOrigin(record) {
 		hash: origin.hash
 	};
 }
+function serializeChangeRecord(record) {
+	return {
+		path: record.path,
+		previous: record.previous,
+		current: record.current,
+		source: record.source
+	};
+}
+function restoreChangeRecord(record) {
+	return {
+		path: record.path,
+		previous: record.previous === null ? null : {
+			...record.previous,
+			hash: record.previous.hash
+		},
+		current: record.current === null ? null : {
+			...record.current,
+			hash: record.current.hash
+		},
+		source: record.source
+	};
+}
+function serializeDirtyDirSummary(summary) {
+	return {
+		path: summary.path,
+		isDirty: summary.isDirty,
+		dirtyEntryCount: summary.dirtyEntryCount,
+		dirtyDescendantCount: summary.dirtyDescendantCount,
+		affectedNames: [...summary.affectedNames],
+		currentTreeHash: summary.currentTreeHash,
+		hashState: summary.hashState
+	};
+}
+function restoreDirtyDirSummary(summary) {
+	return {
+		path: summary.path,
+		isDirty: summary.isDirty,
+		dirtyEntryCount: readDirtyDirCount(summary.dirtyEntryCount, "dirtyEntryCount"),
+		dirtyDescendantCount: readDirtyDirCount(summary.dirtyDescendantCount, "dirtyDescendantCount"),
+		affectedNames: readDirtyDirAffectedNames(summary.affectedNames),
+		currentTreeHash: summary.currentTreeHash === null ? null : sha1(summary.currentTreeHash),
+		hashState: readDirtyDirHashState(summary.hashState)
+	};
+}
+function readDirtyDirCount(raw, field) {
+	if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 0) throw new Error(`Invalid file workdir dirty dir summary ${field}`);
+	return raw;
+}
+function readDirtyDirAffectedNames(raw) {
+	if (!Array.isArray(raw) || raw.some((item) => typeof item !== "string")) throw new Error("Invalid file workdir dirty dir summary affectedNames");
+	return [...raw].sort((left, right) => left.localeCompare(right));
+}
+function readDirtyDirHashState(raw) {
+	if (raw === "stale" || raw === "materialized") return raw;
+	throw new Error(`Invalid file workdir dirty dir summary hashState: ${String(raw)}`);
+}
 function readPayload(contentDir, payloadRef) {
 	const path = getContentPath(contentDir, payloadRef);
 	if (!existsSync(path)) throw new Error(`Virtual workdir payload not found: ${payloadRef}`);
@@ -359,8 +429,5 @@ function writeBufferAtomic(path, value) {
 function encodePathToken(value) {
 	return encodeURIComponent(value);
 }
-function decodePathToken(value) {
-	return decodeURIComponent(value);
-}
 //#endregion
-export { createFileVirtualWorkdirBackend };
+export { createFileVirtualWorkdirStateStore, deleteFileVirtualWorkdir, openFileVirtualWorkdir };

package/dist/workdir/file.d.mts

@@ -1,2 +1,2 @@
-import { CreateFileVirtualWorkdirBackendOptions, createFileVirtualWorkdirBackend } from "./file-backend.mjs";
-export { type CreateFileVirtualWorkdirBackendOptions, createFileVirtualWorkdirBackend };
+import { OpenFileVirtualWorkdirOptions, createFileVirtualWorkdirStateStore, deleteFileVirtualWorkdir, openFileVirtualWorkdir } from "./file-backend.mjs";
+export { type OpenFileVirtualWorkdirOptions, createFileVirtualWorkdirStateStore, deleteFileVirtualWorkdir, openFileVirtualWorkdir };

package/dist/workdir/file.mjs

@@ -1,2 +1,2 @@
-import { createFileVirtualWorkdirBackend } from "./file-backend.mjs";
-export { createFileVirtualWorkdirBackend };
+import { createFileVirtualWorkdirStateStore, deleteFileVirtualWorkdir, openFileVirtualWorkdir } from "./file-backend.mjs";
+export { createFileVirtualWorkdirStateStore, deleteFileVirtualWorkdir, openFileVirtualWorkdir };

package/dist/workdir/ids.d.mts

@@ -1,5 +1,5 @@
 //#region src/workdir/ids.d.ts
-/** 会话内节点的稳定身份 */
+/** workdir 内节点的稳定身份 */
 type NodeId = string & {
   readonly __brand: "NodeId";
 };

package/dist/workdir/ids.mjs

@@ -1,9 +1,9 @@
 //#region src/workdir/ids.ts
-/** 根目录节点的固定 ID（每个 session 一致） */
+/** 根目录节点的固定 ID（每个 workdir 一致） */
 const VIRTUAL_ROOT_NODE_ID = "root";
 let nextNodeCounter = 1;
 /**
-* 分配新的 session 节点 ID
+* 分配新的 workdir 节点 ID
 */
 function createNodeId() {
 	const id = `node:${nextNodeCounter}`;
@@ -11,7 +11,7 @@ function createNodeId() {
 	return id;
 }
 /**
-* 为仓库对象哈希派生稳定的 session 节点 ID（懒加载、未 copy 前复用）
+* 为仓库对象哈希派生稳定的 workdir 节点 ID（懒加载、未 copy 前复用）
 */
 function originBackedNodeId(hash) {
 	return `origin:${hash}`;

package/dist/workdir/memory-backend.mjs

@@ -1,8 +1,5 @@
-import { createVirtualChangeLog } from "./change-log.mjs";
 import { VIRTUAL_ROOT_NODE_ID } from "./ids.mjs";
 import { createRootDirectoryNode } from "./nodes.mjs";
-import { createVirtualWorkdirSessionId } from "./session-id.mjs";
-import { openVirtualWorkdirSession } from "./session.mjs";
 //#region src/workdir/memory-backend.ts
 /**
 * Virtual Workdir 内存状态存储
@@ -20,7 +17,8 @@ function createVirtualWorkdirMemoryStateStore(baseTree) {
 	const state = {
 		baseTree,
 		nodes: /* @__PURE__ */ new Map(),
-		changeLog: createVirtualChangeLog()
+		changeRecords: /* @__PURE__ */ new Map(),
+		dirtyDirSummaries: /* @__PURE__ */ new Map()
 	};
 	resetState(state, baseTree);
 	return {
@@ -49,76 +47,62 @@ function createVirtualWorkdirMemoryStateStore(baseTree) {
 		deleteNode(id) {
 			state.nodes.delete(id);
 		},
-		appendChange(record) {
-			state.changeLog.append(record);
-		},
 		listChangeRecords() {
-			return state.changeLog.snapshot();
+			return Array.from(state.changeRecords.values()).sort((left, right) => left.path.localeCompare(right.path));
 		},
-		clearChanges() {
-			state.changeLog.clear();
+		getChangeRecord(path) {
+			return state.changeRecords.get(path) ?? null;
 		},
-		reset(nextBaseTree) {
-			resetState(state, nextBaseTree);
-		}
-	};
-}
-/**
-* 创建内存版 Virtual Workdir backend
-*
-* @example
-* ```ts
-* const backend = createMemoryVirtualWorkdirBackend();
-* const sessionId = backend.createSession({ baseTree: tree });
-* const session = backend.openSession(repo.objects, sessionId);
-* expect(session.baseTree).toBe(tree);
-* ```
-*/
-function createMemoryVirtualWorkdirBackend() {
-	const sessions = /* @__PURE__ */ new Map();
-	return {
-		kind: "memory",
-		createSession(options) {
-			const sessionId = createVirtualWorkdirSessionId();
-			sessions.set(sessionId, createVirtualWorkdirMemoryStateStore(options.baseTree));
-			return sessionId;
+		setChangeRecord(record) {
+			state.changeRecords.set(record.path, record);
+		},
+		deleteChangeRecord(path) {
+			state.changeRecords.delete(path);
 		},
-		openSession(source, sessionId) {
-			const store = sessions.get(sessionId);
-			if (store === void 0) throw new Error(`Virtual workdir session not found: ${sessionId}`);
-			return openVirtualWorkdirSession(source, store);
+		listDirtyDirSummaries() {
+			return Array.from(state.dirtyDirSummaries.values()).sort((left, right) => left.path.localeCompare(right.path));
 		},
-		deleteSession(sessionId) {
-			if (!sessions.delete(sessionId)) throw new Error(`Virtual workdir session not found: ${sessionId}`);
+		getDirtyDirSummary(path) {
+			return state.dirtyDirSummaries.get(path) ?? null;
 		},
-		listSessions() {
-			return Array.from(sessions.keys());
+		setDirtyDirSummary(summary) {
+			state.dirtyDirSummaries.set(summary.path, summary);
+		},
+		deleteDirtyDirSummary(path) {
+			state.dirtyDirSummaries.delete(path);
+		},
+		reset(nextBaseTree) {
+			resetState(state, nextBaseTree);
 		}
 	};
 }
 function resetState(state, baseTree) {
 	state.baseTree = baseTree;
 	state.nodes.clear();
+	state.changeRecords.clear();
+	state.dirtyDirSummaries.clear();
 	state.nodes.set(VIRTUAL_ROOT_NODE_ID, createRootDirectoryNode(baseTree));
-	state.changeLog.clear();
 }
 function snapshotState(state) {
 	const nodes = /* @__PURE__ */ new Map();
-	for (const [nodeId, node] of state.nodes) nodes.set(nodeId, cloneSessionNode(node));
+	for (const [nodeId, node] of state.nodes) nodes.set(nodeId, cloneWorkdirNode(node));
 	return {
 		baseTree: state.baseTree,
 		nodes,
-		changes: state.changeLog.snapshot()
+		changeRecords: new Map(state.changeRecords),
+		dirtyDirSummaries: new Map(state.dirtyDirSummaries)
 	};
 }
 function restoreState(state, snapshot) {
 	state.baseTree = snapshot.baseTree;
 	state.nodes.clear();
-	for (const [nodeId, node] of snapshot.nodes) state.nodes.set(nodeId, cloneSessionNode(node));
-	state.changeLog.clear();
-	for (const record of snapshot.changes) state.changeLog.append(record);
+	state.changeRecords.clear();
+	state.dirtyDirSummaries.clear();
+	for (const [nodeId, node] of snapshot.nodes) state.nodes.set(nodeId, cloneWorkdirNode(node));
+	for (const [path, record] of snapshot.changeRecords) state.changeRecords.set(path, record);
+	for (const [path, summary] of snapshot.dirtyDirSummaries) state.dirtyDirSummaries.set(path, summary);
 }
-function cloneSessionNode(node) {
+function cloneWorkdirNode(node) {
 	if (node.state.kind === "directory") return {
 		id: node.id,
 		origin: node.origin,
@@ -156,4 +140,4 @@ function cloneSessionNode(node) {
 	};
 }
 //#endregion
-export { createMemoryVirtualWorkdirBackend, createVirtualWorkdirMemoryStateStore };
+export { createVirtualWorkdirMemoryStateStore };

package/dist/workdir/memory.d.mts

@@ -1,3 +1,2 @@
-import { createMemoryVirtualWorkdirBackend } from "./memory-backend.mjs";
-import { createVirtualWorkdirSession, openVirtualWorkdirSession } from "./session.mjs";
-export { createMemoryVirtualWorkdirBackend, createVirtualWorkdirSession, openVirtualWorkdirSession };
+import { createVirtualWorkdir, openVirtualWorkdir } from "./workdir.mjs";
+export { createVirtualWorkdir, openVirtualWorkdir };

package/dist/workdir/memory.mjs

@@ -1,3 +1,2 @@
-import { createVirtualWorkdirSession, openVirtualWorkdirSession } from "./session.mjs";
-import { createMemoryVirtualWorkdirBackend } from "./memory-backend.mjs";
-export { createMemoryVirtualWorkdirBackend, createVirtualWorkdirSession, openVirtualWorkdirSession };
+import { createVirtualWorkdir, openVirtualWorkdir } from "./workdir.mjs";
+export { createVirtualWorkdir, openVirtualWorkdir };

package/dist/workdir/nodes.d.mts

@@ -6,7 +6,7 @@ import { DirectoryOverlay } from "./overlay.mjs";
 /** Blob / 符号链接在 origin 与 state 中使用的 mode */
 type BlobObjectMode = "100644" | "100755" | "120000";
 /**
- * 节点来源（repo 对象或纯 session 新建）
+ * 节点来源（repo 对象或纯 workdir 新建）
  */
 type NodeOrigin = {
   readonly kind: "none";
@@ -21,7 +21,7 @@ type NodeOrigin = {
 /**
  * 目录节点当前状态
  *
- * `overlay` 表达 session 层增删改；子项 nodeId 通过 overlay 合成与懒加载解析。
+ * `overlay` 表达 workdir 层增删改；子项 nodeId 通过 overlay 合成与懒加载解析。
  */
 interface DirectoryNodeState {
   readonly kind: "directory";
@@ -44,14 +44,14 @@ interface SymlinkNodeState {
   readonly mode: "120000";
   readonly target?: Buffer;
 }
-type SessionNodeState = DirectoryNodeState | FileNodeState | SymlinkNodeState;
+type WorkdirNodeState = DirectoryNodeState | FileNodeState | SymlinkNodeState;
 /**
- * 完整的会话节点记录
+ * 完整的 workdir 节点记录
  */
-interface SessionNode {
+interface WorkdirNode {
   readonly id: NodeId;
   readonly origin: NodeOrigin;
-  readonly state: SessionNodeState;
+  readonly state: WorkdirNodeState;
 }
 //#endregion
-export { SessionNode };
+export { WorkdirNode };

package/dist/workdir/nodes.mjs

@@ -2,7 +2,7 @@ import { VIRTUAL_ROOT_NODE_ID } from "./ids.mjs";
 import { cloneDirectoryOverlay, createEmptyDirectoryOverlay } from "./overlay.mjs";
 //#region src/workdir/nodes.ts
 /**
-* Virtual Workdir 会话节点状态模型
+* Virtual Workdir 节点状态模型
 *
 * 节点身份（nodeId）与目录路径绑定分离；origin 描述 repo-backed 来源。
 */
@@ -29,12 +29,6 @@ function nodeHasRepoOrigin(node) {
 	return node.origin.kind === "repo-tree" || node.origin.kind === "repo-blob";
 }
 /**
-* 目录 overlay 是否有 session 层修改
-*/
-function isDirectoryOverlayDirty(overlay) {
-	return overlay.addedEntries.size > 0 || overlay.deletedNames.size > 0;
-}
-/**
 * 将节点状态恢复到 origin 语义（丢弃 materialize / 目录 overlay）
 *
 * 无 repo origin 时返回原状态引用，由上层决定是否抛错。
@@ -69,7 +63,7 @@ function revertNodeState(node) {
 /**
 * 为 `copy` 创建新节点：共享 origin，目录为浅复制（子项绑定保留，但 nodeId 为新）
 */
-function cloneSessionNodeForCopy(source, newId) {
+function cloneWorkdirNodeForCopy(source, newId) {
 	const origin = source.origin;
 	if (source.state.kind === "directory") return {
 		id: newId,
@@ -109,4 +103,4 @@ function cloneSessionNodeForCopy(source, newId) {
 	};
 }
 //#endregion
-export { cloneSessionNodeForCopy, createRootDirectoryNode, isDirectoryOverlayDirty, revertNodeState };
+export { cloneWorkdirNodeForCopy, createRootDirectoryNode, revertNodeState };

package/dist/workdir/overlay.d.mts

@@ -2,12 +2,12 @@ import { NodeId } from "./ids.mjs";
 
 //#region src/workdir/overlay.d.ts
 /**
- * 目录 overlay 状态（挂在目录 SessionNode 上）
+ * 目录 overlay 状态（挂在目录 WorkdirNode 上）
  */
 interface DirectoryOverlay {
-  /** session 新增或覆盖：条目名 -> 绑定的 nodeId */
+  /** workdir 新增或覆盖：条目名 -> 绑定的 nodeId */
   readonly addedEntries: Map<string, NodeId>;
-  /** session 删除的 origin/先前条目名（tombstone） */
+  /** workdir 删除的 origin/先前条目名（tombstone） */
   readonly deletedNames: Set<string>;
 }
 //#endregion