texlite 0.5.5 → 0.6.5

package/dist/server/instanceLock.js

@@ -0,0 +1,137 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+export const LOCK_FILE_NAME = ".texlite.lock";
+export function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error?.code;
+        return code === "EPERM";
+    }
+}
+export function readDataDirectoryLock(dataDir) {
+    const lockPath = path.join(dataDir, LOCK_FILE_NAME);
+    const metadataPath = path.join(lockPath, "owner.json");
+    try {
+        if (!fs.existsSync(lockPath))
+            return null;
+        // New locks are complete directories installed with atomic rename, so
+        // readers never need to delete an empty/partially-written lock. Read the
+        // old regular-file
+        // format as a migration path for crashed instances from older releases.
+        const lockStat = fs.lstatSync(lockPath);
+        const content = fs.readFileSync(lockStat.isDirectory() ? metadataPath : lockPath, "utf8");
+        const parsed = JSON.parse(content);
+        if (typeof parsed?.pid === "number" && typeof parsed?.startedAt === "string") {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function acquireDataDirectoryLock(config) {
+    fs.mkdirSync(config.dataDir, { recursive: true, mode: 0o700 });
+    const lockPath = path.join(config.dataDir, LOCK_FILE_NAME);
+    const lockInfo = {
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        token: randomUUID(),
+        configPath: config.configPath,
+        host: config.host,
+        port: config.port
+    };
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            // mkdir is the ownership operation. Another process can never acquire
+            // the same directory; the owner metadata is then installed atomically
+            // inside it. Readers never remove a fresh directory while this write is
+            // in progress.
+            fs.mkdirSync(lockPath, { mode: 0o700 });
+            const metadata = path.join(lockPath, "owner.json");
+            const temporary = `${metadata}.${process.pid}-${randomUUID()}.tmp`;
+            try {
+                fs.writeFileSync(temporary, `${JSON.stringify(lockInfo, null, 2)}\n`, {
+                    encoding: "utf8", mode: 0o600, flag: "wx"
+                });
+                fs.renameSync(temporary, metadata);
+            }
+            catch (error) {
+                fs.rmSync(temporary, { force: true });
+                fs.rmSync(lockPath, { recursive: true, force: true });
+                throw error;
+            }
+            let released = false;
+            const release = () => {
+                if (released)
+                    return;
+                released = true;
+                try {
+                    if (fs.existsSync(lockPath)) {
+                        const current = readDataDirectoryLock(config.dataDir);
+                        if (current?.pid === lockInfo.pid && current.startedAt === lockInfo.startedAt
+                            && current.token === lockInfo.token) {
+                            fs.rmSync(lockPath, { recursive: true, force: true });
+                        }
+                    }
+                }
+                catch { /* Ignore file system cleanup errors on exit */ }
+            };
+            const exitHandler = () => release();
+            process.once("exit", exitHandler);
+            return {
+                release: () => {
+                    process.removeListener("exit", exitHandler);
+                    release();
+                },
+                lockPath,
+                info: lockInfo
+            };
+        }
+        catch (error) {
+            const code = error?.code;
+            if (code !== "EEXIST")
+                throw error;
+            const existing = readDataDirectoryLock(config.dataDir);
+            if (existing && isProcessAlive(existing.pid)) {
+                throw new Error(`The data directory is already locked by another TexLite instance:\n` +
+                    `  - PID: ${existing.pid}\n` +
+                    `  - Config: ${existing.configPath}\n` +
+                    `  - Address: http://${existing.host}:${existing.port}\n` +
+                    `  - Started: ${existing.startedAt}\n` +
+                    `  - Data directory: ${config.dataDir}\n` +
+                    `Do not run multiple TexLite instances with the same data directory.`);
+            }
+            // An empty lock directory is normally another process between mkdir and
+            // its atomic owner.json rename. Never remove a fresh one: doing so would
+            // reintroduce the exact concurrent-start race this lock prevents.
+            if (!existing) {
+                try {
+                    const stat = fs.statSync(lockPath);
+                    if (Date.now() - stat.mtimeMs < 5_000) {
+                        throw new Error("The data directory lock is being initialized by another TexLite instance. Try again shortly.");
+                    }
+                }
+                catch (error) {
+                    if (error instanceof Error && error.message.startsWith("The data directory lock is being initialized"))
+                        throw error;
+                }
+            }
+            // Stale lock from a crashed process. The recursive removal also handles
+            // the legacy regular-file lock used by pre-directory-lock releases.
+            try {
+                fs.rmSync(lockPath, { recursive: true, force: true });
+            }
+            catch {
+                // Ignore removal error and retry
+            }
+        }
+    }
+    throw new Error(`Unable to acquire the TexLite data directory lock: ${lockPath}`);
+}

package/dist/server/latexCompletion.js

@@ -246,6 +246,7 @@ export function buildLatexCompletionIndex(config, projectId) {
 export class LatexCompletionService {
     config;
     cache = new Map();
+    resultCache = new Map();
     pending = new Map();
     constructor(config) {
         this.config = config;
@@ -263,12 +264,26 @@ export class LatexCompletionService {
     }
     invalidate(projectId) {
         this.cache.delete(projectId);
+        this.resultCache.delete(projectId);
+    }
+    stats() {
+        return {
+            cachedProjects: this.resultCache.size,
+            pending: this.pending.size,
+            cachedFiles: [...this.cache.values()].reduce((total, files) => total + files.size, 0)
+        };
     }
     async buildIncremental(projectId) {
         const index = standardIndex();
         const projectCache = this.cache.get(projectId) ?? new Map();
         this.cache.set(projectId, projectCache);
         const allEntries = (await listProjectFilesAsync(this.config, projectId)).filter((entry) => entry.type === "file").slice(0, maxIndexedFiles);
+        const signature = allEntries.map((entry) => `${entry.path}:${entry.size ?? 0}:${entry.mtimeMs ?? 0}`).sort().join("\n");
+        const cachedResult = this.resultCache.get(projectId);
+        if (cachedResult?.signature === signature) {
+            cachedResult.touched = Date.now();
+            return cachedResult.index;
+        }
         const livePaths = new Set(allEntries.map((entry) => entry.path));
         for (const cachedPath of [...projectCache.keys()])
             if (!livePaths.has(cachedPath))
@@ -300,10 +315,17 @@ export class LatexCompletionService {
             }
             mergeIndex(index, cached.index);
         }
-        return {
+        const result = {
             commands: sorted(index.commands), environments: sorted(index.environments), labels: sorted(index.labels),
             citations: sorted(index.citations), packages: sorted(index.packages), files: sorted(index.files)
         };
+        this.resultCache.set(projectId, { signature, index: result, touched: Date.now() });
+        if (this.resultCache.size > 64) {
+            const oldest = [...this.resultCache.entries()].sort((left, right) => left[1].touched - right[1].touched)[0];
+            if (oldest)
+                this.resultCache.delete(oldest[0]);
+        }
+        return result;
     }
 }
 function mergeIndex(target, source) {

package/dist/server/latexFormatter.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { detachedProcessGroup, killProcessGroup } from "./processTree.js";
 const DEFAULT_COMMAND = "tex-fmt";
 const FORMAT_TIMEOUT_MS = 30_000;
 const MAX_DIAGNOSTIC_BYTES = 16 * 1024;
@@ -50,6 +51,7 @@ function runCommand(command, args, input, cwd, timeoutMs) {
                 cwd,
                 env: { ...process.env, LC_ALL: "C" },
                 shell: false,
+                detached: detachedProcessGroup(),
                 stdio: ["pipe", "pipe", "pipe"]
             });
         }
@@ -82,7 +84,7 @@ function runCommand(command, args, input, cwd, timeoutMs) {
         };
         const timer = setTimeout(() => {
             timedOut = true;
-            child.kill("SIGKILL");
+            killProcessGroup(child);
         }, timeoutMs);
         child.stdout.on("data", (chunk) => {
             if (outputTooLarge || stdoutBytes >= 64 * 1024 * 1024)
@@ -93,7 +95,7 @@ function runCommand(command, args, input, cwd, timeoutMs) {
             stdoutBytes += bytes.byteLength;
             if (chunk.byteLength > remaining) {
                 outputTooLarge = true;
-                child.kill("SIGKILL");
+                killProcessGroup(child);
             }
         });
         child.stderr.on("data", (chunk) => {

package/dist/server/processTree.js

@@ -0,0 +1,31 @@
+/**
+ * Start long-running external commands in their own process group on POSIX.
+ * A negative PID can then be used to signal the command and all descendants
+ * (for example latexmk's pdflatex/bibtex children) together.
+ */
+export function detachedProcessGroup() {
+    return process.platform !== "win32";
+}
+/**
+ * Terminate an external command and its descendants when the platform
+ * supports process groups.  The child-only fallback keeps this safe on
+ * Windows and for processes that have already exited.
+ */
+export function killProcessGroup(child, signal = "SIGKILL") {
+    if (process.platform !== "win32" && child.pid) {
+        try {
+            process.kill(-child.pid, signal);
+            return;
+        }
+        catch (error) {
+            if (error.code !== "ESRCH") {
+                // Fall through to child.kill().  It is possible for a process group
+                // to be unavailable even though the child itself is still alive.
+            }
+        }
+    }
+    try {
+        child.kill(signal);
+    }
+    catch { /* the process may have exited already */ }
+}

package/dist/server/projectMutations.js

@@ -0,0 +1,255 @@
+import { SourceFlushError } from "./http.js";
+/**
+ * Serializes operations that replace or move a project's source tree.
+ *
+ * Ordinary Yjs edits remain concurrent. An exclusive operation first flushes
+ * the current room, blocks new updates, and resets the collaboration epoch on
+ * completion so clients cannot replay edits made against the replaced tree.
+ */
+export class ProjectMutationCoordinator {
+    collaboration;
+    queues = new Map();
+    /**
+     * Compilation is deliberately not represented by the ordinary project
+     * queue.  A compile runs from an immutable snapshot and may take minutes;
+     * keeping it in `queues` would make reads and ordinary edits wait for
+     * latexmk.  The separate state below only prevents source-tree replacement
+     * and compile-cache cleanup from racing an active compile.
+     */
+    compileStates = new Map();
+    constructor(collaboration) {
+        this.collaboration = collaboration;
+    }
+    /**
+     * Flush the live collaborative room and require a durable result.  A null
+     * receipt means that no room is currently loaded, so the source directory
+     * is already authoritative for this request.
+     */
+    flushProject(projectId) {
+        return this.requireSuccessfulFlush(this.collaboration.flushProject(projectId));
+    }
+    async runExclusive(projectId, reason, operation, options = {}) {
+        const exclusion = this.beginCompileExclusion(projectId);
+        try {
+            // Do not reserve the ordinary queue until active compilations have
+            // drained.  Otherwise a compile waiting for a short snapshot lock could
+            // deadlock behind this exclusive operation.
+            await exclusion.waitForIdle();
+            const reservation = this.reserve(projectId);
+            const { previous, tail, release } = reservation;
+            await previous;
+            try {
+                await this.collaboration.waitForReady?.(projectId);
+                options.preflight?.();
+                // This call is synchronous. No WebSocket event can interleave between
+                // the final flush and the maintenance flag being installed.
+                if (options.flush !== false)
+                    this.flushProject(projectId);
+                this.collaboration.beginMaintenance(projectId, reason);
+                try {
+                    return await operation();
+                }
+                finally {
+                    this.collaboration.endMaintenance(projectId);
+                }
+            }
+            finally {
+                release();
+                if (this.queues.get(projectId)?.tail === tail)
+                    this.queues.delete(projectId);
+            }
+        }
+        finally {
+            exclusion.release();
+        }
+    }
+    /**
+     * Run a long-lived compiler job without occupying the source mutation
+     * queue. The callback must use an immutable compile snapshot for all source
+     * reads. Exclusive source-tree operations and compile-cache cleanup wait for
+     * this callback to finish, while ordinary reads and edits continue.
+     */
+    async runCompile(projectId, operation) {
+        const release = await this.acquireCompile(projectId);
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+        }
+    }
+    /**
+     * Serialize an operation that removes or replaces compiler state without
+     * disconnecting collaborators. This is used by compile-cache/artifact
+     * cleanup, which must not run alongside latexmk but does not need the full
+     * maintenance mode used by Git checkout or history restore.
+     */
+    async runCompileExclusive(projectId, operation, options = {}) {
+        const exclusion = this.beginCompileExclusion(projectId);
+        try {
+            await exclusion.waitForIdle();
+            return await this.runQueued(projectId, operation, options);
+        }
+        finally {
+            exclusion.release();
+        }
+    }
+    /** Reserve a project operation after queued mutations without flushing. */
+    async runSnapshot(projectId, operation, options = {}) {
+        return this.runQueued(projectId, operation, options);
+    }
+    /**
+     * Serialize a project operation without entering maintenance mode.
+     *
+     * This is the common short lock for source-tree operations that must not
+     * overlap another queued operation, but should not disconnect active
+     * collaborators. Long-running compiler processes use `runCompile` instead;
+     * they operate on immutable snapshots and do not occupy this queue.
+     * The queue is deliberately held until the async operation settles (rather
+     * than only until it starts), so filesystem work cannot race another queued
+     * operation.
+     */
+    async runSerialized(projectId, operation, options = {}) {
+        return this.runQueued(projectId, async () => {
+            if (options.flush !== false)
+                this.flushProject(projectId);
+            return operation();
+        }, options);
+    }
+    /**
+     * Run a source-tree read under a short snapshot barrier.
+     *
+     * Yjs edits continue in memory, but autosave and HTTP mutations cannot
+     * change the source tree while the asynchronous scan/archive is running.
+     * The deferred edits are flushed when the barrier is released.
+     */
+    async runConsistentRead(projectId, operation, options = {}) {
+        return this.runBarrieredRead(projectId, operation, options, true);
+    }
+    /**
+     * Read the source tree under the same short barrier as a consistent read,
+     * but do not wait for a cold collaboration room to hydrate.  The filesystem
+     * is authoritative until a room exists, so this is safe for first-paint
+     * file-list requests and prevents them from being serialized behind a large
+     * Yjs bootstrap.
+     */
+    async runFilesystemRead(projectId, operation, options = {}) {
+        return this.runBarrieredRead(projectId, operation, options, false);
+    }
+    /**
+     * Serialize an ordinary filesystem write with compile snapshots without
+     * interrupting active collaborators. The operation flushes the current Yjs
+     * room first, so an HTTP file operation never overwrites a newer draft.
+     */
+    async runWrite(projectId, operation, options = {}) {
+        return this.runSerialized(projectId, operation, options);
+    }
+    async runQueued(projectId, operation, options) {
+        const { previous, tail, release } = this.reserve(projectId);
+        await previous;
+        try {
+            await this.collaboration.waitForReady?.(projectId);
+            options.preflight?.();
+            return await operation();
+        }
+        finally {
+            release();
+            if (this.queues.get(projectId)?.tail === tail)
+                this.queues.delete(projectId);
+        }
+    }
+    async runBarrieredRead(projectId, operation, options, waitForRoom) {
+        const { previous, tail, release } = this.reserve(projectId);
+        await previous;
+        let barrierStarted = false;
+        try {
+            if (waitForRoom)
+                await this.collaboration.waitForReady?.(projectId);
+            options.preflight?.();
+            this.flushProject(projectId);
+            this.collaboration.beginSnapshotBarrier(projectId);
+            barrierStarted = true;
+            return await operation();
+        }
+        finally {
+            try {
+                if (barrierStarted)
+                    this.requireSuccessfulFlush(this.collaboration.endSnapshotBarrier(projectId));
+            }
+            finally {
+                release();
+                if (this.queues.get(projectId)?.tail === tail)
+                    this.queues.delete(projectId);
+            }
+        }
+    }
+    requireSuccessfulFlush(receipt) {
+        if (receipt && !receipt.ok)
+            throw new SourceFlushError(receipt.failedPaths ?? []);
+        return receipt;
+    }
+    reserve(projectId) {
+        const previous = this.queues.get(projectId)?.tail ?? Promise.resolve();
+        let release;
+        const gate = new Promise((resolve) => { release = resolve; });
+        const tail = previous.then(() => gate);
+        this.queues.set(projectId, { tail, release });
+        return { previous, tail, release };
+    }
+    stateFor(projectId) {
+        const existing = this.compileStates.get(projectId);
+        if (existing)
+            return existing;
+        const state = { active: 0, exclusions: 0, idleWaiters: [], startWaiters: [] };
+        this.compileStates.set(projectId, state);
+        return state;
+    }
+    beginCompileExclusion(projectId) {
+        const state = this.stateFor(projectId);
+        state.exclusions += 1;
+        let released = false;
+        return {
+            waitForIdle: () => state.active === 0
+                ? Promise.resolve()
+                : new Promise((resolve) => state.idleWaiters.push(resolve)),
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                state.exclusions = Math.max(0, state.exclusions - 1);
+                if (state.exclusions === 0) {
+                    const waiters = state.startWaiters.splice(0);
+                    for (const resolve of waiters)
+                        resolve();
+                }
+                this.cleanupCompileState(projectId, state);
+            }
+        };
+    }
+    async acquireCompile(projectId) {
+        const state = this.stateFor(projectId);
+        while (state.exclusions > 0) {
+            await new Promise((resolve) => state.startWaiters.push(resolve));
+        }
+        state.active += 1;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            state.active = Math.max(0, state.active - 1);
+            if (state.active === 0) {
+                const waiters = state.idleWaiters.splice(0);
+                for (const resolve of waiters)
+                    resolve();
+            }
+            this.cleanupCompileState(projectId, state);
+        };
+    }
+    cleanupCompileState(projectId, state) {
+        if (state.active === 0 && state.exclusions === 0 && state.idleWaiters.length === 0 && state.startWaiters.length === 0) {
+            if (this.compileStates.get(projectId) === state)
+                this.compileStates.delete(projectId);
+        }
+    }
+}

package/dist/server/projectOutline.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { resolveSourcePath, safeRelativePath } from "./files.js";
+import { listProjectFilesAsync, resolveSourcePath, safeRelativePath } from "./files.js";
 const levels = { part: 0, chapter: 0, section: 1, subsection: 2, subsubsection: 3, paragraph: 4 };
 const commandPattern = /\\(part|chapter|section|subsection|subsubsection|paragraph)\*?(?:\s*\[[^\]]*\])?\s*\{|\\(?:input|include|subfile)\s*\{/g;
 export function buildProjectOutline(config, projectId, mainFileInput) {
@@ -34,6 +34,101 @@ export function buildProjectOutline(config, projectId, mainFileInput) {
     visit(mainFile);
     return result;
 }
+/** Async outline builder used by the HTTP path so large projects do not block the event loop. */
+export async function buildProjectOutlineAsync(config, projectId, mainFileInput) {
+    const mainFile = safeRelativePath(mainFileInput);
+    const result = [];
+    const visited = new Set();
+    const visit = async (filePath) => {
+        if (visited.has(filePath) || visited.size >= 200)
+            return;
+        visited.add(filePath);
+        let stat;
+        try {
+            stat = await fs.promises.stat(resolveSourcePath(config, projectId, filePath));
+        }
+        catch {
+            return;
+        }
+        if (!stat.isFile() || stat.size > 3 * 1024 * 1024)
+            return;
+        let content;
+        try {
+            content = stripCommentsPreserveLines(await fs.promises.readFile(resolveSourcePath(config, projectId, filePath), "utf8"));
+        }
+        catch {
+            return;
+        }
+        const lineStarts = sourceLineStarts(content);
+        const pattern = new RegExp(commandPattern.source, commandPattern.flags);
+        for (const command of content.matchAll(pattern)) {
+            const start = (command.index ?? 0) + command[0].length;
+            const argument = balancedArgument(content, start);
+            if (!argument)
+                continue;
+            if (command[1]) {
+                result.push({ path: filePath, line: lineAtOffset(lineStarts, command.index ?? 0), level: levels[command[1]], title: cleanTitle(argument.value) });
+                continue;
+            }
+            const included = await resolveIncludedFileAsync(config, projectId, filePath, argument.value);
+            if (included)
+                await visit(included);
+        }
+    };
+    await visit(mainFile);
+    return result;
+}
+/**
+ * Caches the parsed outline by project tree metadata and main document. The
+ * pending map also coalesces simultaneous requests from multiple browser
+ * sessions opening the same project.
+ */
+export class ProjectOutlineService {
+    config;
+    cache = new Map();
+    pending = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    build(projectId, mainFileInput) {
+        const mainFile = safeRelativePath(mainFileInput);
+        const key = `${projectId}\0${mainFile}`;
+        const existing = this.pending.get(key);
+        if (existing)
+            return existing;
+        const request = this.buildCached(projectId, mainFile, key).finally(() => {
+            if (this.pending.get(key) === request)
+                this.pending.delete(key);
+        });
+        this.pending.set(key, request);
+        return request;
+    }
+    invalidate(projectId) {
+        for (const key of this.cache.keys())
+            if (key.startsWith(`${projectId}\0`))
+                this.cache.delete(key);
+    }
+    stats() {
+        return { cachedOutlines: this.cache.size, pending: this.pending.size };
+    }
+    async buildCached(projectId, mainFile, key) {
+        const entries = await listProjectFilesAsync(this.config, projectId);
+        const signature = entries.map((entry) => `${entry.type}:${entry.path}:${entry.size ?? 0}:${entry.mtimeMs ?? 0}`).sort().join("\n");
+        const cached = this.cache.get(key);
+        if (cached?.signature === signature) {
+            cached.touched = Date.now();
+            return cached.outline;
+        }
+        const outline = await buildProjectOutlineAsync(this.config, projectId, mainFile);
+        this.cache.set(key, { signature, outline, touched: Date.now() });
+        if (this.cache.size > 64) {
+            const oldest = [...this.cache.entries()].sort((left, right) => left[1].touched - right[1].touched)[0];
+            if (oldest)
+                this.cache.delete(oldest[0]);
+        }
+        return outline;
+    }
+}
 function resolveIncludedFile(config, projectId, currentFile, value) {
     const raw = value.trim();
     if (!raw || /[\\#]/.test(raw))
@@ -50,6 +145,23 @@ function resolveIncludedFile(config, projectId, currentFile, value) {
     }
     return null;
 }
+async function resolveIncludedFileAsync(config, projectId, currentFile, value) {
+    const raw = value.trim();
+    if (!raw || /[\\#]/.test(raw))
+        return null;
+    const withExtension = path.posix.extname(raw) ? raw : `${raw}.tex`;
+    const candidates = [withExtension, path.posix.join(path.posix.dirname(currentFile), withExtension)];
+    for (const candidate of [...new Set(candidates)]) {
+        try {
+            const safe = safeRelativePath(candidate);
+            const stat = await fs.promises.stat(resolveSourcePath(config, projectId, safe));
+            if (stat.isFile())
+                return safe;
+        }
+        catch { /* Ignore includes outside the project. */ }
+    }
+    return null;
+}
 function balancedArgument(source, start) {
     let depth = 1;
     for (let index = start; index < source.length; index += 1) {

package/dist/server/projectSearch.js

@@ -75,6 +75,12 @@ export async function replaceProject(config, projectId, options, replacement) {
         const content = previous.replace(pattern, () => { count += 1; return replacement; });
         if (!count || content === previous)
             continue;
+        if (options.maxFileBytes !== undefined && Buffer.byteLength(content, "utf8") > options.maxFileBytes) {
+            await Promise.allSettled(staged.map((entry) => fs.promises.rm(entry.temporary, { force: true })));
+            throw Object.assign(new Error(`Replacement would exceed the ${Math.floor(options.maxFileBytes / 1024 / 1024)} MB collaborative text limit`), {
+                code: "FILE_TOO_LARGE", statusCode: 413
+            });
+        }
         const temporary = `${absolute}.search-${process.pid}-${Date.now()}-${staged.length}.tmp`;
         await fs.promises.writeFile(temporary, content, { encoding: "utf8", mode: 0o600 });
         staged.push({ path: entry.path, absolute, temporary, previous, content, count });