nano-git 0.3.0 → 0.3.2

package/dist/workdir/workdir.mjs

@@ -0,0 +1,280 @@
+import { VirtualNotDirectoryError, VirtualNotFileError, VirtualNotSymlinkError, VirtualPathAlreadyExistsError, VirtualPathNotFoundError, VirtualRevertNotSupportedError } from "../core/errors.mjs";
+import { createNodeId } from "./ids.mjs";
+import { modeToVirtualEntryKind, readRepoBlobContent } from "./origin.mjs";
+import { overlayBindEntry, overlayRenameEntry, overlayTombstoneEntry } from "./overlay.mjs";
+import { assertValidVirtualPath, normalizeDirectoryPath } from "./path.mjs";
+import { getDirectoryChildrenView, getRootNode, requireExistingWriteTarget, requireMissingWriteTarget, resolveLeafWriteTarget, resolvePath, resolveWriteTransfer } from "./workdir-path.mjs";
+import { createChangeIndexPlanner } from "./change-index-plan.mjs";
+import { computeVirtualDiff, rebuildNormalizedChangeIndex, refreshChangeRecordForPath, replaceChangeRecords, rewriteChangeRecordForRename, writeChangeRecordForCopy } from "./change-index.mjs";
+import { createDirtyDirPlanner } from "./dirty-dir-plan.mjs";
+import { revertNodeState } from "./nodes.mjs";
+import { createVirtualWorkdirMemoryStateStore } from "./memory-backend.mjs";
+import { cloneNodeGraphForCopy, runInWriteTransaction, statDirectoryNode, statNode, updateParentOverlay } from "./workdir-transaction.mjs";
+import { writeTreeFromSession } from "./write-tree.mjs";
+//#region src/workdir/workdir.ts
+/**
+* VirtualWorkdir 行为编排
+*
+* Phase 5：完整文件/目录 rename 与 copy 语义。
+*/
+/**
+* 基于 ObjectDatabase 创建 VirtualWorkdir
+*
+* @example
+* ```ts
+* const repo = createMemoryRepository();
+* const tree = repo.createTree([]);
+* const workdir = createVirtualWorkdir(repo.objects, { baseTree: tree });
+* expect(workdir.readdir()).toEqual([]);
+* ```
+*/
+function createVirtualWorkdir(source, options) {
+	return openVirtualWorkdir(source, createVirtualWorkdirMemoryStateStore(options.baseTree));
+}
+/**
+* 基于已有状态存储打开 VirtualWorkdir
+*
+* @example
+* ```ts
+* const store = createVirtualWorkdirMemoryStateStore(tree);
+* const workdir = openVirtualWorkdir(repo.objects, store);
+* expect(workdir.baseTree).toBe(tree);
+* ```
+*/
+function openVirtualWorkdir(source, state) {
+	const currentNodeHashes = /* @__PURE__ */ new Map();
+	const invalidateDiffCaches = () => {
+		currentNodeHashes.clear();
+	};
+	const refreshChangeIndex = () => {
+		invalidateDiffCaches();
+		replaceChangeRecords(state, rebuildNormalizedChangeIndex(source, state, {
+			currentNodeHashes,
+			setCurrentNodeHash(nodeId, hash) {
+				currentNodeHashes.set(nodeId, hash);
+			}
+		}));
+	};
+	const refreshChangeIndexForPath = (path) => {
+		invalidateDiffCaches();
+		refreshChangeRecordForPath(source, state, path, {
+			currentNodeHashes,
+			setCurrentNodeHash(nodeId, hash) {
+				currentNodeHashes.set(nodeId, hash);
+			}
+		});
+	};
+	const rewriteChangeIndexForRename = (from, to) => {
+		invalidateDiffCaches();
+		rewriteChangeRecordForRename(source, state, from, to, {
+			currentNodeHashes,
+			setCurrentNodeHash(nodeId, hash) {
+				currentNodeHashes.set(nodeId, hash);
+			}
+		});
+	};
+	const writeChangeIndexForCopy = (from, to) => {
+		invalidateDiffCaches();
+		writeChangeRecordForCopy(source, state, from, to, {
+			currentNodeHashes,
+			setCurrentNodeHash(nodeId, hash) {
+				currentNodeHashes.set(nodeId, hash);
+			}
+		});
+	};
+	const changeIndexPlanner = createChangeIndexPlanner(source, state, {
+		rebuildAll: refreshChangeIndex,
+		refreshPath: refreshChangeIndexForPath,
+		rewriteRename: rewriteChangeIndexForRename,
+		writeCopy: writeChangeIndexForCopy
+	});
+	const dirtyDirPlanner = createDirtyDirPlanner(source, state);
+	refreshChangeIndex();
+	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 getDirectoryChildrenView(source, state, resolved.node, normalized).children.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, () => dirtyDirPlanner.rebuild([path]), invalidateDiffCaches, () => {
+				const target = requireMissingWriteTarget(source, state, 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, target.parentNode.id, overlayBindEntry(target.parentNode.state.overlay, target.name, nodeId));
+			});
+		},
+		writeFile(path, content, options) {
+			runInWriteTransaction(state, () => {
+				changeIndexPlanner.apply(changeIndexPlanner.planRefreshForPath(path));
+				dirtyDirPlanner.rebuild([path]);
+			}, invalidateDiffCaches, () => {
+				const mode = options?.mode ?? "100644";
+				const target = resolveLeafWriteTarget(source, state, path);
+				const nodeId = target.existing !== null ? target.existing.node.id : createNodeId();
+				const fileNode = {
+					id: nodeId,
+					origin: target.existing !== null ? target.existing.node.origin : { kind: "none" },
+					state: {
+						kind: "file",
+						mode,
+						content
+					}
+				};
+				state.setNode(fileNode);
+				if (target.existing === null || target.parentNode.state.overlay.addedEntries.has(target.name)) updateParentOverlay(state, target.parentNode.id, overlayBindEntry(target.parentNode.state.overlay, target.name, nodeId));
+			});
+		},
+		writeLink(path, target) {
+			runInWriteTransaction(state, () => {
+				changeIndexPlanner.apply(changeIndexPlanner.planRefreshForPath(path));
+				dirtyDirPlanner.rebuild([path]);
+			}, invalidateDiffCaches, () => {
+				const writeTarget = resolveLeafWriteTarget(source, state, path);
+				const nodeId = writeTarget.existing !== null ? writeTarget.existing.node.id : createNodeId();
+				const linkNode = {
+					id: nodeId,
+					origin: writeTarget.existing !== null ? writeTarget.existing.node.origin : { kind: "none" },
+					state: {
+						kind: "symlink",
+						mode: "120000",
+						target: Buffer.from(target)
+					}
+				};
+				state.setNode(linkNode);
+				if (writeTarget.existing === null || writeTarget.parentNode.state.overlay.addedEntries.has(writeTarget.name)) updateParentOverlay(state, writeTarget.parentNode.id, overlayBindEntry(writeTarget.parentNode.state.overlay, writeTarget.name, nodeId));
+			});
+		},
+		delete(path) {
+			runInWriteTransaction(state, () => {
+				changeIndexPlanner.apply(changeIndexPlanner.planRefreshForPath(path, { treatMissingAsIncremental: true }));
+				dirtyDirPlanner.rebuild([path]);
+			}, invalidateDiffCaches, () => {
+				const target = requireExistingWriteTarget(source, state, path);
+				updateParentOverlay(state, target.parentNode.id, overlayTombstoneEntry(target.parentNode.state.overlay, target.name));
+			});
+		},
+		rename(from, to) {
+			runInWriteTransaction(state, () => {
+				changeIndexPlanner.apply(changeIndexPlanner.planRewriteForRename(from, to));
+				dirtyDirPlanner.rebuild([from, to]);
+			}, invalidateDiffCaches, () => {
+				assertValidVirtualPath(from);
+				assertValidVirtualPath(to);
+				if (from === to) return;
+				const { from: fromTarget, to: toTarget } = resolveWriteTransfer(source, state, from, to);
+				const sourceNode = fromTarget.existing.node;
+				if (toTarget.existing !== 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 (fromTarget.parentNode.id === toTarget.parentNode.id) updateParentOverlay(state, fromTarget.parentNode.id, overlayRenameEntry(fromTarget.parentNode.state.overlay, fromTarget.name, toTarget.name, sourceNode.id));
+				else {
+					updateParentOverlay(state, fromTarget.parentNode.id, overlayTombstoneEntry(fromTarget.parentNode.state.overlay, fromTarget.name));
+					updateParentOverlay(state, toTarget.parentNode.id, overlayBindEntry(toTarget.parentNode.state.overlay, toTarget.name, sourceNode.id));
+				}
+			});
+		},
+		copy(from, to) {
+			runInWriteTransaction(state, () => {
+				changeIndexPlanner.apply(changeIndexPlanner.planWriteForCopy(from, to));
+				dirtyDirPlanner.rebuild([from, to]);
+			}, invalidateDiffCaches, () => {
+				assertValidVirtualPath(from);
+				assertValidVirtualPath(to);
+				if (from === to) throw new VirtualPathAlreadyExistsError(to);
+				const { from: fromTarget, to: toTarget } = resolveWriteTransfer(source, state, from, to);
+				const sourceNode = fromTarget.existing.node;
+				if (toTarget.existing !== null) throw new VirtualPathAlreadyExistsError(to);
+				const newNodeId = cloneNodeGraphForCopy(source, state, sourceNode, from);
+				updateParentOverlay(state, toTarget.parentNode.id, overlayBindEntry(toTarget.parentNode.state.overlay, toTarget.name, newNodeId));
+			});
+		},
+		revert(path) {
+			runInWriteTransaction(state, () => {
+				changeIndexPlanner.apply(changeIndexPlanner.planRefreshForPath(path));
+				dirtyDirPlanner.rebuild([path]);
+			}, invalidateDiffCaches, () => {
+				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);
+			});
+		},
+		diff() {
+			return computeVirtualDiff(state);
+		},
+		writeTree() {
+			return writeTreeFromSession(source, state);
+		},
+		reset(baseTree) {
+			runInWriteTransaction(state, null, invalidateDiffCaches, () => {
+				state.reset(baseTree);
+				dirtyDirPlanner.clear();
+			});
+		}
+	};
+}
+//#endregion
+export { createVirtualWorkdir, openVirtualWorkdir };

package/dist/workdir/write-tree.mjs

@@ -1,23 +1,25 @@
 import { writeObject } from "../objects/raw.mjs";
-import { isDirectoryOverlayDirty } from "./nodes.mjs";
-import { listDirectoryChildren } from "./session-internal.mjs";
+import { readRepoTree } from "./origin.mjs";
+import { listDirectoryChildren } from "./workdir-path.mjs";
+import { createNamedOriginChildLookup, observeListedDirectoryChild, observeNamedDirectoryChild, planAffectedDirectoryChildren } from "./directory-view.mjs";
+import { materializeDirtyDirSummary } from "./dirty-dir.mjs";
 //#region src/workdir/write-tree.ts
 /**
 * Virtual Workdir overlay -> tree 最小化编译
 *
-* 遍历 session 的目录 overlay，将受影响的目录重写为新 tree，
+* 遍历 workdir 的目录 overlay，将受影响的目录重写为新 tree，
 * 未修改的 repo-backed 子树/文件尽量复用原对象哈希。
 *
 * writeTree() 成功后不清空 overlay，不推进 baseTree。
 */
 /**
-* 将当前 session 状态编译为新的根 tree
+* 将当前 workdir 状态编译为新的根 tree
 *
 * 只重写受 overlay 影响的目录；文件/符号链接仅在 materialized 时写新 blob。
 * 未修改的 repo-backed 条目直接复用 origin hash。
 *
 * @param source - 可写对象数据库（用于写入新 blob/tree）
-* @param state - session 内存状态
+* @param state - workdir 内部状态
 * @returns 新根 tree 的 SHA-1
 *
 * @example
@@ -35,63 +37,125 @@ function writeTreeFromSession(source, state) {
 *
 * 返回新 tree 的 SHA-1（若目录无任何变化则直接复用 origin hash）。
 */
-function compileDirectory(writeSource, readSource, state, dirNode) {
+function compileDirectory(writeSource, readSource, state, dirNode, dirPath = "") {
 	if (dirNode.state.kind !== "directory") throw new Error("compileDirectory called on non-directory node");
-	const children = listDirectoryChildren(readSource, state, dirNode, "");
+	const summary = state.getDirtyDirSummary(dirPath);
+	if (summary !== null && summary.hashState === "materialized" && summary.currentTreeHash !== null) return summary.currentTreeHash;
+	if (summary === null && dirNode.origin.kind === "repo-tree") return dirNode.origin.hash;
 	let anyChanged = false;
-	const newEntries = [];
-	for (const child of children) {
-		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;
-			newEntries.push({
+	const newEntries = collectCompiledEntries(writeSource, readSource, state, dirNode, dirPath, summary, (changed) => {
+		if (changed) anyChanged = true;
+	});
+	if (summary !== null && (summary.dirtyEntryCount > 0 || summary.dirtyDescendantCount > 0)) anyChanged = true;
+	if (!anyChanged && dirNode.origin.kind === "repo-tree") {
+		state.setDirtyDirSummary(materializeDirtyDirSummary(summary, dirPath, dirNode.origin.hash));
+		return dirNode.origin.hash;
+	}
+	newEntries.sort((a, b) => a.name.localeCompare(b.name));
+	const treeHash = writeObject(writeSource, {
+		type: "tree",
+		entries: newEntries
+	});
+	state.setDirtyDirSummary(materializeDirtyDirSummary(summary, dirPath, treeHash));
+	return treeHash;
+}
+function collectCompiledEntries(writeSource, readSource, state, dirNode, dirPath, summary, markChanged) {
+	if (dirNode.state.kind !== "directory") throw new Error("collectCompiledEntries called on non-directory node");
+	if (dirNode.origin.kind !== "repo-tree" || summary === null) return listDirectoryChildren(readSource, state, dirNode, dirPath).flatMap((child) => {
+		const observedChild = observeListedDirectoryChild(state, dirPath, child);
+		if (observedChild === null) return [];
+		const entry = compileChildEntry(writeSource, readSource, state, observedChild);
+		if (entry === null) return [];
+		markChanged(entry.changed);
+		return [entry.entry];
+	});
+	const originLookup = createNamedOriginChildLookup(readRepoTree(readSource, dirNode.origin.hash, dirPath).entries);
+	const childPlan = planAffectedDirectoryChildren(originLookup, collectAffectedChildNames(summary));
+	const out = [];
+	for (const planEntry of childPlan) {
+		if (!planEntry.shouldCompile) {
+			if (planEntry.originEntry === null) throw new Error(`collectCompiledEntries: missing origin entry for '${planEntry.name}'`);
+			out.push(planEntry.originEntry);
+			continue;
+		}
+		const compiled = compileNamedChildEntry(writeSource, readSource, state, dirNode, dirPath, planEntry.name, originLookup);
+		if (compiled === null) continue;
+		markChanged(compiled.changed);
+		out.push(compiled.entry);
+	}
+	return out;
+}
+function collectAffectedChildNames(summary) {
+	return new Set(summary.affectedNames);
+}
+function compileNamedChildEntry(writeSource, readSource, state, dirNode, dirPath, name, originLookup) {
+	if (dirNode.state.kind !== "directory") throw new Error("compileNamedChildEntry called on non-directory node");
+	const observedChild = observeNamedDirectoryChild(state, dirNode, dirPath, originLookup, name);
+	if (observedChild === null) return null;
+	return compileChildEntry(writeSource, readSource, state, observedChild);
+}
+function compileChildEntry(writeSource, readSource, state, child) {
+	const node = child.node;
+	if (node.state.kind === "directory") {
+		const newHash = compileDirectory(writeSource, readSource, state, node, child.path);
+		const originHash = node.origin.kind === "repo-tree" ? node.origin.hash : null;
+		return {
+			entry: {
 				mode: "40000",
 				name: child.name,
 				hash: newHash
+			},
+			changed: newHash !== originHash
+		};
+	}
+	if (node.state.kind === "file") {
+		if (node.state.content !== void 0) {
+			const hash = writeObject(writeSource, {
+				type: "blob",
+				content: node.state.content
 			});
-		} else if (node.state.kind === "file") {
-			if (node.state.content !== void 0) {
-				const hash = writeObject(writeSource, {
-					type: "blob",
-					content: node.state.content
-				});
-				anyChanged = true;
-				newEntries.push({
+			return {
+				entry: {
 					mode: node.state.mode,
 					name: child.name,
 					hash
-				});
-			} else if (node.origin.kind === "repo-blob") newEntries.push({
+				},
+				changed: node.origin.kind !== "repo-blob" || hash !== node.origin.hash
+			};
+		}
+		if (node.origin.kind === "repo-blob") return {
+			entry: {
 				mode: node.state.mode,
 				name: child.name,
 				hash: node.origin.hash
-			});
-		} else if (node.state.target !== void 0) {
-			const hash = writeObject(writeSource, {
-				type: "blob",
-				content: node.state.target
-			});
-			anyChanged = true;
-			newEntries.push({
+			},
+			changed: false
+		};
+		return null;
+	}
+	if (node.state.target !== void 0) {
+		const hash = writeObject(writeSource, {
+			type: "blob",
+			content: node.state.target
+		});
+		return {
+			entry: {
 				mode: "120000",
 				name: child.name,
 				hash
-			});
-		} else if (node.origin.kind === "repo-blob") newEntries.push({
+			},
+			changed: node.origin.kind !== "repo-blob" || hash !== node.origin.hash
+		};
+	}
+	if (node.origin.kind === "repo-blob") return {
+		entry: {
 			mode: "120000",
 			name: child.name,
 			hash: node.origin.hash
-		});
-	}
-	if (isDirectoryOverlayDirty(dirNode.state.overlay)) anyChanged = true;
-	if (!anyChanged && dirNode.origin.kind === "repo-tree") return dirNode.origin.hash;
-	newEntries.sort((a, b) => a.name.localeCompare(b.name));
-	return writeObject(writeSource, {
-		type: "tree",
-		entries: newEntries
-	});
+		},
+		changed: false
+	};
+	return null;
 }
 //#endregion
 export { writeTreeFromSession };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nano-git",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "files": [
     "dist"
   ],
@@ -169,6 +169,7 @@
   },
   "scripts": {
     "build": "tsdown",
+    "bench:workdir-diff": "bun run examples/workdir-diff-benchmark.ts",
     "lint": "oxlint .",
     "format": "oxfmt .",
     "format:check": "oxfmt --check .",

package/dist/workdir/change-log.d.mts

@@ -1,25 +0,0 @@
-//#region src/workdir/change-log.d.ts
-/** 内部变更操作（含 revert，公开 API 暂不暴露 revert） */
-type InternalChangeRecord = {
-  readonly op: "add";
-  readonly path: string;
-} | {
-  readonly op: "modify";
-  readonly path: string;
-} | {
-  readonly op: "delete";
-  readonly path: string;
-} | {
-  readonly op: "rename";
-  readonly from: string;
-  readonly to: string;
-} | {
-  readonly op: "copy";
-  readonly from: string;
-  readonly to: string;
-} | {
-  readonly op: "revert";
-  readonly path: string;
-};
-//#endregion
-export { InternalChangeRecord };

package/dist/workdir/change-log.mjs

@@ -1,69 +0,0 @@
-//#region src/workdir/change-log.ts
-/**
-* 创建空的变更日志
-*
-* @example
-* ```ts
-* const log = createVirtualChangeLog();
-* log.append({ op: "add", path: "a.txt" });
-* expect(log.toVirtualChanges()).toEqual([{ path: "a.txt", type: "add" }]);
-* ```
-*/
-function createVirtualChangeLog() {
-	const records = [];
-	return {
-		append(record) {
-			records.push(record);
-		},
-		clear() {
-			records.length = 0;
-		},
-		snapshot() {
-			return records.slice();
-		},
-		toVirtualChanges() {
-			return mapInternalChangesToVirtualChanges(records);
-		}
-	};
-}
-/**
-* 将内部变更记录映射为公开 VirtualChange 列表
-*/
-function mapInternalChangesToVirtualChanges(records) {
-	const out = [];
-	for (const record of records) {
-		const mapped = mapInternalToVirtual(record);
-		if (mapped !== null) out.push(mapped);
-	}
-	return out;
-}
-function mapInternalToVirtual(record) {
-	switch (record.op) {
-		case "add": return {
-			path: record.path,
-			type: "add"
-		};
-		case "modify": return {
-			path: record.path,
-			type: "modify"
-		};
-		case "delete": return {
-			path: record.path,
-			type: "delete"
-		};
-		case "rename": return {
-			path: record.to,
-			type: "rename",
-			oldPath: record.from
-		};
-		case "copy": return {
-			path: record.to,
-			type: "copy",
-			oldPath: record.from
-		};
-		case "revert": return null;
-		default: return record;
-	}
-}
-//#endregion
-export { createVirtualChangeLog, mapInternalChangesToVirtualChanges };

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

@@ -1,17 +0,0 @@
-import { VirtualWorkdirBackend } from "./core.mjs";
-
-//#region src/workdir/memory-backend.d.ts
-/**
- * 创建内存版 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);
- * ```
- */
-declare function createMemoryVirtualWorkdirBackend(): VirtualWorkdirBackend;
-//#endregion
-export { createMemoryVirtualWorkdirBackend };

package/dist/workdir/session-id.mjs

@@ -1,18 +0,0 @@
-//#region src/workdir/session-id.ts
-let nextSessionCounter = 1;
-/**
-* 分配新的 session ID
-*
-* @example
-* ```ts
-* const sessionId = createVirtualWorkdirSessionId();
-* expect(String(sessionId).startsWith("session:")).toBe(true);
-* ```
-*/
-function createVirtualWorkdirSessionId() {
-	const id = `session:${nextSessionCounter}`;
-	nextSessionCounter += 1;
-	return id;
-}
-//#endregion
-export { createVirtualWorkdirSessionId };