@davideasden/pi-undo 0.2.17 → 0.2.18

package/package.json

@@ -1,7 +1,8 @@
 {
 	"name": "@davideasden/pi-undo",
-	"version": "0.2.17",
+	"version": "0.2.18",
 	"description": "Persistent workspace undo and redo for Pi",
+	"license": "MIT",
 	"type": "module",
 	"keywords": [
 		"pi-package",

package/src/durable-pack.ts

@@ -1,4 +1,4 @@
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { copyFile, link, lstat, open, readFile, rename, rm, type FileHandle } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 
@@ -194,7 +194,12 @@ export async function createDurablePack(
 		await rm(temporary, { force: true }).catch(() => {});
 		throw error;
 	}
-	const packChecksum = checksum(Buffer.concat([MAGIC, lengthBytes, headerBytes, ...payloads]));
+	const digest = createHash("sha256");
+	digest.update(MAGIC);
+	digest.update(lengthBytes);
+	digest.update(headerBytes);
+	for (const payload of payloads) digest.update(payload);
+	const packChecksum = digest.digest("hex");
 	return durablePackFromInput(input.opId, input.planDigest, packPath, packChecksum, entries);
 }
 

package/src/restore-engine.ts

@@ -38,6 +38,7 @@ const PREPARED_PLAN_CACHE_LIMIT = 16;
 const RESTORE_FILE_BATCH_MAX_ENTRIES = 1_024;
 const RESTORE_FILE_BATCH_MAX_BYTES = 64 * 1024 * 1024;
 const RESTORE_FILE_PREPARE_CONCURRENCY = 32;
+const RESTORE_FILE_VERIFY_CONCURRENCY = 32;
 
 export interface RestorePlan {
 	currentManifestId: ManifestId;
@@ -519,7 +520,13 @@ export class RestoreEngine {
 			return { code: "recovery_required", verifiedPaths: 0, totalPaths: currentPaths.size };
 		}
 		try {
-			await this.assertCompleteVisibleSubset(topologyBefore, [current, target], options.mutationJournal);
+			await this.assertCompleteVisibleSubset(
+				topologyBefore,
+				[current, target],
+				options.mutationJournal,
+				[],
+				this.completeCoverageOwnedPaths(plan.scopePaths, [currentPaths, targetPaths]),
+			);
 		} catch {
 			return { code: "restore_failed_safe", verifiedPaths: 0, totalPaths: 0 };
 		}
@@ -588,6 +595,11 @@ export class RestoreEngine {
 			);
 			return result;
 		}
+		try {
+			await this.prefetchCompleteRestoreBlobs(plan, current, target, currentPaths, targetPaths);
+		} catch {
+			// 预取是性能优化；失败时继续走原有逐文件校验和可恢复 mutation 路径。
+		}
 		const preflight = await this.verifyKnownState(current, target, currentPaths, targetPaths, plan.scopePaths);
 		if (!preflight.ok) {
 			return {
@@ -625,7 +637,13 @@ export class RestoreEngine {
 
 			const topologyAfter = await this.discovery.discover(this.workspaceRoot);
 			assertUnchangedTopology(topologyBefore, topologyAfter);
-			await this.assertCompleteVisibleSubset(topologyAfter, [target], options.mutationJournal);
+			await this.assertCompleteVisibleSubset(
+				topologyAfter,
+				[target],
+				options.mutationJournal,
+				[],
+				this.completeCoverageOwnedPaths(plan.scopePaths, [targetPaths]),
+			);
 			const verification = await this.verifyTarget(
 				target,
 				currentPaths,
@@ -702,6 +720,7 @@ export class RestoreEngine {
 						? []
 						: [artifacts.source, ...(artifacts.target === null ? [] : [artifacts.target])];
 				}),
+				this.completeCoverageOwnedPaths(plan.scopePaths, [targetPaths]),
 			);
 			const totalPaths = plan.deletePaths.length + plan.writePaths.length;
 			if ((await options.mutationJournal.load()).length !== 0) {
@@ -887,6 +906,41 @@ export class RestoreEngine {
 		return result;
 	}
 
+	private completeCoverageOwnedPaths(
+		scopePaths: readonly string[] | undefined,
+		ownedPaths: readonly ReadonlyMap<string, OwnedPath>[],
+	): readonly ReadonlyMap<string, OwnedPath>[] | undefined {
+		return scopePaths === undefined ? ownedPaths : undefined;
+	}
+
+	private async prefetchCompleteRestoreBlobs(
+		plan: RestorePlan,
+		current: SnapshotManifest,
+		target: SnapshotManifest,
+		currentPaths: ReadonlyMap<string, OwnedPath>,
+		targetPaths: ReadonlyMap<string, OwnedPath>,
+	): Promise<void> {
+		if (plan.scopePaths !== undefined || !SnapshotStore.supportsValidatedBlobBatch(this.store)) return;
+		const requestsFor = (paths: ReadonlyMap<string, OwnedPath>, extraPaths: readonly string[] = []) => {
+			const requests = [];
+			const requested = new Set([...plan.writePaths, ...extraPaths]);
+			for (const path of requested) {
+				const owned = paths.get(path);
+				if (owned === undefined || owned.entry.kind !== "file" || owned.entry.blobId === null) continue;
+				requests.push({
+					rootPath: owned.root.relativeRoot,
+					blobId: owned.entry.blobId,
+					relativePath: owned.entry.relativePath,
+				});
+			}
+			return requests;
+		};
+		await Promise.all([
+			this.store.prefetchBlobs(current.manifestId, requestsFor(currentPaths, plan.deletePaths)),
+			this.store.prefetchBlobs(target.manifestId, requestsFor(targetPaths)),
+		]);
+	}
+
 	private assertCurrentTopology(
 		current: SnapshotManifest,
 		target: SnapshotManifest,
@@ -926,12 +980,13 @@ export class RestoreEngine {
 		const paths = [...new Set([...currentPaths.keys(), ...targetPaths.keys()])]
 			.filter((path) => scope === undefined || scope.has(path))
 			.sort(comparePaths);
-		let verifiedPaths = 0;
-		for (const path of paths) {
-			if (await this.pathIsShadowedByTarget(target.manifestId, path, targetPaths)) {
-				verifiedPaths += 1;
-				continue;
-			}
+		const results: Array<boolean | undefined> = new Array(paths.length);
+		let nextIndex = 0;
+		let stop = false;
+		let failure: unknown;
+		let failureIndex: number | undefined;
+		const verifyPath = async (path: string): Promise<boolean> => {
+			if (await this.pathIsShadowedByTarget(target.manifestId, path, targetPaths)) return true;
 			const currentPath = currentPaths.get(path);
 			const targetPath = targetPaths.get(path);
 			const matchesCurrent = currentPath !== undefined &&
@@ -941,7 +996,37 @@ export class RestoreEngine {
 			const matchesAbsentSide = !matchesCurrent && !matchesTarget &&
 				(currentPath === undefined || targetPath === undefined) &&
 				await this.pathIsAbsent(path);
-			if (!matchesCurrent && !matchesTarget && !matchesAbsentSide) {
+			return matchesCurrent || matchesTarget || matchesAbsentSide;
+		};
+		const worker = async (): Promise<void> => {
+			while (!stop && nextIndex < paths.length) {
+				const index = nextIndex;
+				nextIndex += 1;
+				try {
+					const ok = await verifyPath(paths[index]!);
+					results[index] = ok;
+					if (!ok) stop = true;
+				} catch (error) {
+					if (failureIndex === undefined || index < failureIndex) {
+						failure = error;
+						failureIndex = index;
+					}
+					stop = true;
+				}
+			}
+		};
+		if (paths.length > 0) {
+			await Promise.all(Array.from(
+				{ length: Math.min(RESTORE_FILE_VERIFY_CONCURRENCY, paths.length) },
+				() => worker(),
+			));
+		}
+		let verifiedPaths = 0;
+		for (let index = 0; index < results.length; index += 1) {
+			const ok = results[index];
+			if (ok === false) return { ok: false, verifiedPaths, totalPaths: paths.length };
+			if (ok === undefined) {
+				if (failureIndex === index && failure !== undefined) throw failure;
 				return { ok: false, verifiedPaths, totalPaths: paths.length };
 			}
 			verifiedPaths += 1;
@@ -1168,7 +1253,13 @@ export class RestoreEngine {
 			await this.writePlannedPaths(current.manifestId, currentPaths, rollbackPlan.writePaths, context);
 			const topologyAfter = await this.discovery.discover(this.workspaceRoot);
 			assertUnchangedTopology(topologyBefore, topologyAfter);
-			await this.assertCompleteVisibleSubset(topologyAfter, [current], options.mutationJournal);
+			await this.assertCompleteVisibleSubset(
+				topologyAfter,
+				[current],
+				options.mutationJournal,
+				[],
+				this.completeCoverageOwnedPaths(scopePaths, [currentPaths]),
+			);
 			const verification = await this.verifyTarget(
 				current,
 				targetPaths,
@@ -1205,7 +1296,13 @@ export class RestoreEngine {
 				try {
 					const topologyAfter = await this.discovery.discover(this.workspaceRoot);
 					assertUnchangedTopology(topologyBefore, topologyAfter);
-					await this.assertCompleteVisibleSubset(topologyAfter, [current], options.mutationJournal);
+					await this.assertCompleteVisibleSubset(
+						topologyAfter,
+						[current],
+						options.mutationJournal,
+						[],
+						this.completeCoverageOwnedPaths(scopePaths, [currentPaths]),
+					);
 					const verification = await this.verifyTarget(
 						current,
 						targetPaths,
@@ -1397,16 +1494,17 @@ export class RestoreEngine {
 		allowedManifests: readonly SnapshotManifest[],
 		mutationJournal?: MutationJournal,
 		extraExclusions: readonly string[] = [],
+		ownedPaths?: readonly (ReadonlyMap<string, OwnedPath> | undefined)[],
 	): Promise<void> {
 		if (allowedManifests.some((manifest) => manifest.coverage !== "complete")) {
 			return;
 		}
 		const allowedPaths = new Set<string>();
-		for (const manifest of allowedManifests) {
+		for (const [index, manifest] of allowedManifests.entries()) {
 			for (const path of ignoredWorkspacePaths(manifest)) {
 				allowedPaths.add(path);
 			}
-			const paths = await this.readOwnedPaths(manifest);
+			const paths = ownedPaths?.[index] ?? await this.readOwnedPaths(manifest);
 			for (const [path, owned] of paths) {
 				if (owned.entry.kind !== "directory") {
 					allowedPaths.add(path);
@@ -1435,23 +1533,18 @@ export class RestoreEngine {
 		deletePaths: readonly string[],
 		scopePaths?: readonly string[],
 	): Promise<{ verifiedPaths: number; totalPaths: number; pathFingerprints: string[] }> {
-		const pathFingerprints: string[] = [];
 		const scope = scopePaths === undefined ? undefined : new Set(scopePaths);
-		for (const [path, owned] of targetPaths) {
-			if (scope !== undefined && !scope.has(path)) continue;
-			pathFingerprints.push(await this.verifyEntry(target.manifestId, owned));
-		}
-		let verifiedPaths = pathFingerprints.length;
-		let totalPaths = pathFingerprints.length;
-		for (const path of deletePaths) {
-			if (
-				targetPaths.has(path) ||
-				currentPaths.get(path)?.entry.kind === "directory" ||
-				hasNonDirectoryAncestor(path, targetPaths)
-			) {
-				continue;
-			}
-			totalPaths += 1;
+		const scopedTargets = [...targetPaths].filter(([path]) => scope === undefined || scope.has(path));
+		const pathFingerprints = await mapConcurrentOrdered(
+			scopedTargets,
+			RESTORE_FILE_VERIFY_CONCURRENCY,
+			([, owned]) => this.verifyEntry(target.manifestId, owned),
+		);
+		const remainingDeletes = deletePaths.filter((path) =>
+			!targetPaths.has(path) &&
+			currentPaths.get(path)?.entry.kind !== "directory" &&
+			!hasNonDirectoryAncestor(path, targetPaths));
+		await mapConcurrentOrdered(remainingDeletes, RESTORE_FILE_VERIFY_CONCURRENCY, async (path) => {
 			try {
 				await lstat(this.absolutePath(path));
 				throw new Error(`目标应删除的路径仍然存在：${path}`);
@@ -1460,11 +1553,10 @@ export class RestoreEngine {
 					throw error;
 				}
 			}
-			verifiedPaths += 1;
-		}
+		});
 		return {
-			verifiedPaths,
-			totalPaths,
+			verifiedPaths: pathFingerprints.length + remainingDeletes.length,
+			totalPaths: pathFingerprints.length + remainingDeletes.length,
 			pathFingerprints,
 		};
 	}

package/src/snapshot-store.ts

@@ -210,6 +210,8 @@ export class SnapshotStore {
 	private readonly blobCache = new Map<string, CachedBlob>();
 	private readonly visibleLeafCache = new Map<string, Map<string, CachedVisibleLeaf>>();
 	private readonly leafCacheDirectoriesLoaded = new Set<string>();
+	private readonly configuredPrivateRepositories = new Set<string>();
+	private readonly leafCacheDirtyDirectories = new Set<string>();
 	private blobCacheBytes = 0;
 
 	constructor(options: SnapshotStoreOptions = {}) {
@@ -741,6 +743,61 @@ export class SnapshotStore {
 		return (await this.readBlobOperation(id, [{ rootPath, blobId, relativePath }], false))[0]!;
 	}
 
+	/** 按 root 批量预取普通文件 blob；membership 与 manifest 校验仍走只读路径。 */
+	async prefetchBlobs(id: ManifestId, requests: readonly SnapshotBlobRequest[]): Promise<void> {
+		if (requests.length === 0) return;
+		for (const request of requests) {
+			relativeSafePath("/", request.rootPath);
+			if (!isObjectId(request.blobId)) {
+				throw new SnapshotStoreError("object_missing", "blob ID 无效");
+			}
+			if (request.relativePath === undefined) {
+				throw new SnapshotStoreError("object_missing", "blob 预取必须提供 root-relative path");
+			}
+		}
+		const manifestPath = await this.findManifestPath(id);
+		const manifest = await this.loadManifest(id);
+		const roots = new Map(manifest.roots.map((root) => [root.relativeRoot, root]));
+		const storeDirectory = dirname(dirname(manifestPath));
+		const byRoot = new Map<string, SnapshotBlobRequest[]>();
+		for (const request of requests) {
+			const grouped = byRoot.get(request.rootPath) ?? [];
+			grouped.push(request);
+			byRoot.set(request.rootPath, grouped);
+		}
+		try {
+			const grouped = new Map<string, Map<string, CapturedTreeEntry>>();
+			for (const [rootPath, rootRequests] of byRoot) {
+				const root = roots.get(rootPath);
+				if (root === undefined) {
+					throw new SnapshotStoreError("root_not_found", "manifest 中不存在指定 root");
+				}
+				if (root.state !== "active" || root.treeId === null) {
+					throw new SnapshotStoreError("object_missing", "指定 root 没有可读取的 tree");
+				}
+				const gitDirectory = this.rootGitDirectory(storeDirectory, root);
+				const entries = await this.readTreeEntries(gitDirectory, root.treeId);
+				const byPath = new Map(entries.map((entry) => [entry.relativePath, entry]));
+				const unique = grouped.get(gitDirectory) ?? new Map<string, CapturedTreeEntry>();
+				for (const request of rootRequests) {
+					const safeRelativePath = relativeSafePath("/", request.relativePath!);
+					const entry = byPath.get(safeRelativePath);
+					if (entry === undefined || entry.objectId !== request.blobId) {
+						throw new SnapshotStoreError("object_missing", "blob 不属于指定 root tree path");
+					}
+					unique.set(entry.objectId, entry);
+				}
+				grouped.set(gitDirectory, unique);
+			}
+			for (const [gitDirectory, unique] of grouped) {
+				await this.preloadBlobBytes(gitDirectory, [...unique.values()]);
+			}
+		} catch (error) {
+			if (error instanceof SnapshotStoreError) throw error;
+			throw new SnapshotStoreError("object_missing", "blob 无法预取", { cause: error });
+		}
+	}
+
 	private readBlobsValidated(
 		id: ManifestId,
 		requests: readonly SnapshotBlobRequest[],
@@ -1155,9 +1212,10 @@ export class SnapshotStore {
 
 	private rememberVisibleLeaves(update: VisibleLeafCacheUpdate): void {
 		const { gitDirectory, staged, inclusions } = update;
+		const previous = this.visibleLeafCache.get(gitDirectory);
 		const cache = inclusions !== null && inclusions.length === 0
 			? new Map<string, CachedVisibleLeaf>()
-			: new Map(this.visibleLeafCache.get(gitDirectory));
+			: new Map(previous);
 		if (inclusions !== null && inclusions.length > 0) {
 			for (const relativePath of cache.keys()) {
 				if (inclusions.some((inclusion) => isPathAtOrBelow(inclusion, relativePath))) {
@@ -1174,6 +1232,9 @@ export class SnapshotStore {
 			}
 			cache.set(leaf.relativePath, { ...leaf, objectId, verifiedAtNs: staged.verifiedAtNs });
 		}
+		if (!samePersistedLeafCache(previous, cache)) {
+			this.leafCacheDirtyDirectories.add(storeDirectoryForGitDirectory(gitDirectory));
+		}
 		this.visibleLeafCache.set(gitDirectory, cache);
 	}
 
@@ -1210,6 +1271,7 @@ export class SnapshotStore {
 
 	/** 把当前 storeDirectory 范围内的叶子缓存原子写入磁盘（best-effort）。 */
 	private async persistLeafCache(storeDirectory: string): Promise<void> {
+		if (!this.leafCacheDirtyDirectories.has(storeDirectory)) return;
 		const prefix = `${storeDirectory}${sep}`;
 		const entries: Record<string, Record<string, PersistedLeafCacheEntry>> = {};
 		for (const [gitDirectory, cache] of this.visibleLeafCache) {
@@ -1235,6 +1297,7 @@ export class SnapshotStore {
 				Buffer.from(JSON.stringify({ schemaVersion: 1, entries }), "utf8"),
 				0o600,
 			);
+			this.leafCacheDirtyDirectories.delete(storeDirectory);
 		} catch {
 			// 缓存写入是 best-effort：失败只影响下次性能，不影响正确性。
 		}
@@ -1428,9 +1491,11 @@ export class SnapshotStore {
 	}
 
 	private async configurePrivateRepository(gitDirectory: string): Promise<void> {
+		if (this.configuredPrivateRepositories.has(gitDirectory)) return;
 		const environment = cleanGitEnvironment();
 		await this.runGit(["--git-dir", gitDirectory, "config", "gc.auto", "0"], { env: environment });
 		await this.runGit(["--git-dir", gitDirectory, "config", "maintenance.auto", "false"], { env: environment });
+		this.configuredPrivateRepositories.add(gitDirectory);
 	}
 
 	private async assertNoAlternates(gitDirectory: string): Promise<void> {
@@ -1982,6 +2047,35 @@ function blobCacheKey(gitDirectory: string, objectId: string): string {
 	return `${gitDirectory}\0${objectId}`;
 }
 
+function storeDirectoryForGitDirectory(gitDirectory: string): string {
+	return dirname(dirname(dirname(gitDirectory)));
+}
+
+function samePersistedLeafCache(
+	left: ReadonlyMap<string, CachedVisibleLeaf> | undefined,
+	right: ReadonlyMap<string, CachedVisibleLeaf>,
+): boolean {
+	if (left === undefined) return right.size === 0;
+	if (left.size !== right.size) return false;
+	for (const [path, entry] of right) {
+		const existing = left.get(path);
+		const existingTrusted = existing !== undefined &&
+			existing.verifiedAtNs > existing.changedAtNs + RACY_CLEAN_WINDOW_NS;
+		const entryTrusted = entry.verifiedAtNs > entry.changedAtNs + RACY_CLEAN_WINDOW_NS;
+		if (
+			existing === undefined ||
+			existing.kind !== entry.kind ||
+			existing.mode !== entry.mode ||
+			existing.fingerprint !== entry.fingerprint ||
+			existing.cacheable !== entry.cacheable ||
+			existing.objectId !== entry.objectId ||
+			existing.changedAtNs !== entry.changedAtNs ||
+			existingTrusted !== entryTrusted
+		) return false;
+	}
+	return true;
+}
+
 function blobReadBatches(entries: readonly CapturedTreeEntry[]): CapturedTreeEntry[][] {
 	const result: CapturedTreeEntry[][] = [];
 	let batch: CapturedTreeEntry[] = [];