@anionex/dsh-turn-rewind 0.1.0 → 0.1.2

package/lib/snapshot.js

@@ -1,8 +1,10 @@
 import { createHash } from 'node:crypto';
-import { lstat, readFile, readlink } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { lstat, open, readlink } from 'node:fs/promises';
 import { ChangeLedgerError } from './errors.js';
 import { discoverRepository, sameRepositoryFence } from './git.js';
 import { isNodeError, resolveWorkspacePath } from './path-utils.js';
+const COMPARISON_READ_BUDGET_BYTES = 128 * 1024 * 1024;
 /** Capture the current tracked and non-ignored Git working tree. */
 export async function captureTree(options) {
     throwIfAborted(options.signal);
@@ -11,12 +13,19 @@ export async function captureTree(options) {
         throw new ChangeLedgerError('TOO_MANY_FILES', `workspace has ${source.paths.length} eligible paths; configured maximum is ${options.config.maxFiles}`);
     }
     const entries = Object.create(null);
+    const gitObjectFormat = options.gitObjectFormat;
+    const gitCapture = gitObjectFormat === undefined
+        ? undefined
+        : {
+            objectFormat: gitObjectFormat,
+            entries: Object.create(null),
+        };
     let totalBytes = 0;
-    for (const path of source.paths) {
+    const capturePath = async (path) => {
         throwIfAborted(options.signal);
         const entry = await captureEntry(source.state.root, path, options.config.maxFileBytes, options.signal);
         if (entry === undefined)
-            continue;
+            return;
         if (entry.kind === 'file') {
             totalBytes += entry.content.length;
             if (totalBytes > options.config.maxSnapshotBytes) {
@@ -26,13 +35,50 @@ export async function captureTree(options) {
                 await options.store.putBlob(source.state.root, entry.snapshot.blob, entry.content);
             }
             entries[path] = entry.snapshot;
-            continue;
+            if (gitCapture !== undefined) {
+                gitCapture.entries[path] = gitFileSnapshot(entry.snapshot, entry.content, gitCapture.objectFormat);
+            }
+            return;
         }
         entries[path] = entry.snapshot;
+        if (gitCapture !== undefined)
+            gitCapture.entries[path] = entry.snapshot;
+    };
+    if (gitCapture === undefined) {
+        for (const path of source.paths)
+            await capturePath(path);
+    }
+    else {
+        let next = 0;
+        let failed = false;
+        let firstError = new ChangeLedgerError('WORKSPACE_CHANGED_DURING_CAPTURE', 'parallel comparison capture failed');
+        const concurrency = Math.min(32, source.paths.length, Math.max(1, Math.floor(COMPARISON_READ_BUDGET_BYTES / options.config.maxFileBytes)));
+        const workers = Array.from({ length: concurrency }, async () => {
+            while (!failed && next < source.paths.length) {
+                const index = next;
+                next += 1;
+                const path = source.paths[index];
+                if (path === undefined)
+                    continue;
+                try {
+                    await capturePath(path);
+                }
+                catch (error) {
+                    if (!failed) {
+                        failed = true;
+                        firstError = error;
+                    }
+                }
+            }
+        });
+        await Promise.all(workers);
+        if (failed)
+            throw firstError;
     }
     return {
         source,
         entries,
+        ...(gitCapture === undefined ? {} : { gitEntries: gitCapture.entries }),
         treeHash: hashTree(entries),
         fileCount: Object.keys(entries).length,
         totalBytes,
@@ -48,6 +94,7 @@ export async function captureStableTree(options) {
         const first = await captureTree({
             cwd: options.cwd,
             config: options.config,
+            ...(options.gitObjectFormat === undefined ? {} : { gitObjectFormat: options.gitObjectFormat }),
             ...(options.signal === undefined ? {} : { signal: options.signal }),
         });
         const second = await captureTree(options);
@@ -61,12 +108,14 @@ export async function captureStableTree(options) {
     throw new ChangeLedgerError('WORKSPACE_CHANGED_DURING_CAPTURE', 'workspace did not remain stable across repeated full-tree captures');
 }
 /** Compute stable path-level differences between two captured trees. */
-export function diffTrees(before, after) {
+export function diffTrees(before, after, comparisonBefore = before, comparisonAfter = after) {
     const paths = [...new Set([...Object.keys(before), ...Object.keys(after)])].sort(comparePaths);
     const changes = [];
     for (const path of paths) {
         const left = before[path];
         const right = after[path];
+        const comparisonLeft = comparisonBefore[path];
+        const comparisonRight = comparisonAfter[path];
         if (left === undefined && right !== undefined) {
             changes.push({ path, kind: 'added', after: right });
             continue;
@@ -75,17 +124,27 @@ export function diffTrees(before, after) {
             changes.push({ path, kind: 'deleted', before: left });
             continue;
         }
-        if (left === undefined || right === undefined || entriesEqual(left, right))
+        if (left === undefined || right === undefined || entriesEqual(comparisonLeft, comparisonRight))
             continue;
         if (left.kind !== right.kind) {
             changes.push({ path, kind: 'type-changed', before: left, after: right });
             continue;
         }
-        if (left.kind === 'file' && right.kind === 'file' && left.blob === right.blob && left.mode !== right.mode) {
+        if (left.kind === 'file'
+            && right.kind === 'file'
+            && comparisonLeft?.kind === 'file'
+            && comparisonRight?.kind === 'file'
+            && comparisonLeft.blob === comparisonRight.blob
+            && left.mode !== right.mode) {
             changes.push({ path, kind: 'mode-changed', before: left, after: right });
             continue;
         }
-        if (left.kind === 'symlink' && right.kind === 'symlink' && left.target === right.target && left.mode !== right.mode) {
+        if (left.kind === 'symlink'
+            && right.kind === 'symlink'
+            && comparisonLeft?.kind === 'symlink'
+            && comparisonRight?.kind === 'symlink'
+            && comparisonLeft.target === comparisonRight.target
+            && left.mode !== right.mode) {
             changes.push({ path, kind: 'mode-changed', before: left, after: right });
             continue;
         }
@@ -122,6 +181,18 @@ export function hashTree(entries) {
     }
     return hash.digest('hex');
 }
+/** Byte-verify one workspace-relative path without following a final symlink. */
+export async function captureSnapshotEntry(root, path, maxFileBytes, signal, gitObjectFormat) {
+    const entry = await captureEntry(root, path, maxFileBytes, signal);
+    if (entry === undefined || entry.kind === 'symlink' || gitObjectFormat === undefined)
+        return entry?.snapshot;
+    return gitFileSnapshot(entry.snapshot, entry.content, gitObjectFormat);
+}
+function gitFileSnapshot(snapshot, content, objectFormat) {
+    const header = Buffer.from(`blob ${String(content.length)}\0`);
+    const blob = createHash(objectFormat).update(header).update(content).digest('hex');
+    return { ...snapshot, blob, provider: 'git' };
+}
 async function captureEntry(root, path, maxFileBytes, signal) {
     const target = resolveWorkspacePath(root, path);
     for (let attempt = 0; attempt < 3; attempt += 1) {
@@ -149,11 +220,29 @@ async function captureEntry(root, path, maxFileBytes, signal) {
         if (before.size > BigInt(maxFileBytes)) {
             throw new ChangeLedgerError('FILE_TOO_LARGE', `${JSON.stringify(path)} is ${before.size.toString()} bytes; configured per-file maximum is ${maxFileBytes}`);
         }
-        const content = await readFile(target);
-        throwIfAborted(signal);
-        const after = await lstat(target, { bigint: true });
-        if (!sameStat(before, after) || BigInt(content.length) !== after.size)
-            continue;
+        let handle;
+        try {
+            handle = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
+        }
+        catch (error) {
+            if (isNodeError(error, 'ELOOP'))
+                continue;
+            throw error;
+        }
+        let content;
+        try {
+            const opened = await handle.stat({ bigint: true });
+            if (!opened.isFile() || !sameStat(before, opened))
+                continue;
+            content = await readBoundedFile(handle, Number(opened.size));
+            throwIfAborted(signal);
+            const after = await handle.stat({ bigint: true });
+            if (!sameStat(opened, after) || BigInt(content.length) !== after.size)
+                continue;
+        }
+        finally {
+            await handle.close();
+        }
         const blob = createHash('sha256').update(content).digest('hex');
         return {
             kind: 'file',
@@ -163,6 +252,17 @@ async function captureEntry(root, path, maxFileBytes, signal) {
     }
     throw new ChangeLedgerError('WORKSPACE_CHANGED_DURING_CAPTURE', `path changed repeatedly while being captured: ${JSON.stringify(path)}`);
 }
+async function readBoundedFile(handle, expectedSize) {
+    const buffer = Buffer.allocUnsafe(expectedSize + 1);
+    let offset = 0;
+    while (offset < buffer.length) {
+        const { bytesRead } = await handle.read(buffer, offset, buffer.length - offset, offset);
+        if (bytesRead === 0)
+            break;
+        offset += bytesRead;
+    }
+    return buffer.subarray(0, offset);
+}
 function sameStat(left, right) {
     return left.dev === right.dev
         && left.ino === right.ino