reslop 0.2.1 → 0.2.4

package/lib/git-branches.js

@@ -4,7 +4,10 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
-const { oneLine, requireOk, runGit, runGitAsync } = require('./git.js');
+const files = require('./files.js');
+const gitWorktree = require('./git-worktree.js');
+const { shortAge } = files;
+const { oneLine, requireOk, runGit, runGitAsync } = gitWorktree;
 
 const BRANCH_FORMAT = [
   '%(HEAD)',
@@ -33,36 +36,95 @@ const commitMessage = (top, sha) => {
 
 const lastMessage = (top) => commitMessage(top, 'HEAD');
 
-const COMMIT_FORMAT = ['%H', '%h', '%an', '%ar', '%s'].join('%x1f');
+const COMMIT_FIELDS = ['%H', '%h', '%an', '%ae', '%ar', '%ci', '%D', '%s'];
+const COMMIT_FORMAT = `${COMMIT_FIELDS.join('%x1f')}%x1e%B`;
 const COMMIT_LIMIT = 256;
 const UNIT = '\x1f';
+const RECORD = '\x1e';
+const TAG_REF = /^tag: /;
+const REMOTE_HEAD = /\/HEAD(?: -> |$)/;
+
+const formatCommitRefs = (raw) => {
+  const text = `${raw ?? ''}`.trim();
+  if (!text) return '';
+  const names = [];
+  for (const part of text.split(', ')) {
+    const name = part.trim();
+    if (!name || TAG_REF.test(name)) continue;
+    if (name !== 'HEAD' && REMOTE_HEAD.test(name)) continue;
+    names.push(name);
+  }
+  return names.join(', ');
+};
 
-const parseCommitLine = (line, index) => {
-  const parts = line.split(UNIT);
-  if (parts.length < 5) return null;
+const parseCommitRecord = (record, index) => {
+  const cut = record.indexOf(RECORD);
+  if (cut < 0) return null;
+  const parts = record.slice(0, cut).split(UNIT);
+  if (parts.length < COMMIT_FIELDS.length) return null;
   const sha = (parts[0] ?? '').trim();
   if (!sha) return null;
+  const body = record.slice(cut + 1).replace(/\s+$/, '');
+  const read = (spec) => {
+    const at = COMMIT_FIELDS.indexOf(spec);
+    return (parts[at] ?? '').trim();
+  };
+  const subject = read('%s') || body.split('\n')[0].trim();
   return {
     sha,
-    shortSha: (parts[1] ?? '').trim() || sha.slice(0, 7),
-    author: (parts[2] ?? '').trim(),
-    date: (parts[3] ?? '').trim(),
-    subject: parts.slice(4).join(UNIT).trim(),
+    shortSha: read('%h') || sha.slice(0, 7),
+    author: read('%an'),
+    email: read('%ae'),
+    date: shortAge(read('%ar')),
+    when: read('%ci'),
+    refs: formatCommitRefs(read('%D')),
+    subject,
+    body,
+    added: 0,
+    removed: 0,
     head: index === 0,
   };
 };
 
+const STAT_LEAD = /^\n* *\d+ files? changed[^\n]*\n?/;
+
+const takeStat = (chunk) => {
+  const match = STAT_LEAD.exec(chunk);
+  if (!match) return { stat: '', rest: chunk };
+  return { stat: match[0], rest: chunk.slice(match[0].length) };
+};
+
+const countIn = (line, word) => {
+  const match = new RegExp(`(\\d+) ${word}`).exec(line);
+  if (!match) return 0;
+  return parseInt(match[1], 10);
+};
+
+const parseShortstat = (line) => ({
+  added: countIn(line, 'insertion'),
+  removed: countIn(line, 'deletion'),
+});
+
 const listCommits = (top) => {
   const args = [
     'log',
+    '-z',
+    '--shortstat',
     `--format=${COMMIT_FORMAT}`,
     `--max-count=${COMMIT_LIMIT}`,
   ];
   const result = requireOk(runGit(args, top), 'log failed');
   const commits = [];
-  for (const line of result.stdout.split('\n')) {
-    if (!line) continue;
-    const entry = parseCommitLine(line, commits.length);
+  for (const chunk of result.stdout.split('\0')) {
+    const taken = takeStat(chunk);
+    if (taken.stat && commits.length) {
+      const stat = parseShortstat(taken.stat);
+      const last = commits[commits.length - 1];
+      last.added = stat.added;
+      last.removed = stat.removed;
+    }
+    if (!taken.rest) continue;
+    const entry = parseCommitRecord(taken.rest, commits.length);
     if (entry) commits.push(entry);
   }
   return commits;
@@ -83,48 +145,40 @@ const dropHeadCommit = (top) => {
   requireOk(runGit(['reset', '--soft', 'HEAD~1'], top), 'drop failed');
 };
 
-const rebaseFailed = (result) => {
-  if (result.status === 0) return '';
-  return result.stderr || result.stdout || 'rebase failed';
-};
-
-const dropOlderCommit = (top, sha) => {
-  const onto = `${sha}^`;
-  const result = runGit(['rebase', '--onto', onto, sha], top);
-  const failed = rebaseFailed(result);
-  if (!failed) return;
+const runRebase = (top, args, extra = {}) => {
+  const result = runGit(args, top, undefined, extra);
+  if (result.status === 0) return;
   runGit(['rebase', '--abort'], top);
-  throw new Error(oneLine(failed));
+  requireOk(result, 'rebase failed');
 };
 
-const dropOlderCommitAsync = async (top, sha) => {
-  const onto = `${sha}^`;
-  const result = await runGitAsync(['rebase', '--onto', onto, sha], top);
-  const failed = rebaseFailed(result);
-  if (!failed) return;
+const runRebaseAsync = async (top, args, extra = {}) => {
+  const result = await runGitAsync(args, top, extra);
+  if (result.status === 0) return;
   await runGitAsync(['rebase', '--abort'], top);
-  throw new Error(oneLine(failed));
+  requireOk(result, 'rebase failed');
 };
 
-const dropCommit = (top, sha) => {
-  const spec = namedCommit(sha);
-  const target = resolveCommit(top, spec);
+const dropTarget = (top, sha) => {
+  const target = resolveCommit(top, namedCommit(sha));
   const parent = runGit(['rev-parse', '--verify', `${target}^`], top);
   if (parent.status !== 0) throw new Error('cannot drop root commit');
-  const head = resolveCommit(top, 'HEAD');
-  if (target === head) return void dropHeadCommit(top);
-  dropOlderCommit(top, target);
+  return target;
+};
+
+const dropCommit = (top, sha) => {
+  const target = dropTarget(top, sha);
+  if (target === resolveCommit(top, 'HEAD')) return void dropHeadCommit(top);
+  runRebase(top, ['rebase', '--onto', `${target}^`, target]);
 };
 
 const dropCommitAsync = async (top, sha) => {
-  const spec = namedCommit(sha);
-  const target = resolveCommit(top, spec);
-  const parentArgs = ['rev-parse', '--verify', `${target}^`];
-  const parent = await runGitAsync(parentArgs, top);
-  if (parent.status !== 0) throw new Error('cannot drop root commit');
-  const head = resolveCommit(top, 'HEAD');
-  if (target === head) return void dropHeadCommit(top);
-  await dropOlderCommitAsync(top, target);
+  const target = dropTarget(top, sha);
+  if (target === resolveCommit(top, 'HEAD')) {
+    requireOk(await runGitAsync(['reset', '--soft', 'HEAD~1'], top));
+    return;
+  }
+  await runRebaseAsync(top, ['rebase', '--onto', `${target}^`, target]);
 };
 
 const FIXUP_MARK = 'fixup!';
@@ -154,72 +208,46 @@ const commitSubject = (top, sha) => {
 };
 
 const ancestorWithSubject = (top, sha, want) => {
-  const args = ['log', `--format=${COMMIT_FORMAT}`, `${sha}^`];
+  const args = ['log', '--format=%H%x1f%s', `${sha}^`];
   const result = runGit(args, top);
   if (result.status !== 0) return '';
   for (const line of result.stdout.split('\n')) {
-    if (!line) continue;
-    const entry = parseCommitLine(line, 1);
-    if (entry && entry.subject === want) return entry.sha;
+    const cut = line.indexOf(UNIT);
+    if (cut < 0) continue;
+    const subject = line.slice(cut + 1).trim();
+    if (subject !== want) continue;
+    return line.slice(0, cut).trim();
   }
   return '';
 };
 
-const applyAutosquash = (top, ontoArgs) => {
-  const result = runGit([...AUTOSQUASH_ARGS, ...ontoArgs], top);
-  const failed = rebaseFailed(result);
-  if (!failed) return;
-  runGit(['rebase', '--abort'], top);
-  throw new Error(oneLine(failed));
-};
-
-const applyAutosquashAsync = async (top, ontoArgs) => {
-  const result = await runGitAsync([...AUTOSQUASH_ARGS, ...ontoArgs], top);
-  const failed = rebaseFailed(result);
-  if (!failed) return;
-  await runGitAsync(['rebase', '--abort'], top);
-  throw new Error(oneLine(failed));
-};
-
-const applyFixupOnto = (top, original, applyRange) => {
-  const parent = runGit(['rev-parse', '--verify', `${original}^`], top);
-  if (parent.status !== 0) return applyRange(top, ['--root']);
-  return applyRange(top, [(parent.stdout ?? '').trim()]);
+const rebaseRange = (top, sha) => {
+  const parent = runGit(['rev-parse', '--verify', `${sha}^`], top);
+  return parent.status === 0 ? [parent.stdout.trim()] : ['--root'];
 };
 
-const applyFixup = (top, sha) => {
-  const spec = namedCommit(sha);
-  const commit = resolveCommit(top, spec);
+const fixupArgs = (top, sha) => {
+  const commit = resolveCommit(top, namedCommit(sha));
   const subject = commitSubject(top, commit);
   if (!isFixupSubject(subject)) throw new Error('not a fixup commit');
   const want = fixupRest(subject);
   if (!want) throw new Error('no fixup target');
   const original = ancestorWithSubject(top, commit, want);
   if (!original) throw new Error('no fixup target');
-  applyFixupOnto(top, original, applyAutosquash);
+  return [...AUTOSQUASH_ARGS, ...rebaseRange(top, original)];
 };
 
-const applyFixupAsync = async (top, sha) => {
-  const spec = namedCommit(sha);
-  const commit = resolveCommit(top, spec);
-  const subject = commitSubject(top, commit);
-  if (!isFixupSubject(subject)) throw new Error('not a fixup commit');
-  const want = fixupRest(subject);
-  if (!want) throw new Error('no fixup target');
-  const original = ancestorWithSubject(top, commit, want);
-  if (!original) throw new Error('no fixup target');
-  await applyFixupOnto(top, original, applyAutosquashAsync);
-};
+const applyFixup = (top, sha) => runRebase(top, fixupArgs(top, sha));
+
+const applyFixupAsync = async (top, sha) =>
+  runRebaseAsync(top, fixupArgs(top, sha));
 
 const messageBody = (message) => {
   const text = `${message ?? ''}`;
   return text.endsWith('\n') ? text : `${text}\n`;
 };
 
-const rewordHead = (top, message) => {
-  const args = ['commit', '--amend', '--only', '-F', '-'];
-  requireOk(runGit(args, top, messageBody(message)));
-};
+const REWORD_HEAD_ARGS = ['commit', '--amend', '--only', '-F', '-'];
 
 const REWORD_TODO = path.join(__dirname, 'git-reword-todo.js');
 
@@ -238,32 +266,11 @@ const prepareRewordEditor = (message) => {
   };
 };
 
-const rewordRange = (top, sha, env) => {
-  const parent = runGit(['rev-parse', '--verify', `${sha}^`], top);
-  const onto =
-    parent.status !== 0 ? ['--root'] : [(parent.stdout ?? '').trim()];
-  return runGit(['rebase', '--interactive', ...onto], top, undefined, { env });
-};
-
-const rewordRangeAsync = async (top, sha, env) => {
-  const parent = runGit(['rev-parse', '--verify', `${sha}^`], top);
-  const onto =
-    parent.status !== 0 ? ['--root'] : [(parent.stdout ?? '').trim()];
-  return runGitAsync(['rebase', '--interactive', ...onto], top, { env });
-};
-
-const finishRewordRebase = (top, result) => {
-  const failed = rebaseFailed(result);
-  if (!failed) return;
-  runGit(['rebase', '--abort'], top);
-  throw new Error(oneLine(failed));
-};
-
 const rewordOlder = (top, sha, message) => {
   const prepared = prepareRewordEditor(message);
   try {
-    const result = rewordRange(top, sha, prepared.env);
-    finishRewordRebase(top, result);
+    const args = ['rebase', '--interactive', ...rebaseRange(top, sha)];
+    runRebase(top, args, { env: prepared.env });
   } finally {
     fs.rmSync(prepared.dir, { recursive: true, force: true });
   }
@@ -272,29 +279,29 @@ const rewordOlder = (top, sha, message) => {
 const rewordOlderAsync = async (top, sha, message) => {
   const prepared = prepareRewordEditor(message);
   try {
-    const result = await rewordRangeAsync(top, sha, prepared.env);
-    const failed = rebaseFailed(result);
-    if (!failed) return;
-    await runGitAsync(['rebase', '--abort'], top);
-    throw new Error(oneLine(failed));
+    const args = ['rebase', '--interactive', ...rebaseRange(top, sha)];
+    await runRebaseAsync(top, args, { env: prepared.env });
   } finally {
     fs.rmSync(prepared.dir, { recursive: true, force: true });
   }
 };
 
 const rewordCommit = (top, sha, message) => {
-  const spec = namedCommit(sha);
-  const commit = resolveCommit(top, spec);
-  const head = resolveCommit(top, 'HEAD');
-  if (commit === head) return void rewordHead(top, message);
+  const commit = resolveCommit(top, namedCommit(sha));
+  if (commit === resolveCommit(top, 'HEAD')) {
+    requireOk(runGit(REWORD_HEAD_ARGS, top, messageBody(message)));
+    return;
+  }
   rewordOlder(top, commit, message);
 };
 
 const rewordCommitAsync = async (top, sha, message) => {
-  const spec = namedCommit(sha);
-  const commit = resolveCommit(top, spec);
-  const head = resolveCommit(top, 'HEAD');
-  if (commit === head) return void rewordHead(top, message);
+  const commit = resolveCommit(top, namedCommit(sha));
+  if (commit === resolveCommit(top, 'HEAD')) {
+    const input = messageBody(message);
+    requireOk(await runGitAsync(REWORD_HEAD_ARGS, top, { input }));
+    return;
+  }
   await rewordOlderAsync(top, commit, message);
 };
 
@@ -316,7 +323,7 @@ const parseBranchLine = (line) => {
   if (!name) return null;
   const mark = parts[0] ?? '';
   const sha = (parts[2] ?? '').trim();
-  const date = (parts[3] ?? '').trim();
+  const date = shortAge(parts[3] ?? '');
   const track = parseTrack(parts[4]);
   const subject = parts.slice(5).join('\t').trim();
   return {
@@ -361,13 +368,10 @@ const listBranches = (top) => {
   const names = new Set();
   for (const entry of branches) names.add(entry.name);
   const primary = defaultBranch(top, names);
-  const { length } = branches;
-  const listed = new Array(length);
-  for (let i = 0; i < length; i++) {
-    const entry = branches[i];
-    listed[i] = { ...entry, isDefault: entry.name === primary };
-  }
-  return listed;
+  return branches.map((entry) => ({
+    ...entry,
+    isDefault: entry.name === primary,
+  }));
 };
 
 const namedBranch = (name) => {
@@ -398,23 +402,11 @@ const createBranchAsync = async (top, name) => {
   requireOk(await runGitAsync(args, top), 'checkout failed');
 };
 
-const rebaseBranch = (top, onto) => {
-  const branch = namedBranch(onto);
-  const result = runGit(['rebase', branch], top);
-  const failed = rebaseFailed(result);
-  if (!failed) return;
-  runGit(['rebase', '--abort'], top);
-  throw new Error(oneLine(failed));
-};
+const rebaseBranch = (top, onto) =>
+  runRebase(top, ['rebase', namedBranch(onto)]);
 
-const rebaseBranchAsync = async (top, onto) => {
-  const branch = namedBranch(onto);
-  const result = await runGitAsync(['rebase', branch], top);
-  const failed = rebaseFailed(result);
-  if (!failed) return;
-  await runGitAsync(['rebase', '--abort'], top);
-  throw new Error(oneLine(failed));
-};
+const rebaseBranchAsync = async (top, onto) =>
+  runRebaseAsync(top, ['rebase', namedBranch(onto)]);
 
 const dropBranch = (top, name) => {
   const branch = namedBranch(name);
@@ -478,36 +470,31 @@ const pushCmd = (force, branch) => {
 const noUpstream = (msg) =>
   `${msg ?? ''}`.toLowerCase().includes('no upstream');
 
-const finishPush = (result, force, branch, run) => {
+const requirePushOk = (result) => {
   if (result.status === 0) return;
-  const msg = result.stderr || result.stdout || 'push failed';
-  if (!noUpstream(msg)) throw pushError(msg);
-  const next = run(pushCmd(force, branch));
-  if (next.status !== 0) {
-    throw pushError(next.stderr || next.stdout || 'push failed');
-  }
+  throw pushError(result.stderr || result.stdout || 'push failed');
 };
 
 const pushChanges = (top, force) => {
   const useForce = force === true;
   const branch = pushBranch(top);
   const tracked = hasUpstream(top) ? '' : branch;
-  const result = runGit(pushCmd(useForce, tracked), top);
-  finishPush(result, useForce, branch, (args) => runGit(args, top));
+  let result = runGit(pushCmd(useForce, tracked), top);
+  if (result.status !== 0 && noUpstream(result.stderr || result.stdout)) {
+    result = runGit(pushCmd(useForce, branch), top);
+  }
+  requirePushOk(result);
 };
 
 const pushChangesAsync = async (top, force) => {
   const useForce = force === true;
   const branch = pushBranch(top);
   const tracked = hasUpstream(top) ? '' : branch;
-  const result = await runGitAsync(pushCmd(useForce, tracked), top);
-  if (result.status === 0) return;
-  const msg = result.stderr || result.stdout || 'push failed';
-  if (!noUpstream(msg)) throw pushError(msg);
-  const next = await runGitAsync(pushCmd(useForce, branch), top);
-  if (next.status !== 0) {
-    throw pushError(next.stderr || next.stdout || 'push failed');
+  let result = await runGitAsync(pushCmd(useForce, tracked), top);
+  if (result.status !== 0 && noUpstream(result.stderr || result.stdout)) {
+    result = await runGitAsync(pushCmd(useForce, branch), top);
   }
+  requirePushOk(result);
 };
 
 const hasStaged = (top) => {
@@ -519,9 +506,7 @@ const commitPlan = (kind, message) => {
   const args = ['commit'];
   if (kind === 'amend') args.push('--amend');
   args.push('-F', '-');
-  const text = message ?? '';
-  const body = text.endsWith('\n') ? text : `${text}\n`;
-  return { args, body };
+  return { args, body: messageBody(message) };
 };
 
 const commitChanges = (top, kind, message) => {

package/lib/git-deps.js

@@ -8,12 +8,14 @@ const { foldDepItems, mergeDepFile, depFileMeta } = deps;
 const { parseAuditReport, parseOutdatedReport } = deps;
 const { mergeProposedItems, MANIFEST, LOCKFILE } = deps;
 const { collectUsedNames, collectExportMeta } = deps;
-const { itemPath, isPathInScope } = require('./files.js');
+const files = require('./files.js');
+const { itemPath, isPathInScope } = files;
 const proc = require('./utilities.js');
 const { abortError, npmBin, npmOpts, runProc, runProcSync } = proc;
-const git = require('./git.js');
+const git = require('./git-worktree.js');
 const { oneLine, requireOk, runGit } = git;
 const { gitText, worktreeText, readDepSides, revertOnePath } = git;
+const { writeFile, writeIndex } = git;
 
 const AUDIT_MS = 15000;
 const INSTALL_MS = 120000;
@@ -30,12 +32,12 @@ const npmProcOptions = (cwd, extra = {}) => ({
 const runNpm = (cwd, args) =>
   runProcSync(npmBin(), args, npmProcOptions(cwd, { timeout: INSTALL_MS }));
 
-const runNpmAsync = (cwd, args, extra = {}) =>
-  runProc(
-    npmBin(),
-    args,
-    npmProcOptions(cwd, { timeout: INSTALL_MS, signal: extra.signal }),
-  );
+const runNpmAsync = (cwd, args, extra = {}) => {
+  const bin = npmBin();
+  const signal = extra.signal;
+  const options = npmProcOptions(cwd, { timeout: INSTALL_MS, signal });
+  return runProc(bin, args, options);
+};
 
 const runNpmJson = (top, args, timeout) => {
   const result = runProcSync(npmBin(), args, npmProcOptions(top, { timeout }));
@@ -104,18 +106,6 @@ const hasProposed = (item) => {
   return !!(change && change.propose);
 };
 
-const relatedFiles = (items) => {
-  let size = 0;
-  for (const item of items) size += depPaths(item).length;
-  const files = new Array(size);
-  let i = 0;
-  for (const item of items) {
-    const paths = depPaths(item);
-    for (let j = 0; j < paths.length; j++) files[i++] = paths[j];
-  }
-  return files;
-};
-
 const itemsForPath = (rel, items) => {
   const group = [];
   for (const item of items) {
@@ -287,12 +277,6 @@ const loadExtras = async (snapshot, extra = {}) => {
   };
 };
 
-const writeWorktreeFile = (top, rel, text) => {
-  const abs = path.join(top, rel);
-  fs.mkdirSync(path.dirname(abs), { recursive: true });
-  fs.writeFileSync(abs, text);
-};
-
 const captureFile = (top, rel) => {
   const abs = path.join(top, rel);
   try {
@@ -327,16 +311,6 @@ const restoreFiles = (top, owned) => {
   for (const saved of owned) restoreFile(top, saved);
 };
 
-const writeIndexFile = (top, rel, text) => {
-  const saved = captureFile(top, rel);
-  writeWorktreeFile(top, rel, text);
-  try {
-    requireOk(runGit(['add', '--', rel], top));
-  } finally {
-    restoreFile(top, saved);
-  }
-};
-
 const mergeDepLive = (top, rel, change, origin, base, side, kind) => {
   const sides = readDepSides(top, null, origin, rel);
   return mergeDepFile(base, sides.oldText, sides.newText, change, side, kind);
@@ -347,7 +321,7 @@ const applyDepIndex = (top, rel, change, origin, side) => {
   if (!meta) return;
   const indexed = gitText(top, `:${rel}`) || gitText(top, `HEAD:${rel}`);
   const text = mergeDepLive(top, rel, change, origin, indexed, side, meta.kind);
-  writeIndexFile(top, rel, text);
+  writeIndex(top, rel, text);
 };
 
 const applyDepWorktree = (top, rel, change, origin) => {
@@ -363,7 +337,7 @@ const applyDepWorktree = (top, rel, change, origin) => {
     'old',
     meta.kind,
   );
-  writeWorktreeFile(top, rel, text);
+  writeFile(top, rel, text);
 };
 
 const ownedRelsOf = (plan) => {
@@ -399,7 +373,7 @@ const applyPreparation = (top, item, plan) => {
     'new',
     'manifest',
   );
-  writeWorktreeFile(top, plan.manifest, text);
+  writeFile(top, plan.manifest, text);
 };
 
 const stagePlan = (top, plan) => {
@@ -418,26 +392,14 @@ const finishPlan = (top, plan, result, stage) => {
   stageFn(top, plan);
 };
 
-const syncInstaller = (plan, extra) => {
-  if (extra.run) return extra.run;
-  if (plan.runner) return plan.runner;
-  return (dir) => runNpm(dir, plan.npmArgs);
-};
-
-const asyncInstaller = (plan, extra) => {
-  if (extra.run) return extra.run;
-  if (plan.runner) return (dir) => Promise.resolve(plan.runner(dir));
-  return (dir) => runNpmAsync(dir, plan.npmArgs);
-};
-
 const applyProposedUpdate = (top, item, extra = {}) => {
   const plan = proposedNpmPlan(top, item);
   if (!plan) return;
   const owned = captureFiles(top, ownedRelsOf(plan));
   try {
     applyPreparation(top, item, plan);
-    const install = syncInstaller(plan, extra);
-    const result = install(plan.cwd);
+    const install = extra.run ?? plan.runner ?? runNpm;
+    const result = install(plan.cwd, plan.npmArgs);
     finishPlan(top, plan, result, extra.stage);
   } catch (error) {
     restoreFiles(top, owned);
@@ -451,8 +413,8 @@ const applyProposedUpdateAsync = async (top, item, extra = {}) => {
   const owned = captureFiles(top, ownedRelsOf(plan));
   try {
     applyPreparation(top, item, plan);
-    const run = asyncInstaller(plan, extra);
-    const result = await run(plan.cwd);
+    const run = extra.run ?? plan.runner ?? runNpmAsync;
+    const result = await run(plan.cwd, plan.npmArgs);
     finishPlan(top, plan, result, extra.stage);
   } catch (error) {
     restoreFiles(top, owned);
@@ -525,7 +487,9 @@ const revertDepItem = (top, item) => {
 
 const revertFile = (top, rel, items) => {
   const paths = new Set([rel]);
-  for (const file of relatedFiles(items)) paths.add(file);
+  for (const item of items) {
+    for (const file of depPaths(item)) paths.add(file);
+  }
   for (const file of paths) {
     const group = itemsForPath(file, items);
     const targets = group.length ? group : items;
@@ -533,12 +497,8 @@ const revertFile = (top, rel, items) => {
   }
 };
 
-const handles = (item) => !!(item && item.dep);
-
 module.exports = {
   hasProposed,
-  handles,
-  relatedFiles,
   itemsForPath,
   finishLoad,
   loadExtras,