npmdata 0.9.1 → 0.10.0

package/dist/consumer.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.compressGitignoreEntries = compressGitignoreEntries;
+exports.findNearestMarkerPath = findNearestMarkerPath;
 exports.extract = extract;
 exports.check = check;
 exports.purge = purge;
@@ -12,6 +14,7 @@ exports.list = list;
 /* eslint-disable no-continue */
 /* eslint-disable functional/immutable-data */
 /* eslint-disable no-restricted-syntax */
+/* eslint-disable max-depth */
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
@@ -22,6 +25,24 @@ const MARKER_FILE = '.npmdata';
 const GITIGNORE_FILE = '.gitignore';
 const GITIGNORE_START = '# npmdata:start';
 const GITIGNORE_END = '# npmdata:end';
+/**
+ * Read the .gitignore at dir and return parsed patterns, excluding the npmdata-managed
+ * section.  These are the "external" patterns (e.g. node_modules, dist) that were written
+ * by the project author rather than by npmdata itself.
+ */
+function readExternalGitignorePatterns(dir) {
+    const gitignorePath = node_path_1.default.join(dir, GITIGNORE_FILE);
+    if (!node_fs_1.default.existsSync(gitignorePath))
+        return [];
+    let content = node_fs_1.default.readFileSync(gitignorePath, 'utf8');
+    // Strip out the npmdata-managed block so we only act on external entries.
+    const startIdx = content.indexOf(GITIGNORE_START);
+    const endIdx = content.indexOf(GITIGNORE_END);
+    if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {
+        content = content.slice(0, startIdx) + content.slice(endIdx + GITIGNORE_END.length);
+    }
+    return (0, utils_1.parseGitignorePatterns)(content);
+}
 /**
  * Update (or create) a .gitignore in the given directory so that the managed
  * files and the .npmdata marker file are ignored by git.
@@ -67,40 +88,161 @@ function updateGitignoreForDir(dir, managedFilenames, addEntries = true) {
     node_fs_1.default.writeFileSync(gitignorePath, updatedContent, 'utf8');
 }
 /**
- * Walk outputDir and update .gitignore files for every directory that has a
- * .npmdata marker (to reflect its current managed files) and also clean up
- * any npmdata sections in directories where the marker was removed.
+ * Optimise the list of managed file paths for use in .gitignore.
+ * When every file inside a directory (recursively, excluding MARKER_FILE, GITIGNORE_FILE, and
+ * symlinks) is present in managedPaths, the whole directory is represented as "dir/" rather than
+ * listing each file individually.  Root-level files (no slash) are always emitted as-is.
+ *
+ * @param managedPaths - Paths relative to outputDir (e.g. ["docs/guide.md", "README.md"])
+ * @param outputDir    - Absolute path to the root used to inspect actual disk contents
+ */
+function compressGitignoreEntries(managedPaths, outputDir) {
+    const managedSet = new Set(managedPaths);
+    const gitignorePatterns = readExternalGitignorePatterns(outputDir);
+    // Returns true when every non-special, non-symlink file inside absDir (recursively)
+    // appears in managedSet under its full outputDir-relative path (relDir prefix included).
+    const isDirFullyManaged = (absDir, relDir) => {
+        if (!node_fs_1.default.existsSync(absDir))
+            return false;
+        for (const entry of node_fs_1.default.readdirSync(absDir)) {
+            if (entry === MARKER_FILE || entry === GITIGNORE_FILE)
+                continue;
+            const absEntry = node_path_1.default.join(absDir, entry);
+            const relEntry = `${relDir}/${entry}`;
+            const lstat = node_fs_1.default.lstatSync(absEntry);
+            if (lstat.isSymbolicLink())
+                continue;
+            if (lstat.isDirectory()) {
+                // Skip gitignored subdirs that have no managed files — they are not our concern
+                // and traversing them (e.g. node_modules) causes serious performance problems.
+                if ((0, utils_1.isGitignored)(entry, gitignorePatterns) && !(0, utils_1.hasManagedFilesUnder)(relEntry, managedSet)) {
+                    continue;
+                }
+                if (!isDirFullyManaged(absEntry, relEntry))
+                    return false;
+            }
+            else if (!managedSet.has(relEntry))
+                return false;
+        }
+        return true;
+    };
+    // paths: managed paths relative to the current directory scope
+    // absRoot: absolute path of the current directory scope
+    // relRoot: path of the current scope relative to outputDir (empty string at top level)
+    const compress = (paths, absRoot, relRoot) => {
+        const result = [];
+        const subdirNames = new Set();
+        for (const p of paths) {
+            const slashIdx = p.indexOf('/');
+            if (slashIdx === -1) {
+                // File lives directly in this scope — emit its full outputDir-relative path
+                result.push(relRoot ? `${relRoot}/${p}` : p);
+            }
+            else {
+                subdirNames.add(p.slice(0, slashIdx));
+            }
+        }
+        for (const dirName of subdirNames) {
+            const absDir = node_path_1.default.join(absRoot, dirName);
+            const relDir = relRoot ? `${relRoot}/${dirName}` : dirName;
+            const prefix = `${dirName}/`;
+            const subPaths = paths.filter((p) => p.startsWith(prefix)).map((p) => p.slice(prefix.length));
+            if (isDirFullyManaged(absDir, relDir)) {
+                result.push(`${relDir}/`);
+            }
+            else {
+                result.push(...compress(subPaths, absDir, relDir));
+            }
+        }
+        return result;
+    };
+    return compress(managedPaths, outputDir, '');
+}
+/**
+ * Find the nearest .npmdata marker file by walking up from fromDir to outputDir (inclusive).
+ * Returns the path to the marker file, or null if none found within the outputDir boundary.
+ */
+function findNearestMarkerPath(fromDir, outputDir) {
+    let dir = fromDir;
+    const resolvedOutput = node_path_1.default.resolve(outputDir);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const markerPath = node_path_1.default.join(dir, MARKER_FILE);
+        if (node_fs_1.default.existsSync(markerPath))
+            return markerPath;
+        if (node_path_1.default.resolve(dir) === resolvedOutput)
+            break;
+        const parent = node_path_1.default.dirname(dir);
+        if (parent === dir)
+            break; // reached filesystem root
+        dir = parent;
+    }
+    // eslint-disable-next-line unicorn/no-null
+    return null;
+}
+/**
+ * Write one .gitignore at outputDir containing all managed file paths (relative to outputDir),
+ * and remove any npmdata sections from .gitignore files in subdirectories.
  * When addEntries is false, existing sections are updated/removed but no new
  * sections are created — use this to clean up without opting into gitignore management.
  */
 function updateGitignores(outputDir, addEntries = true) {
     if (!node_fs_1.default.existsSync(outputDir))
         return;
-    const walkDir = (dir) => {
-        const markerPath = node_path_1.default.join(dir, MARKER_FILE);
-        const gitignorePath = node_path_1.default.join(dir, GITIGNORE_FILE);
-        if (node_fs_1.default.existsSync(markerPath)) {
-            try {
-                const managedFiles = (0, utils_1.readCsvMarker)(markerPath);
-                updateGitignoreForDir(dir, managedFiles.map((m) => m.path), addEntries);
-            }
-            catch {
-                // Ignore unreadable marker files
+    // Read managed paths up-front so we can skip gitignored dirs that have no managed files.
+    const managedPaths = new Set();
+    const rootMarkerPathForRead = node_path_1.default.join(outputDir, MARKER_FILE);
+    if (node_fs_1.default.existsSync(rootMarkerPathForRead)) {
+        // eslint-disable-next-line functional/no-try-statements
+        try {
+            for (const m of (0, utils_1.readCsvMarker)(rootMarkerPathForRead)) {
+                managedPaths.add(m.path);
             }
         }
-        else if (node_fs_1.default.existsSync(gitignorePath)) {
-            // Clean up any leftover npmdata section
-            updateGitignoreForDir(dir, [], addEntries);
+        catch {
+            // ignore unreadable marker
         }
+    }
+    // Read external gitignore patterns once for the whole walk.
+    const gitignorePatterns = readExternalGitignorePatterns(outputDir);
+    // Remove npmdata sections from all subdirectory .gitignore files (migration / cleanup of old format)
+    const cleanupSubDirGitignores = (dir) => {
         for (const item of node_fs_1.default.readdirSync(dir)) {
             const fullPath = node_path_1.default.join(dir, item);
             const lstat = node_fs_1.default.lstatSync(fullPath);
             if (!lstat.isSymbolicLink() && lstat.isDirectory()) {
-                walkDir(fullPath);
+                const relPath = node_path_1.default.relative(outputDir, fullPath);
+                // Skip gitignored directories that have no managed files under them —
+                // traversing them (e.g. node_modules) causes serious performance problems.
+                if ((0, utils_1.isGitignored)(item, gitignorePatterns) && !(0, utils_1.hasManagedFilesUnder)(relPath, managedPaths)) {
+                    continue;
+                }
+                const subGitignore = node_path_1.default.join(fullPath, GITIGNORE_FILE);
+                if (node_fs_1.default.existsSync(subGitignore)) {
+                    updateGitignoreForDir(fullPath, [], false);
+                }
+                cleanupSubDirGitignores(fullPath);
             }
         }
     };
-    walkDir(outputDir);
+    cleanupSubDirGitignores(outputDir);
+    // Update (or remove) the single .gitignore at outputDir
+    const rootMarkerPath = node_path_1.default.join(outputDir, MARKER_FILE);
+    if (node_fs_1.default.existsSync(rootMarkerPath)) {
+        try {
+            const managedFiles = (0, utils_1.readCsvMarker)(rootMarkerPath);
+            const rawPaths = managedFiles.map((m) => m.path);
+            const optimisedPaths = compressGitignoreEntries(rawPaths, outputDir);
+            updateGitignoreForDir(outputDir, optimisedPaths, addEntries);
+        }
+        catch {
+            // Ignore unreadable marker files
+        }
+    }
+    else {
+        // Clean up any leftover npmdata section at root
+        updateGitignoreForDir(outputDir, [], false);
+    }
 }
 async function getPackageFiles(packageName, cwd) {
     const pkgPath = require.resolve(`${packageName}/package.json`, {
@@ -177,41 +319,23 @@ async function ensurePackageInstalled(packageName, version, packageManager, cwd,
     return installedVersion;
 }
 /**
- * Load all managed files from marker files under outputDir as a flat list.
- * Paths are relative to outputDir.
+ * Load all managed files from the root marker file at outputDir.
+ * Paths stored in the marker are already relative to outputDir.
+ * Uses findNearestMarkerPath starting from outputDir itself.
  */
 function loadAllManagedFiles(outputDir) {
-    const files = [];
-    const walkDir = (dir) => {
-        if (!node_fs_1.default.existsSync(dir))
-            return;
-        for (const item of node_fs_1.default.readdirSync(dir)) {
-            const fullPath = node_path_1.default.join(dir, item);
-            const stat = node_fs_1.default.lstatSync(fullPath);
-            if (stat.isSymbolicLink())
-                continue;
-            if (item === MARKER_FILE) {
-                try {
-                    const managedFiles = (0, utils_1.readCsvMarker)(fullPath);
-                    const markerDir = node_path_1.default.dirname(fullPath);
-                    const relMarkerDir = node_path_1.default.relative(outputDir, markerDir);
-                    for (const managed of managedFiles) {
-                        const relPath = relMarkerDir === '.' ? managed.path : node_path_1.default.join(relMarkerDir, managed.path);
-                        files.push({ ...managed, path: relPath });
-                    }
-                }
-                catch {
-                    console.warn(`Warning: Failed to read marker file at ${fullPath}. Skipping.`); // eslint-disable-line no-console
-                    // Ignore unreadable marker files
-                }
-            }
-            else if (stat.isDirectory()) {
-                walkDir(fullPath);
-            }
-        }
-    };
-    walkDir(outputDir);
-    return files;
+    if (!node_fs_1.default.existsSync(outputDir))
+        return [];
+    const markerPath = findNearestMarkerPath(outputDir, outputDir);
+    if (!markerPath)
+        return [];
+    try {
+        return (0, utils_1.readCsvMarker)(markerPath);
+    }
+    catch {
+        console.warn(`Warning: Failed to read marker file at ${markerPath}. Skipping.`); // eslint-disable-line no-console
+        return [];
+    }
 }
 /**
  * Load managed files from all marker files under outputDir, keyed by relative path.
@@ -221,34 +345,25 @@ function loadManagedFilesMap(outputDir) {
     return new Map(loadAllManagedFiles(outputDir).map((m) => [m.path, m]));
 }
 function cleanupEmptyMarkers(outputDir) {
-    const walkDir = (dir) => {
-        if (!node_fs_1.default.existsSync(dir))
-            return;
-        for (const file of node_fs_1.default.readdirSync(dir)) {
-            const fullPath = node_path_1.default.join(dir, file);
-            if (file === MARKER_FILE) {
-                try {
-                    const managedFiles = (0, utils_1.readCsvMarker)(fullPath);
-                    if (managedFiles.length === 0) {
-                        node_fs_1.default.chmodSync(fullPath, 0o644);
-                        node_fs_1.default.unlinkSync(fullPath);
-                    }
-                }
-                catch {
-                    // Ignore unreadable marker files
-                }
-            }
-            else {
-                const lstat = node_fs_1.default.lstatSync(fullPath);
-                if (!lstat.isSymbolicLink() && lstat.isDirectory()) {
-                    walkDir(fullPath);
-                }
-            }
+    if (!node_fs_1.default.existsSync(outputDir))
+        return;
+    const markerPath = node_path_1.default.join(outputDir, MARKER_FILE);
+    if (!node_fs_1.default.existsSync(markerPath))
+        return;
+    try {
+        const managedFiles = (0, utils_1.readCsvMarker)(markerPath);
+        if (managedFiles.length === 0) {
+            node_fs_1.default.chmodSync(markerPath, 0o644);
+            node_fs_1.default.unlinkSync(markerPath);
         }
-    };
-    walkDir(outputDir);
+    }
+    catch {
+        // Ignore unreadable marker files
+    }
 }
 function cleanupEmptyDirs(outputDir) {
+    const gitignorePatterns = readExternalGitignorePatterns(outputDir);
+    const managedPaths = new Set(loadAllManagedFiles(outputDir).map((m) => m.path));
     const walkDir = (dir) => {
         if (!node_fs_1.default.existsSync(dir))
             return true;
@@ -257,6 +372,13 @@ function cleanupEmptyDirs(outputDir) {
             const fullPath = node_path_1.default.join(dir, item);
             const lstat = node_fs_1.default.lstatSync(fullPath);
             if (!lstat.isSymbolicLink() && lstat.isDirectory()) {
+                const relPath = node_path_1.default.relative(outputDir, fullPath);
+                // Skip gitignored directories that have no managed files — they are not our concern
+                // and traversing them (e.g. node_modules) causes serious performance problems.
+                if ((0, utils_1.isGitignored)(item, gitignorePatterns) && !(0, utils_1.hasManagedFilesUnder)(relPath, managedPaths)) {
+                    isEmpty = false; // treat as non-empty so we preserve the parent directory
+                    continue;
+                }
                 const childEmpty = walkDir(fullPath);
                 if (!childEmpty)
                     isEmpty = false;
@@ -289,160 +411,145 @@ async function extractFiles(config, packageName) {
     }
     emit?.({ type: 'package-start', packageName, packageVersion: installedVersion });
     const packageFiles = await getPackageFiles(packageName, config.cwd);
-    const addedByDir = new Map();
+    const extractedFiles = [];
     const existingManagedMap = loadManagedFilesMap(config.outputDir);
-    const deletedOnlyDirs = new Set();
-    // Tracks basenames (per directory) force-claimed from a different package so the
+    // Tracks full relPaths force-claimed from a different package so the
     // marker-file merge can evict the previous owner's entry.
-    const forceClaimedByDir = new Map();
+    const forceClaimedPaths = new Set();
     // eslint-disable-next-line functional/no-let
     let wasForced = false;
-    for (const packageFile of packageFiles) {
-        if (!(0, utils_1.matchesFilenamePattern)(packageFile.relPath, config.filenamePatterns ?? types_1.DEFAULT_FILENAME_PATTERNS) ||
-            !(0, utils_1.matchesContentRegex)(packageFile.fullPath, config.contentRegexes)) {
-            continue;
-        }
-        const destPath = node_path_1.default.join(config.outputDir, packageFile.relPath);
-        if (!dryRun)
-            (0, utils_1.ensureDir)(node_path_1.default.dirname(destPath));
-        const existingOwner = existingManagedMap.get(packageFile.relPath);
-        // In unmanaged mode, skip files that already exist on disk.
-        if (config.unmanaged && node_fs_1.default.existsSync(destPath)) {
-            changes.skipped.push(packageFile.relPath);
-            emit?.({ type: 'file-skipped', packageName, file: packageFile.relPath });
-            continue;
-        }
-        // In keep-existing mode, skip files that already exist on disk but create missing ones normally.
-        if (config.keepExisting && node_fs_1.default.existsSync(destPath)) {
-            changes.skipped.push(packageFile.relPath);
-            emit?.({ type: 'file-skipped', packageName, file: packageFile.relPath });
-            continue;
-        }
-        if (node_fs_1.default.existsSync(destPath)) {
-            if (existingOwner?.packageName === packageName) {
-                if ((0, utils_1.calculateFileHash)(packageFile.fullPath) === (0, utils_1.calculateFileHash)(destPath)) {
-                    changes.skipped.push(packageFile.relPath);
-                    emit?.({ type: 'file-skipped', packageName, file: packageFile.relPath });
+    try {
+        for (const packageFile of packageFiles) {
+            if (!(0, utils_1.matchesFilenamePattern)(packageFile.relPath, config.filenamePatterns ?? types_1.DEFAULT_FILENAME_PATTERNS) ||
+                !(0, utils_1.matchesContentRegex)(packageFile.fullPath, config.contentRegexes)) {
+                continue;
+            }
+            const destPath = node_path_1.default.join(config.outputDir, packageFile.relPath);
+            if (!dryRun)
+                (0, utils_1.ensureDir)(node_path_1.default.dirname(destPath));
+            const existingOwner = existingManagedMap.get(packageFile.relPath);
+            // In unmanaged mode, skip files that already exist on disk.
+            if (config.unmanaged && node_fs_1.default.existsSync(destPath)) {
+                changes.skipped.push(packageFile.relPath);
+                emit?.({ type: 'file-skipped', packageName, file: packageFile.relPath });
+                continue;
+            }
+            // In keep-existing mode, skip files that already exist on disk but create missing ones normally.
+            if (config.keepExisting && node_fs_1.default.existsSync(destPath)) {
+                changes.skipped.push(packageFile.relPath);
+                emit?.({ type: 'file-skipped', packageName, file: packageFile.relPath });
+                continue;
+            }
+            if (node_fs_1.default.existsSync(destPath)) {
+                if (existingOwner?.packageName === packageName) {
+                    if ((0, utils_1.calculateFileHash)(packageFile.fullPath) === (0, utils_1.calculateFileHash)(destPath)) {
+                        changes.skipped.push(packageFile.relPath);
+                        emit?.({ type: 'file-skipped', packageName, file: packageFile.relPath });
+                    }
+                    else {
+                        if (!dryRun)
+                            (0, utils_1.copyFile)(packageFile.fullPath, destPath);
+                        changes.modified.push(packageFile.relPath);
+                        emit?.({ type: 'file-modified', packageName, file: packageFile.relPath });
+                    }
+                    wasForced = false;
                 }
                 else {
+                    // File exists but is owned by a different package (clash) or is unmanaged (conflict).
+                    // Behaviour is identical in both cases: throw when force is false, overwrite when true.
+                    if (!config.force) {
+                        if (existingOwner) {
+                            throw new Error(`Package clash: ${packageFile.relPath} already managed by ${existingOwner.packageName}@${existingOwner.packageVersion}. Cannot extract from ${packageName}. Use force: true to override.`);
+                        }
+                        throw new Error(`File conflict: ${packageFile.relPath} already exists and is not managed by npmdata. Use force: true to override.`);
+                    }
+                    // force=true: overwrite the existing file and take ownership.
                     if (!dryRun)
                         (0, utils_1.copyFile)(packageFile.fullPath, destPath);
                     changes.modified.push(packageFile.relPath);
                     emit?.({ type: 'file-modified', packageName, file: packageFile.relPath });
-                }
-                wasForced = false;
-            }
-            else {
-                // File exists but is owned by a different package (clash) or is unmanaged (conflict).
-                // Behaviour is identical in both cases: throw when force is false, overwrite when true.
-                if (!config.force) {
+                    wasForced = true;
                     if (existingOwner) {
-                        throw new Error(`Package clash: ${packageFile.relPath} already managed by ${existingOwner.packageName}@${existingOwner.packageVersion}. Cannot extract from ${packageName}. Use force: true to override.`);
+                        // Evict the previous owner's entry from the root marker file.
+                        forceClaimedPaths.add(packageFile.relPath);
                     }
-                    throw new Error(`File conflict: ${packageFile.relPath} already exists and is not managed by npmdata. Use force: true to override.`);
                 }
-                // force=true: overwrite the existing file and take ownership.
+            }
+            else {
                 if (!dryRun)
                     (0, utils_1.copyFile)(packageFile.fullPath, destPath);
-                changes.modified.push(packageFile.relPath);
-                emit?.({ type: 'file-modified', packageName, file: packageFile.relPath });
-                wasForced = true;
-                if (existingOwner) {
-                    // Evict the previous owner's entry from the marker file.
-                    const claimDir = node_path_1.default.dirname(packageFile.relPath) || '.';
-                    if (!forceClaimedByDir.has(claimDir))
-                        forceClaimedByDir.set(claimDir, new Set());
-                    forceClaimedByDir.get(claimDir).add(node_path_1.default.basename(packageFile.relPath));
-                }
+                changes.added.push(packageFile.relPath);
+                emit?.({ type: 'file-added', packageName, file: packageFile.relPath });
+                wasForced = false;
             }
-        }
-        else {
-            if (!dryRun)
-                (0, utils_1.copyFile)(packageFile.fullPath, destPath);
-            changes.added.push(packageFile.relPath);
-            emit?.({ type: 'file-added', packageName, file: packageFile.relPath });
-            wasForced = false;
-        }
-        if (!dryRun && !config.unmanaged && node_fs_1.default.existsSync(destPath))
-            node_fs_1.default.chmodSync(destPath, 0o444);
-        if (!config.unmanaged) {
-            const dir = node_path_1.default.dirname(packageFile.relPath) || '.';
-            if (!addedByDir.has(dir)) {
-                addedByDir.set(dir, []);
+            if (!dryRun && !config.unmanaged && node_fs_1.default.existsSync(destPath))
+                node_fs_1.default.chmodSync(destPath, 0o444);
+            if (!config.unmanaged) {
+                // eslint-disable-next-line functional/immutable-data
+                extractedFiles.push({
+                    path: packageFile.relPath,
+                    packageName,
+                    packageVersion: installedVersion,
+                    force: wasForced,
+                });
             }
-            addedByDir.get(dir).push({
-                path: node_path_1.default.basename(packageFile.relPath),
-                packageName,
-                packageVersion: installedVersion,
-                force: wasForced,
-            });
         }
-    }
-    // Delete files that were managed by this package but are no longer in the package
-    for (const [relPath, owner] of existingManagedMap) {
-        if (owner.packageName !== packageName)
-            continue;
-        const fileDir = node_path_1.default.dirname(relPath) === '.' ? '.' : node_path_1.default.dirname(relPath);
-        const dirFiles = addedByDir.get(fileDir) ?? [];
-        const stillPresent = dirFiles.some((m) => m.path === node_path_1.default.basename(relPath));
-        if (!stillPresent) {
-            const fullPath = node_path_1.default.join(config.outputDir, relPath);
-            if (node_fs_1.default.existsSync(fullPath)) {
-                if (!dryRun)
-                    (0, utils_1.removeFile)(fullPath);
-                changes.deleted.push(relPath);
-                emit?.({ type: 'file-deleted', packageName, file: relPath });
-            }
-            const dir = node_path_1.default.dirname(relPath) === '.' ? '.' : node_path_1.default.dirname(relPath);
-            if (!addedByDir.has(dir)) {
-                deletedOnlyDirs.add(dir);
+        // Delete files that were managed by this package but are no longer in the package
+        for (const [relPath, owner] of existingManagedMap) {
+            if (owner.packageName !== packageName)
+                continue;
+            const stillPresent = extractedFiles.some((m) => m.path === relPath);
+            if (!stillPresent) {
+                const fullPath = node_path_1.default.join(config.outputDir, relPath);
+                if (node_fs_1.default.existsSync(fullPath)) {
+                    if (!dryRun)
+                        (0, utils_1.removeFile)(fullPath);
+                    changes.deleted.push(relPath);
+                    emit?.({ type: 'file-deleted', packageName, file: relPath });
+                }
             }
         }
-    }
-    if (!dryRun && !config.unmanaged) {
-        // Write updated marker files
-        // eslint-disable-next-line unicorn/no-keyword-prefix
-        for (const [dir, newFiles] of addedByDir) {
-            const markerDir = dir === '.' ? config.outputDir : node_path_1.default.join(config.outputDir, dir);
-            (0, utils_1.ensureDir)(markerDir);
-            const markerPath = node_path_1.default.join(markerDir, MARKER_FILE);
-            // eslint-disable-next-line unicorn/no-null
+        if (!dryRun && !config.unmanaged) {
+            // Write a single root marker at outputDir with all managed file paths (relative to outputDir)
+            const rootMarkerPath = node_path_1.default.join(config.outputDir, MARKER_FILE);
             let existingFiles = [];
-            if (node_fs_1.default.existsSync(markerPath)) {
-                existingFiles = (0, utils_1.readCsvMarker)(markerPath);
+            if (node_fs_1.default.existsSync(rootMarkerPath)) {
+                existingFiles = (0, utils_1.readCsvMarker)(rootMarkerPath);
             }
-            // Keep entries from other packages, replace entries from this package.
-            // Also evict entries from other packages for any file force-claimed in this pass.
-            const claimedInDir = forceClaimedByDir.get(dir);
+            // Keep entries from other packages, evict entries from force-claimed paths.
             const mergedFiles = [
-                ...existingFiles.filter((m) => m.packageName !== packageName && !claimedInDir?.has(m.path)),
-                // eslint-disable-next-line unicorn/no-keyword-prefix
-                ...newFiles,
+                ...existingFiles.filter((m) => m.packageName !== packageName && !forceClaimedPaths.has(m.path)),
+                ...extractedFiles,
             ];
-            (0, utils_1.writeCsvMarker)(markerPath, mergedFiles);
-        }
-        // Update marker files for directories where all managed files were removed (no new files added)
-        for (const dir of deletedOnlyDirs) {
-            const markerDir = dir === '.' ? config.outputDir : node_path_1.default.join(config.outputDir, dir);
-            const markerPath = node_path_1.default.join(markerDir, MARKER_FILE);
-            if (!node_fs_1.default.existsSync(markerPath))
-                continue;
-            try {
-                const existingFiles = (0, utils_1.readCsvMarker)(markerPath);
-                const mergedFiles = existingFiles.filter((m) => m.packageName !== packageName);
-                if (mergedFiles.length === 0) {
-                    node_fs_1.default.chmodSync(markerPath, 0o644);
-                    node_fs_1.default.unlinkSync(markerPath);
-                }
-                else {
-                    (0, utils_1.writeCsvMarker)(markerPath, mergedFiles);
+            if (mergedFiles.length === 0) {
+                if (node_fs_1.default.existsSync(rootMarkerPath)) {
+                    node_fs_1.default.chmodSync(rootMarkerPath, 0o644);
+                    node_fs_1.default.unlinkSync(rootMarkerPath);
                 }
             }
-            catch {
-                // Ignore unreadable marker files
+            else {
+                (0, utils_1.writeCsvMarker)(rootMarkerPath, mergedFiles);
+            }
+            cleanupEmptyMarkers(config.outputDir);
+        }
+    }
+    catch (error) {
+        // On error, delete all files that were created during this extraction run
+        if (!dryRun) {
+            for (const relPath of changes.added) {
+                const fullPath = node_path_1.default.join(config.outputDir, relPath);
+                if (node_fs_1.default.existsSync(fullPath)) {
+                    try {
+                        (0, utils_1.removeFile)(fullPath);
+                    }
+                    catch {
+                        // ignore cleanup errors
+                    }
+                }
             }
+            cleanupEmptyDirs(config.outputDir);
         }
-        cleanupEmptyMarkers(config.outputDir);
+        throw error;
     }
     emit?.({ type: 'package-end', packageName, packageVersion: installedVersion });
     return changes;
@@ -631,7 +738,6 @@ async function purge(config) {
     for (const spec of config.packages) {
         const { name: packageName } = (0, utils_1.parsePackageSpec)(spec);
         const deleted = [];
-        const deletedOnlyDirs = new Set();
         emit?.({ type: 'package-start', packageName, packageVersion: 'unknown' });
         const allManaged = loadManagedFilesMap(config.outputDir);
         for (const [relPath, owner] of allManaged) {
@@ -644,26 +750,21 @@ async function purge(config) {
                 deleted.push(relPath);
                 emit?.({ type: 'file-deleted', packageName, file: relPath });
             }
-            const dir = node_path_1.default.dirname(relPath) === '.' ? '.' : node_path_1.default.dirname(relPath);
-            deletedOnlyDirs.add(dir);
         }
         if (!dryRun) {
-            // Update marker files: remove entries owned by this package.
-            for (const dir of deletedOnlyDirs) {
-                const markerDir = dir === '.' ? config.outputDir : node_path_1.default.join(config.outputDir, dir);
-                const markerPath = node_path_1.default.join(markerDir, MARKER_FILE);
-                if (!node_fs_1.default.existsSync(markerPath))
-                    continue;
+            // Update root marker: remove entries owned by this package.
+            const rootMarkerPath = node_path_1.default.join(config.outputDir, MARKER_FILE);
+            if (node_fs_1.default.existsSync(rootMarkerPath)) {
                 // eslint-disable-next-line functional/no-try-statements
                 try {
-                    const existingFiles = (0, utils_1.readCsvMarker)(markerPath);
+                    const existingFiles = (0, utils_1.readCsvMarker)(rootMarkerPath);
                     const mergedFiles = existingFiles.filter((m) => m.packageName !== packageName);
                     if (mergedFiles.length === 0) {
-                        node_fs_1.default.chmodSync(markerPath, 0o644);
-                        node_fs_1.default.unlinkSync(markerPath);
+                        node_fs_1.default.chmodSync(rootMarkerPath, 0o644);
+                        node_fs_1.default.unlinkSync(rootMarkerPath);
                     }
                     else {
-                        (0, utils_1.writeCsvMarker)(markerPath, mergedFiles);
+                        (0, utils_1.writeCsvMarker)(rootMarkerPath, mergedFiles);
                     }
                 }
                 catch {