mixdog 1.4.2 → 1.4.3

package/src/runtime/shared/worktrees/dependencies.mjs

@@ -20,24 +20,21 @@
  * Further stacks are one STACKS entry each (see there). Java (Gradle, Maven),
  * Rust and Go fetch on their own and need nothing.
  *
- * Only node_modules is ever linked: when the main checkout's same folder has
- * it installed (a real directory, never a link) and the lockfile is
- * byte-identical, the worktree's becomes a link to it (directory junction on
- * Windows, symlink elsewhere) at creation, recorded with the worktree's
- * include links so removal unlinks it before the checkout goes and never
- * traverses into the target. Everything else (a virtualenv is not
- * relocatable) is installed in the worktree folder at the start of the
- * session's first turn (setup-commands.mjs). A folder whose artefact already
- * exists in the worktree is left alone, so an install never runs through a
- * link into the main checkout; a link standing in for an artefact that is
- * never linked (a .venv) is noted as not prepared. A tool that is not on PATH
- * is skipped with a note.
+ * Nothing is shared with the main checkout: every artefact is installed in
+ * the worktree folder at the start of the session's first turn
+ * (setup-commands.mjs). A linked node_modules is never safe: `npm ci` lists
+ * the folder it finds and deletes each entry, which through a link (junction
+ * or symlink) are the main checkout's, and other installs prune or rebuild in
+ * place the same way. A folder whose artefact already exists in the worktree
+ * is left alone; while any is a link (made by hand, or by an earlier version
+ * and not yet detached, manager detachDependencyLinks), nothing in the
+ * worktree is installed, since an install can reach other folders than its
+ * own. A tool that is not on PATH is skipped with a note.
  */
 import { lstat, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { which } from '../../tidy/process.mjs';
 import { runGit } from './git.mjs';
-import { linkDirectory } from './include.mjs';
 import { runWorktreeSetupCommands } from './setup-commands.mjs';
 
 /** JS lockfile → package manager, in the order a folder with several picks one. */
@@ -86,9 +83,18 @@ async function yarnInstallFlag(tool, cwd, signal) {
  *   globs     committed basename globs it reads (`*` within a name), optional;
  *   artefact  the folder an install leaves: the main checkout having it
  *             admits a nested folder, the worktree having it skips the folder;
- *   linkable  only when the main checkout's artefact works as is through a
- *             link (then an identical `lockfile` is required); never for an
- *             install that embeds its own path (a virtualenv);
+ *   reinstallable  the artefact's whole contents come back from the install,
+ *             so an automatic worktree removal may drop it (dependencyArtefacts);
+ *             optional. node_modules is one by deliberate choice: hand edits
+ *             inside it (say, before patch-package saved them) are NOT
+ *             protected and go with the worktree — protecting it would stop
+ *             the cleanup of nearly every JS worktree, which only removes
+ *             merged, disposable or aged ones, and installs treat the folder
+ *             as their output (npm ci deletes and rebuilds it). Not so: .venv (pip reads a pip.conf inside it, index
+ *             credentials included), .bundle (local Bundler config, gem
+ *             source credentials), vendor and deps (dev and git dependencies
+ *             are git checkouts that can hold local commits), obj and
+ *             .dart_tool (build and tool state an install does not restore);
  *   pick(files)  the folder's committed basenames → { manager, lockfile?, … }
  *                or null;
  *   install(match, { cwd, tool, signal })
@@ -105,7 +111,7 @@ const STACKS = [
     stack: 'js',
     names: ['package.json', ...JS_LOCKFILES.map(([name]) => name)],
     artefact: 'node_modules',
-    linkable: true,
+    reinstallable: true,
     pick(files) {
       if (!files.has('package.json')) return null;
       const match = JS_LOCKFILES.find(([name]) => files.has(name));
@@ -289,29 +295,21 @@ function workspaceMatcher(patterns) {
   return (dir) => include.some((re) => re.test(dir)) && !exclude.some((re) => re.test(dir));
 }
 
-/** Whether `dir` holds the installed `artefact`: a real directory, never a link. */
-async function installedArtefact(dir, artefact) {
-  const info = await lstatOrNull(join(dir, artefact));
-  return !!info?.isDirectory() && !info.isSymbolicLink();
-}
-
 /**
- * What to prepare (forward-slash `dir` relative to `projectDir`; '' is the
- * project itself), root first: one entry per project folder and stack, with
- * the manager its committed files select. `mainDir`: the same folder in the
- * main checkout, whose installed artefacts admit nested folders.
- * @returns {Promise<Array<{ dir: string, stack: string, manager: string, artefact: string, linkable?: boolean,
- *   lockfile?: string, requirements?: string[] }>>}
+ * The folders (forward-slash, relative to `projectDir`, '' itself) holding
+ * committed files some stack reads, with those basenames; nothing inside
+ * node_modules. Empty when git cannot list them.
+ * @returns {Promise<Map<string, Set<string>>>}
  */
-export async function findLockfileFolders(projectDir, { mainDir = null, signal } = {}) {
+async function committedFolders(projectDir, signal) {
   const pathspecs = [...STACK_NAMES, ...STACK_GLOBS].map((name) => `:(glob)**/${name}`);
   const result = await runGit(projectDir, ['-c', 'core.quotePath=false', 'ls-files', '-z', '--', ...pathspecs], {
     signal,
     readOnly: true,
     allowFailure: true,
   });
-  if (result.code !== 0) return [];
   const folders = new Map();
+  if (result.code !== 0) return folders;
   for (const path of result.stdout.split('\0')) {
     const parts = path.split('/');
     const name = parts.pop();
@@ -320,6 +318,72 @@ export async function findLockfileFolders(projectDir, { mainDir = null, signal }
     if (!folders.has(dir)) folders.set(dir, new Set());
     folders.get(dir).add(name);
   }
+  return folders;
+}
+
+/** Whether `stack` reads the committed basename `name`. */
+function stackReads(stack, name) {
+  return stack.names.includes(name) || (stack.globs ?? []).some((glob) => matchesSegment(glob, name));
+}
+
+function matchesSegment(glob, name) {
+  return new RegExp(`^${segmentPattern(glob)}$`, 'i').test(name);
+}
+
+/**
+ * Every installed artefact in `projectDir` that is a link (forward-slash
+ * paths): the artefact of each folder with committed files of its stack, so
+ * a node_modules beside every committed package.json, the workspace packages
+ * that share the root lockfile too. Only the artefact itself is examined
+ * (lstat), never what a link points at. An install reaches beyond its own
+ * folder (`npm ci` at the root resets every workspace package's
+ * node_modules), so any one blocks every install in the worktree.
+ * @returns {Promise<string[]>}
+ */
+export async function linkedArtefacts(projectDir, { signal } = {}) {
+  const links = [];
+  for (const [dir, files] of await committedFolders(projectDir, signal)) {
+    for (const stack of STACKS) {
+      if (![...files].some((name) => stackReads(stack, name))) continue;
+      const info = await lstatOrNull(join(folderPath(projectDir, dir), stack.artefact));
+      if (info?.isSymbolicLink()) links.push([dir, stack.artefact].filter(Boolean).join('/'));
+    }
+  }
+  return links;
+}
+
+/**
+ * The artefacts an install restores whole in `projectDir` (forward-slash,
+ * relative to it): the artefact of every folder whose committed files a
+ * `reinstallable` stack installs from, wherever the folder is.
+ * @returns {Promise<string[]>}
+ */
+export async function dependencyArtefacts(projectDir, { signal } = {}) {
+  const artefacts = [];
+  for (const [dir, files] of await committedFolders(projectDir, signal)) {
+    for (const stack of STACKS) {
+      if (stack.reinstallable && stack.pick(files)) artefacts.push([dir, stack.artefact].filter(Boolean).join('/'));
+    }
+  }
+  return artefacts;
+}
+
+/** Whether `dir` holds the installed `artefact`: a real directory, never a link. */
+async function installedArtefact(dir, artefact) {
+  const info = await lstatOrNull(join(dir, artefact));
+  return !!info?.isDirectory() && !info.isSymbolicLink();
+}
+
+/**
+ * What to prepare (forward-slash `dir` relative to `projectDir`; '' is the
+ * project itself), root first: one entry per project folder and stack, with
+ * the manager its committed files select. `mainDir`: the same folder in the
+ * main checkout, whose installed artefacts admit nested folders.
+ * @returns {Promise<Array<{ dir: string, stack: string, manager: string, artefact: string,
+ *   lockfile?: string, requirements?: string[] }>>}
+ */
+export async function findLockfileFolders(projectDir, { mainDir = null, signal } = {}) {
+  const folders = await committedFolders(projectDir, signal);
   const isWorkspace = workspaceMatcher(await workspacePatterns(projectDir));
   const found = [];
   for (const [dir, files] of folders) {
@@ -329,56 +393,17 @@ export async function findLockfileFolders(projectDir, { mainDir = null, signal }
       const admitted =
         !dir || isWorkspace(dir) || (mainDir && (await installedArtefact(folderPath(mainDir, dir), stack.artefact)));
       if (admitted) {
-        found.push({ dir, stack: stack.stack, artefact: stack.artefact, linkable: stack.linkable === true, ...match });
+        found.push({ dir, stack: stack.stack, artefact: stack.artefact, ...match });
       }
     }
   }
   return found.sort((a, b) => a.dir.split('/').length - b.dir.split('/').length || a.dir.localeCompare(b.dir));
 }
 
-/** Whether the main checkout's installed artefact can stand in for the worktree's. */
-async function linkSource(mainDir, worktreeDir, { dir, lockfile, artefact }) {
-  if (!lockfile || !(await installedArtefact(folderPath(mainDir, dir), artefact))) return null;
-  const [mainLock, worktreeLock] = await Promise.all([
-    readOrNull(join(folderPath(mainDir, dir), lockfile)),
-    readOrNull(join(folderPath(worktreeDir, dir), lockfile)),
-  ]);
-  return mainLock && worktreeLock && mainLock.equals(worktreeLock) ? join(folderPath(mainDir, dir), artefact) : null;
-}
+const sharedClause = (count) =>
+  `${count > 1 ? 'are' : 'is'} shared from the main checkout by .worktreeinclude and not installed here`;
 
-/**
- * Link each linkable folder's artefact (node_modules) from the main checkout
- * where its lockfile is identical (creation time). `record(ledger)` is
- * awaited with status 'pending' before each link is made and 'created'
- * after, like an include link; a link that cannot be made is left to the
- * first-turn install.
- * @param {{ mainDir: string, worktreeDir: string, worktreeRel: string, signal?: AbortSignal,
- *   record: (ledger: object) => Promise<void> }} input `worktreeRel`: the project
- *   folder relative to the worktree's top level ('' at the top).
- * @returns {Promise<string[]>} The linked folders.
- */
-export async function linkWorktreeDependencies({ mainDir, worktreeDir, worktreeRel, signal, record }) {
-  const linked = [];
-  for (const folder of await findLockfileFolders(worktreeDir, { mainDir, signal })) {
-    if (!folder.linkable) continue;
-    const dest = join(folderPath(worktreeDir, folder.dir), folder.artefact);
-    if (await lstatOrNull(dest)) continue;
-    const source = await linkSource(mainDir, worktreeDir, folder);
-    if (!source) continue;
-    const rel = [worktreeRel, folder.dir, folder.artefact].filter(Boolean).join('/');
-    const ledger = { mode: 'link', rel, path: dest, status: 'pending', digest: null, source, dependency: true };
-    await record(ledger);
-    try {
-      await linkDirectory(source, dest);
-    } catch {
-      continue;
-    }
-    ledger.status = 'created';
-    await record(ledger);
-    linked.push(folder.dir);
-  }
-  return linked;
-}
+const sharedNote = (artefact, where) => `${artefact} in ${where} ${sharedClause(1)}.`;
 
 /** Display text of a command (never run through a shell). */
 const displayLine = (tool, args) => `${tool} ${args.map(quote).join(' ')}`;
@@ -390,39 +415,53 @@ function commandLine(tool, { args, followUp }) {
 /**
  * What the first turn still has to do in the worktree folder `worktreeDir`:
  * the installs (`commands`, setup-commands entries) and one line per folder
- * it leaves alone (`notes`: linked, nothing found, tool not on PATH, an
- * artefact that is a link it must not install through).
+ * it leaves alone (`notes`: nothing found, tool not on PATH, an artefact that
+ * is a link it must not install through).
  * `mainDir`: the same folder in the main checkout (findLockfileFolders).
  * `env`: where the tools are looked up (PATH).
- * @param {{ worktreeDir: string, mainDir?: string|null, signal?: AbortSignal, env?: NodeJS.ProcessEnv }} input
+ * `shared`: artefacts (forward-slash, relative to `worktreeDir`) that are links
+ * the user asked for in .worktreeinclude; they are never installed through or
+ * replaced, and are reported as shared rather than as a link to remove.
+ * @param {{ worktreeDir: string, mainDir?: string|null, shared?: string[], signal?: AbortSignal, env?: NodeJS.ProcessEnv }} input
  */
-export async function planDependencySetup({ worktreeDir, mainDir = null, signal, env = process.env }) {
+export async function planDependencySetup({ worktreeDir, mainDir = null, shared = [], signal, env = process.env }) {
   const folders = await findLockfileFolders(worktreeDir, { mainDir, signal });
   if (!folders.length) {
     return { commands: [], notes: ['No lockfile or dependency manifest found; nothing was installed.'] };
   }
   const commands = [];
   const notes = [];
-  const linked = [];
+  // While any artefact is a link nothing is installed (linkedArtefacts).
+  const links = await linkedArtefacts(worktreeDir, { signal });
   for (const entry of folders) {
     const cwd = folderPath(worktreeDir, entry.dir);
     const where = folderLabel(entry.dir);
-    const present = await lstatOrNull(join(cwd, entry.artefact));
-    if (present && (!present.isSymbolicLink() || entry.linkable)) {
-      if (present.isSymbolicLink()) linked.push(where);
-      continue;
-    }
+    const info = await lstatOrNull(join(cwd, entry.artefact));
+    if (info && !info.isSymbolicLink()) continue;
     const stack = STACKS.find((candidate) => candidate.stack === entry.stack);
     const named = await stack.install(entry, { cwd, signal });
     if (!named) continue;
-    if (present) {
-      // A link where the stack needs its own install (a virtualenv): not
-      // prepared, and never installed through into whatever it points at.
+    if (info && shared.includes([entry.dir, entry.artefact].filter(Boolean).join('/'))) {
+      notes.push(sharedNote(entry.artefact, where));
+      continue;
+    }
+    if (info) {
       notes.push(
-        `${entry.artefact} in ${where} is a link, not an environment of its own; ${where} was not prepared (replace it with \`${commandLine(named.tools[0], named)}\` there if tests need it).`
+        `${entry.artefact} in ${where} is a link, not an install of its own; ${where} was not prepared (replace it with \`${commandLine(named.tools[0], named)}\` there if tests need it).`
       );
       continue;
     }
+    const others = links.filter((rel) => !shared.includes(rel));
+    if (others.length) {
+      notes.push(
+        `${where} was not prepared while ${others.join(', ')} ${others.length > 1 ? 'are links' : 'is a link'} an install could reach through (run \`${commandLine(named.tools[0], named)}\` there once replaced if tests need it).`
+      );
+      continue;
+    }
+    if (links.length) {
+      notes.push(`${where} was not prepared; ${links.join(', ')} ${sharedClause(links.length)}.`);
+      continue;
+    }
     const found = named.tools.find((candidate) => which(candidate, { env }));
     if (!found) {
       notes.push(
@@ -451,6 +490,5 @@ export async function planDependencySetup({ worktreeDir, mainDir = null, signal,
       commands.push({ command: displayLine(`"${file}"`, args), file, args, cwd, label, ...specEnv });
     }
   }
-  if (linked.length) notes.unshift(`Linked node_modules from the main checkout: ${linked.join(', ')}.`);
   return { commands, notes };
 }

package/src/runtime/shared/worktrees/disk.mjs

@@ -4,9 +4,10 @@
  * space on the DESTINATION volume.
  */
 import { existsSync } from 'node:fs';
-import { statfs } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
+import { lstat, readdir, statfs } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
 import { runGit } from './git.mjs';
+import { pathKey } from './paths.mjs';
 
 const MARGIN_MIN_BYTES = 64 * 1024 * 1024;
 const MARGIN_RATIO = 0.1;
@@ -44,6 +45,82 @@ export function requiredBytes(contentBytes) {
   return contentBytes + Math.max(MARGIN_MIN_BYTES, Math.ceil(contentBytes * MARGIN_RATIO));
 }
 
+/**
+ * Bytes of the files under `path`. Links are not followed (linked dependency
+ * folders belong to the project folder); unreadable entries are skipped. The
+ * walk stops after `maxEntries`, reporting `complete: false` (a lower bound).
+ * @returns {Promise<{ bytes: number, complete: boolean }>}
+ */
+async function folderBytes(path, { maxEntries = 250_000 } = {}) {
+  let bytes = 0;
+  let seen = 0;
+  const pending = [path];
+  while (pending.length) {
+    const dir = pending.pop();
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (++seen > maxEntries) return { bytes, complete: false };
+      const child = join(dir, entry.name);
+      if (entry.isDirectory()) pending.push(child);
+      else if (entry.isFile())
+        bytes += await lstat(child).then(
+          (info) => info.size,
+          () => 0
+        );
+    }
+  }
+  return { bytes, complete: true };
+}
+
+// path key → { bytes, complete, at, refresh }: the worktree list's sizes.
+const sizeCache = new Map();
+const FOLDER_SIZE_TTL_MS = 5 * 60_000;
+// The repository's comparison key: canonical, case-folded only on Windows.
+const sizeKey = (path, platform) => pathKey(path, platform);
+
+/**
+ * folderBytes through a per-path cache: a fresh entry (younger than
+ * `ttlMs`) is returned as is; a stale one is returned at once while one
+ * background walk refreshes it; only a path never measured waits for its walk.
+ * forgetFolderSize drops an entry (the worktree was removed or created).
+ * @returns {Promise<{ bytes: number, complete: boolean, at: number }>}
+ */
+export async function cachedFolderBytes(
+  path,
+  { ttlMs = FOLDER_SIZE_TTL_MS, measure = folderBytes, platform = process.platform } = {}
+) {
+  const key = sizeKey(path, platform);
+  const cached = sizeCache.get(key);
+  const walk = () => {
+    const refresh = measure(path).then(
+      (value) => {
+        const entry = { ...value, at: Date.now(), refresh: null };
+        if (sizeCache.get(key)?.refresh === refresh) sizeCache.set(key, entry);
+        return entry;
+      },
+      (error) => {
+        if (sizeCache.get(key)?.refresh === refresh) sizeCache.delete(key);
+        throw error;
+      }
+    );
+    sizeCache.set(key, { ...(cached ?? { bytes: 0, complete: false, at: 0 }), refresh });
+    return refresh;
+  };
+  if (!cached) return walk();
+  if (!cached.refresh && Date.now() - cached.at >= ttlMs) walk().catch(() => {});
+  if (!cached.at) return cached.refresh;
+  return { bytes: cached.bytes, complete: cached.complete, at: cached.at };
+}
+
+export function forgetFolderSize(path, platform = process.platform) {
+  if (typeof path === 'string' && path) sizeCache.delete(sizeKey(path, platform));
+}
+
 /** Free bytes available to this user on the volume holding `path`. */
 export async function freeBytesAt(path) {
   let dir = resolve(path);

package/src/runtime/shared/worktrees/git.mjs

@@ -68,14 +68,16 @@ const READ_ONLY_FLAGS = ['--no-optional-locks', '-c', 'core.fsmonitor=false'];
 /**
  * @param {string} cwd
  * @param {string[]} args
- * @param {{ signal?: AbortSignal, timeoutMs?: number, maxBytes?: number, allowFailure?: boolean, readOnly?: boolean, env?: Record<string, string> }} [options]
+ * @param {{ signal?: AbortSignal, timeoutMs?: number, maxBytes?: number, allowFailure?: boolean, readOnly?: boolean, env?: Record<string, string>, waitForExitMs?: number }} [options]
  *   `env`: variables set on top of the pinned environment (a temporary GIT_INDEX_FILE, a commit identity).
+ *   `waitForExitMs`: a timeout rejects only once the killed git exited (or after that bound;
+ *   the error's `childExited` says which).
  * @returns {Promise<{ code: number, stdout: string, stderr: string }>}
  */
 export async function runGit(
   cwd,
   args,
-  { signal, timeoutMs, maxBytes, allowFailure = false, readOnly = false, env = null } = {}
+  { signal, timeoutMs, maxBytes, allowFailure = false, readOnly = false, env = null, waitForExitMs = 0 } = {}
 ) {
   throwIfAborted(signal);
   const result = await runGitOffThread([...(readOnly ? READ_ONLY_FLAGS : []), ...SCOPED_CONFIG, ...args], {
@@ -83,6 +85,7 @@ export async function runGit(
     env: env ? { ...gitEnvironment(), ...env } : gitEnvironment(),
     timeoutMs: timeoutMs ?? DEFAULT_TIMEOUT_MS,
     maxBytes: maxBytes ?? DEFAULT_MAX_BYTES,
+    waitForExitMs,
   });
   if (result.code !== 0 && !allowFailure) throw gitFailure(args, result);
   return result;
@@ -225,10 +228,14 @@ export async function branchCommit(cwd, branch, { signal } = {}) {
  *  answer is not exactly two commit ids: the caller then reads each with
  *  branchCommit(). */
 export async function branchCommitPair(cwd, first, second, { signal } = {}) {
-  const result = await runGit(cwd, ['rev-parse', `refs/heads/${first}^{commit}`, `refs/heads/${second}^{commit}`, '--'], {
-    signal,
-    allowFailure: true,
-  });
+  const result = await runGit(
+    cwd,
+    ['rev-parse', `refs/heads/${first}^{commit}`, `refs/heads/${second}^{commit}`, '--'],
+    {
+      signal,
+      allowFailure: true,
+    }
+  );
   const [a, b, dashes, ...rest] = String(result.stdout || '')
     .split(/\r?\n/)
     .map((line) => line.trim());
@@ -243,6 +250,23 @@ export async function localBranches(cwd, { signal, prefix = '' } = {}) {
   return lines(result.stdout);
 }
 
+/**
+ * Every local branch with the committer time of its tip (ISO-8601), in
+ * refname order. Ref names cannot hold a tab, so it separates the fields.
+ * @returns {Promise<Array<{ name: string, committedAt: string }>>}
+ */
+export async function localBranchCommits(cwd, { signal } = {}) {
+  const result = await runGit(
+    cwd,
+    ['for-each-ref', '--format=%(refname:short)%09%(committerdate:iso-strict)', 'refs/heads/'],
+    { signal }
+  );
+  return lines(result.stdout).map((line) => {
+    const tab = line.indexOf('\t');
+    return tab < 0 ? { name: line, committedAt: '' } : { name: line.slice(0, tab), committedAt: line.slice(tab + 1) };
+  });
+}
+
 /** The local branch names the repository's remotes declare as their default (`refs/remotes/<remote>/HEAD`). */
 export async function remoteDefaultBranches(cwd) {
   const result = await runGit(cwd, ['for-each-ref', '--format=%(refname) %(symref)', 'refs/remotes'], {
@@ -307,18 +331,27 @@ export async function listWorktrees(cwd, { signal } = {}) {
 }
 
 /**
- * Paths reported by `git status --porcelain=v1 -z`.
+ * Entries `{ code, path }` reported by `git status --porcelain=v1 -z` (`!!`:
+ * an ignored path, a folder with a trailing slash).
  * @param {string} raw
  */
-export function parseStatusPaths(raw) {
+export function parseStatusEntries(raw) {
   const fields = String(raw || '').split('\0');
-  const paths = [];
+  const entries = [];
   for (let index = 0; index < fields.length; index++) {
     const field = fields[index];
     if (field.length < 4) continue;
     const code = field.slice(0, 2);
-    paths.push(field.slice(3));
+    entries.push({ code, path: field.slice(3) });
     if (code.includes('R') || code.includes('C')) index++;
   }
-  return paths;
+  return entries;
+}
+
+/**
+ * Paths reported by `git status --porcelain=v1 -z`.
+ * @param {string} raw
+ */
+export function parseStatusPaths(raw) {
+  return parseStatusEntries(raw).map((entry) => entry.path);
 }

package/src/runtime/shared/worktrees/include.mjs

@@ -135,7 +135,7 @@ async function exists(path) {
 }
 
 /** Link the directory `source` at `dest`: a directory junction on Windows, a symlink elsewhere. */
-export function linkDirectory(source, dest) {
+function linkDirectory(source, dest) {
   return symlink(source, dest, process.platform === 'win32' ? 'junction' : 'dir');
 }
 
@@ -559,14 +559,16 @@ export async function removeIncludeLinks(items) {
 /**
  * Put back the links removeIncludeLinks took away (those that record their
  * `source`) after a removal that did not go through, each with its recorded
- * `linkType` (a record without one — dependency links, older records — is a
- * directory link). A path that exists again is left alone.
+ * `linkType` (a record without one, an older record, is a directory link). A
+ * path that exists again is left alone. An earlier version's dependency link
+ * (node_modules into the main checkout) is never put back: a reset through
+ * it empties the main checkout's folder.
  * @returns {Promise<Array<{ path: string, error: string }>>} Links that could not be restored.
  */
 export async function restoreIncludeLinks(items) {
   const failures = [];
   for (const item of items || []) {
-    if (item.mode !== 'link' || !item.source || item.status !== 'created') continue;
+    if (item.mode !== 'link' || !item.source || item.status !== 'created' || item.dependency) continue;
     if (await exists(item.path)) continue;
     try {
       await makeLinkOfType(item.linkType || 'directory', item.source, item.path);