@davideasden/pi-undo 0.1.2 → 0.2.1

package/src/snapshot-store.ts

@@ -32,10 +32,16 @@ const GC_RETENTION_MS = 7 * 24 * 60 * 60 * 1_000;
 const IGNORE_POLICY = "git-check-ignore-v1";
 const NULL_DEVICE = process.platform === "win32" ? "NUL" : "/dev/null";
 const TREE_CACHE_LIMIT = 256;
-const HASH_BATCH_MAX_PATHS = 128;
-const HASH_BATCH_MAX_ARGUMENT_BYTES = 24 * 1024;
+const TREE_BLOB_MEMBERSHIP_LIMIT = 65_536;
+const HASH_BATCH_MAX_PATHS = process.platform === "win32" ? 128 : 2_048;
+const HASH_BATCH_MAX_ARGUMENT_BYTES = process.platform === "win32" ? 24 * 1024 : 128 * 1024;
+const HASH_BATCH_CONCURRENCY = 4;
+const FILE_SYSTEM_INSPECTION_CONCURRENCY = 32;
 const INDEX_BATCH_MAX_ENTRIES = 4_096;
 const INDEX_BATCH_MAX_BYTES = 8 * 1024 * 1024;
+const BLOB_CACHE_MAX_BYTES = 128 * 1024 * 1024;
+const BLOB_BATCH_MAX_BYTES = 16 * 1024 * 1024;
+const BLOB_BATCH_MAX_ENTRIES = 256;
 
 interface PinRecord {
 	readonly schemaVersion: 1;
@@ -73,6 +79,11 @@ interface VisibleLeaf {
 	readonly fingerprint: string;
 }
 
+interface CachedBlob {
+	readonly promise: Promise<Uint8Array>;
+	size: number;
+}
+
 export interface SnapshotStoreOptions {
 	readonly storeRoot?: string;
 	readonly git?: GitRunner;
@@ -108,9 +119,9 @@ export interface SnapshotStore {
 	capture(topology: RootTopology, scope?: readonly string[], options?: CaptureOptions): Promise<SnapshotManifest>;
 	listVisibleLeafPaths(topology: RootTopology, options?: CaptureOptions): Promise<readonly string[]>;
 	loadManifest(id: ManifestId): Promise<SnapshotManifest>;
-	assertComplete(id: ManifestId): Promise<void>;
-	listTree(id: ManifestId, root: string): Promise<readonly RestorePath[]>;
-	readBlob(id: ManifestId, root: string, blobId: string): Promise<Uint8Array>;
+	assertComplete(id: ManifestId, scopePaths?: readonly string[]): Promise<void>;
+	listTree(id: ManifestId, root: string, rootScopePaths?: readonly string[]): Promise<readonly RestorePath[]>;
+	readBlob(id: ManifestId, root: string, blobId: string, relativePath?: string): Promise<Uint8Array>;
 	pin(id: ManifestId, reason: string): Promise<void>;
 	unpin(id: ManifestId, reason: string): Promise<void>;
 	collectGarbage(): Promise<number>;
@@ -124,8 +135,11 @@ export class SnapshotStore {
 	private readonly lock: WorkspaceLock;
 	private readonly clock: () => number;
 	private readonly manifestLocations = new Map<string, string>();
-	// Tree ID 是内容寻址且不可变；这里只缓存解析元数据，blob bytes 与完整性仍逐次读取/校验。
+	// Tree 与 blob 都由 object ID 内容寻址；缓存只复用已从私有 ODB 读取的不可变内容。
 	private readonly treeEntriesCache = new Map<string, Promise<CapturedTreeEntry[]>>();
+	private readonly treeBlobMembership = new Map<string, string>();
+	private readonly blobCache = new Map<string, CachedBlob>();
+	private blobCacheBytes = 0;
 
 	constructor(options: SnapshotStoreOptions = {}) {
 		this.storeRoot = resolve(options.storeRoot ?? join(tmpdir(), "pi-undo-snapshot-store"));
@@ -263,15 +277,16 @@ export class SnapshotStore {
 					.filter((candidate) => isStrictRootAncestor(root.relativeRoot, candidate.relativeRoot))
 					.map((candidate) => rootRelativePath(root.relativeRoot, candidate.relativeRoot));
 				const exactExclusions = ownedArtifactExclusions(topology.roots, root.relativeRoot, artifactExclusions);
-				for (const leaf of await this.collectVisibleLeaves(
+				for (const relativePath of await this.queryVisibleLeafPaths(
 					absoluteRoot,
 					environment,
 					root.gitBacked,
 					[],
 					exclusions,
 					exactExclusions,
+					true,
 				)) {
-					result.add(workspaceRelativePath(root.relativeRoot, leaf.relativePath));
+					result.add(workspaceRelativePath(root.relativeRoot, relativePath));
 				}
 			}
 			await this.assertTopology(topology, "可见路径枚举期间 topology 已变化");
@@ -303,7 +318,7 @@ export class SnapshotStore {
 		}
 	}
 
-	async assertComplete(id: ManifestId): Promise<void> {
+	async assertComplete(id: ManifestId, scopePaths?: readonly string[]): Promise<void> {
 		const manifestPath = await this.findManifestPath(id);
 		const manifest = await this.loadManifest(id);
 		const storeDirectory = dirname(dirname(manifestPath));
@@ -322,9 +337,11 @@ export class SnapshotStore {
 					}
 					continue;
 				}
+				const rootScope = rootRelativeScope(root.relativeRoot, scopePaths);
+				if (rootScope !== undefined && rootScope.length === 0) continue;
 				const gitDirectory = this.rootGitDirectory(storeDirectory, root);
 				await this.assertNoAlternates(gitDirectory);
-				const entries = await this.readTreeEntries(gitDirectory, root.treeId);
+				const entries = await this.readTreeEntries(gitDirectory, root.treeId, rootScope);
 				if (root.ignoredPresentPaths.some((ignoredPath) => entries.some(
 					(entry) => isPathAtOrBelow(ignoredPath, entry.relativePath) ||
 						isPathAtOrBelow(entry.relativePath, ignoredPath),
@@ -332,7 +349,8 @@ export class SnapshotStore {
 					throw new SnapshotStoreError("object_missing", "ignored-present proof 与 root tree 冲突");
 				}
 				await this.assertObjectsComplete(gitDirectory, root.treeId, entries);
-				if (root.objectClosure !== treeObjectClosure(root.treeId, entries)) {
+				if (scopePaths !== undefined) await this.preloadBlobBytes(gitDirectory, entries);
+				if (rootScope === undefined && root.objectClosure !== treeObjectClosure(root.treeId, entries)) {
 					throw new SnapshotStoreError("object_missing", "root tree 对象闭包校验失败");
 				}
 			}
@@ -344,7 +362,11 @@ export class SnapshotStore {
 		}
 	}
 
-	async listTree(id: ManifestId, rootPath: string): Promise<readonly RestorePath[]> {
+	async listTree(
+		id: ManifestId,
+		rootPath: string,
+		rootScopePaths?: readonly string[],
+	): Promise<readonly RestorePath[]> {
 		relativeSafePath("/", rootPath);
 		const manifestPath = await this.findManifestPath(id);
 		const manifest = await this.loadManifest(id);
@@ -359,7 +381,7 @@ export class SnapshotStore {
 		const storeDirectory = dirname(dirname(manifestPath));
 		const gitDirectory = this.rootGitDirectory(storeDirectory, root);
 		try {
-			const treeEntries = await this.readTreeEntries(gitDirectory, root.treeId);
+			const treeEntries = await this.readTreeEntries(gitDirectory, root.treeId, rootScopePaths);
 			const directories = new Set<string>();
 			for (const entry of treeEntries) {
 				const parts = entry.relativePath.split("/");
@@ -397,7 +419,12 @@ export class SnapshotStore {
 		}
 	}
 
-	async readBlob(id: ManifestId, rootPath: string, blobId: string): Promise<Uint8Array> {
+	async readBlob(
+		id: ManifestId,
+		rootPath: string,
+		blobId: string,
+		relativePath?: string,
+	): Promise<Uint8Array> {
 		relativeSafePath("/", rootPath);
 		if (!isObjectId(blobId)) {
 			throw new SnapshotStoreError("object_missing", "blob ID 无效");
@@ -415,11 +442,24 @@ export class SnapshotStore {
 		const storeDirectory = dirname(dirname(manifestPath));
 		const gitDirectory = this.rootGitDirectory(storeDirectory, root);
 		try {
-			const entries = await this.readTreeEntries(gitDirectory, root.treeId);
-			if (!entries.some((entry) => entry.objectId === blobId)) {
-				throw new SnapshotStoreError("object_missing", "blob 不属于指定 root tree");
+			const safeRelativePath = relativePath === undefined ? undefined : relativeSafePath("/", relativePath);
+			if (safeRelativePath === undefined) {
+				const entries = await this.readTreeEntries(gitDirectory, root.treeId);
+				if (!entries.some((entry) => entry.objectId === blobId)) {
+					throw new SnapshotStoreError("object_missing", "blob 不属于指定 root tree");
+				}
+			} else {
+				const membershipKey = treeBlobMembershipKey(gitDirectory, root.treeId, safeRelativePath);
+				let ownedBlobId = this.treeBlobMembership.get(membershipKey);
+				if (ownedBlobId === undefined) {
+					await this.readTreeEntries(gitDirectory, root.treeId, [safeRelativePath]);
+					ownedBlobId = this.treeBlobMembership.get(membershipKey);
+				}
+				if (ownedBlobId !== blobId) {
+					throw new SnapshotStoreError("object_missing", "blob 不属于指定 root tree path");
+				}
 			}
-			return await this.readBlobBytes(gitDirectory, blobId);
+			return new Uint8Array(await this.readBlobBytes(gitDirectory, blobId));
 		} catch (error) {
 			if (error instanceof SnapshotStoreError) {
 				throw error;
@@ -650,8 +690,10 @@ export class SnapshotStore {
 			exactExclusions,
 		);
 		const objectIds = new Map<string, string>();
-		for (const batch of hashPathBatches(leaves.filter((leaf) => leaf.kind === "file"))) {
-			for (const leaf of batch) await this.assertVisibleLeafUnchanged(cwd, leaf);
+		const hashBatches = hashPathBatches(leaves.filter((leaf) => leaf.kind === "file"));
+		const hashedBatches = await mapConcurrentOrdered(hashBatches, HASH_BATCH_CONCURRENCY, async (batch) => {
+			await mapConcurrentOrdered(batch, FILE_SYSTEM_INSPECTION_CONCURRENCY, (leaf) =>
+				this.assertVisibleLeafUnchanged(cwd, leaf));
 			const output = await this.runGit([
 				"hash-object",
 				"-w",
@@ -660,10 +702,12 @@ export class SnapshotStore {
 				...batch.map((leaf) => leaf.relativePath),
 			], { cwd, env: environment });
 			const hashes = parseObjectIdLines(output, batch.length);
-			for (const leaf of batch) await this.assertVisibleLeafUnchanged(cwd, leaf);
-			for (let index = 0; index < batch.length; index += 1) {
-				objectIds.set(batch[index]!.relativePath, hashes[index]!);
-			}
+			await mapConcurrentOrdered(batch, FILE_SYSTEM_INSPECTION_CONCURRENCY, (leaf) =>
+				this.assertVisibleLeafUnchanged(cwd, leaf));
+			return batch.map((leaf, index) => [leaf.relativePath, hashes[index]!] as const);
+		});
+		for (const batch of hashedBatches) {
+			for (const [relativePath, objectId] of batch) objectIds.set(relativePath, objectId);
 		}
 		for (const leaf of leaves) {
 			if (leaf.kind !== "symlink") continue;
@@ -701,60 +745,92 @@ export class SnapshotStore {
 		}
 	}
 
-	private async collectVisibleLeaves(
+	private async queryVisibleLeafPaths(
 		cwd: string,
 		environment: Readonly<Record<string, string | undefined>>,
 		gitBacked: boolean,
 		inclusions: readonly string[] | null,
 		exclusions: readonly string[],
 		exactExclusions: readonly string[],
-	): Promise<VisibleLeaf[]> {
+		excludeDeleted = false,
+	): Promise<string[]> {
 		if (inclusions === null) return [];
 		const pathspecs = inclusions.length === 0 ? ["."] : inclusions.map(literalPathspec);
 		for (const excluded of exclusions) pathspecs.push(excludeLiteralPathspec(excluded));
 		const queryEnvironment = gitBacked ? sourceGitEnvironment() : environment;
-		const output = await this.runGitBytes([
-			...(gitBacked ? ["-c", "core.fsmonitor=false"] : []),
-			"ls-files",
-			...(gitBacked ? ["--cached"] : []),
-			"--others",
-			"--exclude-standard",
-			"-z",
-			"--",
-			...pathspecs,
-		], { cwd, env: queryEnvironment });
-		const result: VisibleLeaf[] = [];
-		for (const relativePath of parseNulPaths(output)) {
-			if (
-				exclusions.some((excluded) => isPathAtOrBelow(excluded, relativePath)) ||
-				exactExclusions.includes(relativePath)
-			) continue;
+		const [output, deletedOutput] = await Promise.all([
+			this.runGitBytes([
+				...(gitBacked ? ["-c", "core.fsmonitor=false"] : []),
+				"ls-files",
+				...(gitBacked ? ["--cached"] : []),
+				"--others",
+				"--exclude-standard",
+				"-z",
+				"--",
+				...pathspecs,
+			], { cwd, env: queryEnvironment }),
+			gitBacked && excludeDeleted
+				? this.runGitBytes([
+					"-c",
+					"core.fsmonitor=false",
+					"ls-files",
+					"--deleted",
+					"-z",
+					"--",
+					...pathspecs,
+				], { cwd, env: queryEnvironment })
+				: Promise.resolve(new Uint8Array()),
+		]);
+		const deletedPaths = new Set(parseNulPaths(deletedOutput));
+		return parseNulPaths(output).filter((relativePath) =>
+			!deletedPaths.has(relativePath) &&
+			!exclusions.some((excluded) => isPathAtOrBelow(excluded, relativePath)) &&
+			!exactExclusions.includes(relativePath));
+	}
+
+	private async collectVisibleLeaves(
+		cwd: string,
+		environment: Readonly<Record<string, string | undefined>>,
+		gitBacked: boolean,
+		inclusions: readonly string[] | null,
+		exclusions: readonly string[],
+		exactExclusions: readonly string[],
+	): Promise<VisibleLeaf[]> {
+		const paths = await this.queryVisibleLeafPaths(
+			cwd,
+			environment,
+			gitBacked,
+			inclusions,
+			exclusions,
+			exactExclusions,
+		);
+		const leaves = await mapConcurrentOrdered(paths, FILE_SYSTEM_INSPECTION_CONCURRENCY, async (relativePath) => {
 			relativeSafePath(cwd, relativePath);
 			await assertNoSymlinkEscape(cwd, relativePath);
 			const metadata = await lstat(join(cwd, ...relativePath.split("/"))).catch((error) => {
 				if (hasErrorCode(error, "ENOENT")) return null;
 				throw error;
 			});
-			if (metadata === null) continue;
+			if (metadata === null) return null;
 			if (metadata.isSymbolicLink()) {
-				result.push({
+				return {
 					relativePath,
-					kind: "symlink",
+					kind: "symlink" as const,
 					mode: 0o120000,
 					fingerprint: visibleLeafFingerprint(metadata),
-				});
-			} else if (metadata.isFile()) {
-				result.push({
+				};
+			}
+			if (metadata.isFile()) {
+				return {
 					relativePath,
-					kind: "file",
+					kind: "file" as const,
 					mode: (metadata.mode & 0o111) === 0 ? 0o100644 : 0o100755,
 					fingerprint: visibleLeafFingerprint(metadata),
-				});
-			} else {
-				throw new SnapshotStoreError("capture_failed", `不支持的工作区文件类型：${relativePath}`);
+				};
 			}
-		}
-		return result;
+			throw new SnapshotStoreError("capture_failed", `不支持的工作区文件类型：${relativePath}`);
+		});
+		return leaves.filter((leaf): leaf is VisibleLeaf => leaf !== null);
 	}
 
 	private async validateIgnoreQuery(
@@ -812,12 +888,38 @@ export class SnapshotStore {
 		}
 	}
 
-	private async readTreeEntries(gitDirectory: string, treeId: string): Promise<CapturedTreeEntry[]> {
-		const key = `${gitDirectory}\0${treeId}`;
+	private async readTreeEntries(
+		gitDirectory: string,
+		treeId: string,
+		rootScopePaths?: readonly string[],
+	): Promise<CapturedTreeEntry[]> {
+		const scope = rootScopePaths === undefined
+			? undefined
+			: [...new Set(rootScopePaths.map((path) => relativeSafePath("/", path)))].sort(comparePaths);
+		const key = `${gitDirectory}\0${treeId}\0${scope === undefined ? "*" : checksum(canonicalJson(scope))}`;
 		const cached = this.treeEntriesCache.get(key);
 		if (cached !== undefined) return cached;
-		const pending = this.runPrivateGitBytes(gitDirectory, ["ls-tree", "-r", "-l", "-z", treeId])
-			.then(parseTreeEntries);
+		const pending = this.runPrivateGitBytes(gitDirectory, [
+			"ls-tree",
+			"-r",
+			"-l",
+			"-z",
+			treeId,
+			...(scope === undefined ? [] : ["--", ...scope.map(literalPathspec)]),
+		]).then((output) => {
+			const entries = parseTreeEntries(output);
+			for (const entry of entries) {
+				const membershipKey = treeBlobMembershipKey(gitDirectory, treeId, entry.relativePath);
+				this.treeBlobMembership.delete(membershipKey);
+				this.treeBlobMembership.set(membershipKey, entry.objectId);
+			}
+			while (this.treeBlobMembership.size > TREE_BLOB_MEMBERSHIP_LIMIT) {
+				const oldest = this.treeBlobMembership.keys().next().value as string | undefined;
+				if (oldest === undefined) break;
+				this.treeBlobMembership.delete(oldest);
+			}
+			return entries;
+		});
 		this.treeEntriesCache.set(key, pending);
 		while (this.treeEntriesCache.size > TREE_CACHE_LIMIT) {
 			const oldest = this.treeEntriesCache.keys().next().value as string | undefined;
@@ -861,6 +963,26 @@ export class SnapshotStore {
 		}
 	}
 
+	private async preloadBlobBytes(
+		gitDirectory: string,
+		entries: readonly CapturedTreeEntry[],
+	): Promise<void> {
+		const unique = new Map<string, CapturedTreeEntry>();
+		for (const entry of entries) {
+			if (!this.blobCache.has(blobCacheKey(gitDirectory, entry.objectId))) unique.set(entry.objectId, entry);
+		}
+		for (const batch of blobReadBatches([...unique.values()])) {
+			const loaded = parseBatchBlobOutput(
+				await this.runGitBytes(["cat-file", "--batch"], {
+					env: privateObjectEnvironment(gitDirectory),
+					stdin: `${batch.map((entry) => entry.objectId).join("\n")}\n`,
+				}),
+				batch,
+			);
+			for (const [objectId, bytes] of loaded) this.rememberBlobBytes(gitDirectory, objectId, bytes);
+		}
+	}
+
 	private async readBlobText(gitDirectory: string, objectId: string): Promise<string> {
 		return decodeUtf8(
 			await this.readBlobBytes(gitDirectory, objectId),
@@ -869,7 +991,51 @@ export class SnapshotStore {
 	}
 
 	private async readBlobBytes(gitDirectory: string, objectId: string): Promise<Uint8Array> {
-		return this.runPrivateGitBytes(gitDirectory, ["cat-file", "blob", objectId]);
+		const key = blobCacheKey(gitDirectory, objectId);
+		const cached = this.blobCache.get(key);
+		if (cached !== undefined) {
+			this.blobCache.delete(key);
+			this.blobCache.set(key, cached);
+			return cached.promise;
+		}
+		const entry: CachedBlob = {
+			promise: this.runPrivateGitBytes(gitDirectory, ["cat-file", "blob", objectId]),
+			size: 0,
+		};
+		this.blobCache.set(key, entry);
+		try {
+			const bytes = await entry.promise;
+			this.finishBlobCacheEntry(key, entry, bytes.byteLength);
+			return bytes;
+		} catch (error) {
+			if (this.blobCache.get(key) === entry) this.blobCache.delete(key);
+			throw error;
+		}
+	}
+
+	private rememberBlobBytes(gitDirectory: string, objectId: string, bytes: Uint8Array): void {
+		const key = blobCacheKey(gitDirectory, objectId);
+		if (this.blobCache.has(key) || bytes.byteLength > BLOB_CACHE_MAX_BYTES) return;
+		const entry: CachedBlob = { promise: Promise.resolve(bytes), size: 0 };
+		this.blobCache.set(key, entry);
+		this.finishBlobCacheEntry(key, entry, bytes.byteLength);
+	}
+
+	private finishBlobCacheEntry(key: string, entry: CachedBlob, size: number): void {
+		if (this.blobCache.get(key) !== entry) return;
+		if (size > BLOB_CACHE_MAX_BYTES) {
+			this.blobCache.delete(key);
+			return;
+		}
+		entry.size = size;
+		this.blobCacheBytes += size;
+		while (this.blobCacheBytes > BLOB_CACHE_MAX_BYTES) {
+			const oldestKey = this.blobCache.keys().next().value as string | undefined;
+			if (oldestKey === undefined) break;
+			const oldest = this.blobCache.get(oldestKey)!;
+			this.blobCache.delete(oldestKey);
+			this.blobCacheBytes -= oldest.size;
+		}
 	}
 
 	private runPrivateGit(gitDirectory: string, args: readonly string[]): Promise<string> {
@@ -991,7 +1157,7 @@ export class SnapshotStore {
 }
 
 function captureCoverage(workspaceIdentity: string, scope: readonly string[] | undefined): string {
-	if (scope === undefined || scope.length === 0) {
+	if (scope === undefined) {
 		return COMPLETE_COVERAGE;
 	}
 	const paths = [...new Set(scope.map((path) => relativeSafePath(workspaceIdentity, path)))].sort(comparePaths);
@@ -1041,10 +1207,15 @@ function ownedArtifactExclusions(
 	return result;
 }
 
+function rootRelativeScope(rootPath: string, scope: readonly string[] | undefined): string[] | undefined {
+	const inclusions = rootScopePathspecs(rootPath, scope);
+	if (inclusions === null) return [];
+	return inclusions.length === 0 ? undefined : inclusions;
+}
+
 function rootScopePathspecs(rootPath: string, scope: readonly string[] | undefined): string[] | null {
-	if (scope === undefined || scope.length === 0) {
-		return [];
-	}
+	if (scope === undefined) return [];
+	if (scope.length === 0) return null;
 	const result = new Set<string>();
 	for (const path of scope) {
 		if (path === "." || path === rootPath || isStrictRootAncestor(path, rootPath)) {
@@ -1234,6 +1405,62 @@ function isolatedGitConfiguration(): Readonly<Record<string, string | undefined>
 	};
 }
 
+function treeBlobMembershipKey(gitDirectory: string, treeId: string, relativePath: string): string {
+	return `${gitDirectory}\0${treeId}\0${relativePath}`;
+}
+
+function blobCacheKey(gitDirectory: string, objectId: string): string {
+	return `${gitDirectory}\0${objectId}`;
+}
+
+function blobReadBatches(entries: readonly CapturedTreeEntry[]): CapturedTreeEntry[][] {
+	const result: CapturedTreeEntry[][] = [];
+	let batch: CapturedTreeEntry[] = [];
+	let bytes = 0;
+	for (const entry of entries) {
+		if (
+			batch.length > 0 &&
+			(batch.length >= BLOB_BATCH_MAX_ENTRIES || bytes + entry.size > BLOB_BATCH_MAX_BYTES)
+		) {
+			result.push(batch);
+			batch = [];
+			bytes = 0;
+		}
+		batch.push(entry);
+		bytes += entry.size;
+	}
+	if (batch.length > 0) result.push(batch);
+	return result;
+}
+
+function parseBatchBlobOutput(
+	output: Uint8Array,
+	expected: readonly CapturedTreeEntry[],
+): Map<string, Uint8Array> {
+	const result = new Map<string, Uint8Array>();
+	let offset = 0;
+	for (const entry of expected) {
+		const lineEnd = output.indexOf(0x0a, offset);
+		if (lineEnd < 0) throw new SnapshotStoreError("object_missing", "Git blob batch header 不完整");
+		const header = decodeUtf8(output.subarray(offset, lineEnd));
+		const match = header.match(/^([0-9a-f]{40,64}) blob ([0-9]+)$/);
+		if (match === null || match[1] !== entry.objectId || Number(match[2]) !== entry.size) {
+			throw new SnapshotStoreError("object_missing", `Git blob batch header 无效：${entry.objectId}`);
+		}
+		const contentStart = lineEnd + 1;
+		const contentEnd = contentStart + entry.size;
+		if (contentEnd >= output.length || output[contentEnd] !== 0x0a) {
+			throw new SnapshotStoreError("object_missing", `Git blob batch 内容不完整：${entry.objectId}`);
+		}
+		result.set(entry.objectId, output.slice(contentStart, contentEnd));
+		offset = contentEnd + 1;
+	}
+	if (offset !== output.length) {
+		throw new SnapshotStoreError("object_missing", "Git blob batch 输出包含多余内容");
+	}
+	return result;
+}
+
 function indexInfoBatches(
 	leaves: readonly VisibleLeaf[],
 	objectIds: ReadonlyMap<string, string>,
@@ -1275,6 +1502,32 @@ function visibleLeafFingerprint(metadata: Stats): string {
 	}));
 }
 
+async function mapConcurrentOrdered<T, R>(
+	values: readonly T[],
+	concurrency: number,
+	operation: (value: T) => Promise<R>,
+): Promise<R[]> {
+	const result = new Array<R>(values.length);
+	let nextIndex = 0;
+	let failed = false;
+	let failure: unknown;
+	async function worker(): Promise<void> {
+		while (!failed && nextIndex < values.length) {
+			const index = nextIndex;
+			nextIndex += 1;
+			try {
+				result[index] = await operation(values[index]!);
+			} catch (error) {
+				if (!failed) failure = error;
+				failed = true;
+			}
+		}
+	}
+	await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, () => worker()));
+	if (failed) throw failure;
+	return result;
+}
+
 function hashPathBatches(leaves: readonly VisibleLeaf[]): VisibleLeaf[][] {
 	const result: VisibleLeaf[][] = [];
 	let current: VisibleLeaf[] = [];

package/src/status-reporter.ts

@@ -43,9 +43,12 @@ export class StatusReporter {
 		this.context.ui.setStatus("pi-undo", undefined);
 	}
 
-	result(result: OperationResult): void {
+	result(result: OperationResult, totalMs?: number): void {
 		const details = result.message === undefined ? "" : ` ${sanitize(result.message)}`;
-		const message = sanitize(`${result.code} files:${result.changedFiles}${details}`);
+		const timing = totalMs !== undefined && totalMs >= 1_000
+			? formatTiming(totalMs, result.timings)
+			: "";
+		const message = sanitize(`${result.code} files:${result.changedFiles}${details}${timing}`);
 		const type = result.code === "ok" || result.code === "noop"
 			? "info"
 			: result.code === "recovery_required" ? "error" : "warning";
@@ -68,6 +71,16 @@ export class StatusReporter {
 	}
 }
 
+function formatTiming(totalMs: number, timings: OperationResult["timings"]): string {
+	const phases = [...(timings ?? [])]
+		.filter((timing) => timing.durationMs >= 5)
+		.sort((left, right) => right.durationMs - left.durationMs)
+		.slice(0, 5)
+		.map((timing) => `${timing.phase}:${timing.durationMs}ms`)
+		.join(" ");
+	return ` total:${Math.round(totalMs)}ms${phases.length === 0 ? "" : ` ${phases}`}`;
+}
+
 function sanitize(value: string): string {
 	return value
 		.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "")