reslop 0.2.7 → 0.3.1

package/lib/{session → dashboard}/watch.js

@@ -3,14 +3,15 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const runs = require('../runs.js');
+const runs = require('../runs/runs.js');
 const { isRunsRel } = runs;
+const { REVIEW_DIR, posixRel } = require('../common/files.js');
 
 const DEBOUNCE_MS = 200;
 const UNKNOWN_PATH = '.';
 const MODULES_STAMP = 'node_modules/.package-lock.json';
 
-const SKIP_DIRS = ['node_modules', '.review', 'coverage', 'dist', '.cache'];
+const SKIP_DIRS = ['node_modules', REVIEW_DIR, 'coverage', 'dist', '.cache'];
 
 const GIT_WATCH_NAMES = [
   'HEAD',
@@ -23,32 +24,31 @@ const GIT_WATCH_NAMES = [
   'rebase-apply',
 ];
 
-const canWatchRecursive = (
-  platform = process.platform,
-  version = process.versions.node,
-) => {
-  if (platform === 'win32' || platform === 'darwin') return true;
-  if (platform !== 'linux') return false;
-  const [major, minor] = `${version}`.split('.').map(Number);
+const canWatchRecursive = (platform, version) => {
+  const host = platform ?? process.platform;
+  const node = version ?? process.versions.node;
+  if (host === 'win32' || host === 'darwin') return true;
+  if (host !== 'linux') return false;
+  const [major, minor] = `${node}`.split('.').map(Number);
   return major > 19 || (major === 19 && minor >= 1);
 };
 
 const IGNORED_SUFFIXES = ['.lock', '~', '.swp', '.swo'];
 
-const ignoredName = (name) =>
-  IGNORED_SUFFIXES.some((suffix) => name.endsWith(suffix)) ||
-  name.startsWith('.#') ||
-  name === '.DS_Store';
+const ignoredName = (name) => {
+  const suffix = IGNORED_SUFFIXES.some((item) => name.endsWith(item));
+  const backup = name.startsWith('.#');
+  const store = name === '.DS_Store';
+  return suffix || backup || store;
+};
 
 const ignoredGitRel = ([, name = '', sub]) => {
   if (name === 'logs' && sub === 'HEAD') return false;
   return name !== '' && !GIT_WATCH_NAMES.includes(name);
 };
 
-const slashRel = (rel) => `${rel}`.replaceAll('\\', '/');
-
 const ignoredRel = (rel) => {
-  const norm = slashRel(rel);
+  const norm = posixRel(rel);
   if (!norm || norm === '.') return false;
   if (norm === MODULES_STAMP) return false;
   const parts = norm.split('/');
@@ -60,15 +60,16 @@ const ignoredRel = (rel) => {
 const skipDirName = (name) => name === '.git' || SKIP_DIRS.includes(name);
 
 const reviewMarkdown = (rel) => {
-  if (!rel.startsWith('.review/')) return false;
-  const rest = rel.slice('.review/'.length);
+  const prefix = `${REVIEW_DIR}/`;
+  if (!rel.startsWith(prefix)) return false;
+  const rest = rel.slice(prefix.length);
   if (!rest || rest.includes('/')) return false;
   return rest.endsWith('.md');
 };
 
 const isReviewDir = (root, dir) => {
-  const rel = slashRel(path.relative(root, dir));
-  return rel === '.review' || rel.startsWith('.review/');
+  const rel = posixRel(path.relative(root, dir));
+  return rel === REVIEW_DIR || rel.startsWith(`${REVIEW_DIR}/`);
 };
 
 const hasFile = (full) => {
@@ -84,13 +85,13 @@ const isBareReviewName = (root, dir, rel) => {
   if (!rel || rel.includes('/')) return false;
   const base = path.basename(rel);
   if (hasFile(path.join(dir, base))) return false;
-  return hasFile(path.join(root, '.review', base));
+  return hasFile(path.join(root, REVIEW_DIR, base));
 };
 
 const isReviewEvent = (root, dir, name) => {
   if (isReviewDir(root, dir)) return true;
   if (!name) return false;
-  const rel = slashRel(path.relative(root, path.join(dir, name)));
+  const rel = posixRel(path.relative(root, path.join(dir, name)));
   if (reviewMarkdown(rel)) return true;
   return isBareReviewName(root, dir, rel);
 };
@@ -98,7 +99,7 @@ const isReviewEvent = (root, dir, name) => {
 const isOwnDirEvent = (dir, name) => {
   if (!name) return false;
   const base = path.basename(dir);
-  const slash = slashRel(name);
+  const slash = posixRel(name);
   const bare = slash.startsWith('./') ? slash.slice(2) : slash;
   const trimmed = bare.endsWith('/') ? bare.slice(0, -1) : bare;
   if (trimmed === base) {
@@ -153,8 +154,9 @@ class DiskWatcher {
     this.watchOne(gitDir);
     this.watchOne(path.join(gitDir, 'refs'));
     this.watchOne(path.join(gitDir, 'logs'));
+    this.watchOne(path.resolve(this.root, runs.logDir('.')));
     this.watchOne(path.resolve(this.root, runs.runsDir('.')));
-    this.watchOne(path.resolve(this.root, '.review'));
+    this.watchOne(path.resolve(this.root, REVIEW_DIR));
   }
 
   schedule(key, fire) {
@@ -211,9 +213,11 @@ class DiskWatcher {
   onEvent(dir, eventType, filename) {
     if (this.closed) return;
     const name = filename ? `${filename}` : '';
-    const rel = name
-      ? slashRel(path.relative(this.root, path.join(dir, name)))
-      : '';
+    let rel = '';
+    if (name) {
+      const full = path.join(dir, name);
+      rel = posixRel(path.relative(this.root, full));
+    }
     const wanted = this.files.has(rel);
     if (isRunsRel(rel)) {
       this.pending.add(rel);
@@ -260,12 +264,13 @@ class DiskWatcher {
   watchTree(dir) {
     this.watchOne(dir, this.recursive);
     if (this.recursive) return;
-    let entries;
+    let entries = null;
     try {
       entries = fs.readdirSync(dir, { withFileTypes: true });
     } catch {
-      return;
+      // unreadable directory
     }
+    if (!entries) return;
     for (const entry of entries) {
       if (!entry.isDirectory() || skipDirName(entry.name)) continue;
       this.watchTree(path.join(dir, entry.name));
@@ -280,7 +285,7 @@ class DiskWatcher {
       return;
     }
     const name = path.basename(full);
-    if (name === '.review') this.watchOne(full);
+    if (name === REVIEW_DIR) this.watchOne(full);
     else if (!skipDirName(name)) this.watchTree(full);
   }
 
@@ -299,7 +304,7 @@ class DiskWatcher {
     for (const rel of rels) {
       if (!rel) continue;
       const full = path.resolve(this.root, rel);
-      this.files.add(slashRel(path.relative(this.root, full)));
+      this.files.add(posixRel(path.relative(this.root, full)));
       this.watchOne(path.dirname(full));
     }
   }

package/lib/{workspace.js → dashboard/workspace.js}

@@ -3,16 +3,13 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
-const files = require('./files.js');
-const { REVIEW_DIR } = files;
-const review = require('./review.js');
+const { REVIEW_DIR } = require('../common/files.js');
+const review = require('../review/review.js');
 const { listReviewNames, latestReviewName, loadReview, noteCounts } = review;
-const worktree = require('./git-worktree.js');
-const { runGitAsync, countUntrackedAdded } = worktree;
-const model = require('./dashboard/model.js');
-const { runName } = model;
-const runs = require('./runs.js');
-const { readRuns } = runs;
+const { countUntrackedAdded } = require('../git/worktree.js');
+const { gitText, countOf } = require('./git.js');
+const { runName } = require('./model.js');
+const { readRuns } = require('../runs/runs.js');
 
 const emptyDiff = () => ({
   stagedAdded: 0,
@@ -31,12 +28,13 @@ const isRepoDir = (dir) => {
 };
 
 const listChildRepos = (dir) => {
-  let entries;
+  let entries = null;
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true });
   } catch {
-    return [];
+    // unreadable directory
   }
+  if (!entries) return [];
   const repos = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
@@ -49,12 +47,13 @@ const listChildRepos = (dir) => {
 };
 
 const workspaceAt = (dir) => {
-  let stat;
+  let stat = null;
   try {
     stat = fs.statSync(dir);
   } catch {
-    return null;
+    // missing path
   }
+  if (!stat) return null;
   if (!stat.isDirectory() || isRepoDir(dir)) return null;
   const repos = listChildRepos(dir);
   if (!repos.length) return null;
@@ -89,22 +88,18 @@ const sumNumstat = (text) => {
 };
 
 const readNumstat = async (dir, cached) => {
-  const args = cached
-    ? ['diff', '--cached', '--numstat']
-    : ['diff', '--numstat'];
-  try {
-    const result = await runGitAsync(args, dir);
-    if (result.status !== 0) return { added: 0, removed: 0 };
-    return sumNumstat(result.stdout);
-  } catch {
-    return { added: 0, removed: 0 };
-  }
+  const stagedArgs = ['diff', '--cached', '--numstat'];
+  const openArgs = ['diff', '--numstat'];
+  const args = cached ? stagedArgs : openArgs;
+  return sumNumstat(await gitText(dir, args));
 };
 
 const readDiffStat = async (dir) => {
-  const staged = await readNumstat(dir, true);
-  const open = await readNumstat(dir, false);
-  const untracked = await countUntrackedAdded(dir);
+  const [staged, open, untracked] = await Promise.all([
+    readNumstat(dir, true),
+    readNumstat(dir, false),
+    countUntrackedAdded(dir),
+  ]);
   return {
     stagedAdded: staged.added,
     unstagedAdded: open.added + untracked,
@@ -113,16 +108,8 @@ const readDiffStat = async (dir) => {
   };
 };
 
-const countCommits = async (dir) => {
-  try {
-    const result = await runGitAsync(['rev-list', '--count', 'HEAD'], dir);
-    if (result.status !== 0) return 0;
-    const value = parseInt(result.stdout.trim(), 10);
-    return Number.isFinite(value) ? value : 0;
-  } catch {
-    return 0;
-  }
-};
+const countCommits = async (dir) =>
+  countOf(await gitText(dir, ['rev-list', '--count', 'HEAD']));
 
 const taskStats = (dir) => {
   const latest = latestReviewName(listReviewNames(dir));
@@ -154,8 +141,6 @@ const pickRun = (dir) => {
 
 module.exports = {
   emptyDiff,
-  isRepoDir,
-  listChildRepos,
   workspaceAt,
   workspaceFromArgs,
   sumNumstat,

package/lib/{deps.js → deps/deps.js}

@@ -2,18 +2,15 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const metautil = require('metautil');
-const { jsonParse, isHashObject } = metautil;
-const files = require('./files.js');
-const { itemPath } = files;
-const utilities = require('./utilities.js');
-const { asText } = utilities;
+const { jsonParse, isHashObject } = require('metautil');
+const { itemPath, REVIEW_DIR } = require('../common/files.js');
+const { asText, readText, readJson } = require('../common/utilities.js');
 const manifest = require('./manifest.js');
 const { MANIFEST, LOCKFILE, SECTION_KEYS, isObject } = manifest;
 const { depFileMeta, relOf, listFilePath, readSections } = manifest;
 const { lockEntries, findDeclared, applyWantedRange } = manifest;
 const { proposedLockVersion, proposedWanted } = manifest;
-const depDiff = require('./deps-diff.js');
+const depDiff = require('./diff.js');
 const { summarizeGroup, collectGroups, takeManifestItems } = depDiff;
 const { foldedDepNames, stripFoldedDepItem } = depDiff;
 const { makeDepItems, stubFileItem } = depDiff;
@@ -26,17 +23,9 @@ const SPEC_PATTERNS = [
   /import\(\s*['"]([^'"]+)['"]\s*\)/g,
 ];
 const SCRIPT_RUNNERS = ['npx', 'npm', 'node'];
-const SKIP_WALK = ['node_modules', '.git', '.review', 'coverage', 'dist'];
+const SKIP_WALK = ['node_modules', '.git', REVIEW_DIR, 'coverage', 'dist'];
 const SEVERITY_RANK = { critical: 4, high: 3, moderate: 2, low: 1, info: 0 };
 
-const readText = (file) => {
-  try {
-    return fs.readFileSync(file, 'utf8');
-  } catch {
-    return '';
-  }
-};
-
 const toPackageName = (spec) => {
   if (!spec || spec.startsWith('.') || spec.startsWith('/')) return '';
   if (spec.startsWith('node:')) return '';
@@ -102,12 +91,13 @@ const pkgExportsLibrary = (pkg) => {
 };
 
 const walkUsedNames = (used, dir) => {
-  let entries;
+  let entries = null;
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true });
   } catch {
-    return;
+    // unreadable directory
   }
+  if (!entries) return;
   for (const entry of entries) {
     if (entry.isSymbolicLink()) continue;
     const full = path.join(dir, entry.name);
@@ -115,7 +105,7 @@ const walkUsedNames = (used, dir) => {
       const skip = SKIP_WALK.includes(entry.name) || entry.name.startsWith('.');
       if (!skip) walkUsedNames(used, full);
     } else if (entry.name === MANIFEST) {
-      collectUsedFromScripts(used, jsonParse(readText(full))?.scripts);
+      collectUsedFromScripts(used, readJson(full)?.scripts);
     } else if (SOURCE_EXT.includes(path.extname(entry.name))) {
       collectUsedFromText(used, readText(full));
     }
@@ -160,7 +150,7 @@ const collectExportEntries = (root, pkgDir, names) => {
 };
 
 const collectExportMeta = (root) => {
-  const pkg = jsonParse(readText(path.join(root, MANIFEST)));
+  const pkg = readJson(path.join(root, MANIFEST));
   const maps = readSections(pkg);
   const names = SECTION_KEYS.flatMap((key) => [...maps[key].keys()]);
   return collectExportEntries(root, '.', names);
@@ -288,8 +278,11 @@ const markChanges = (changes, report, kind) => {
 
 const depExports = (exportEntries, name) => exportEntries?.get(name) === true;
 
-const isAddedDep = (change) =>
-  change.action === 'added' && change.section !== 'resolved';
+const isAddedDep = (change) => {
+  const added = change.action === 'added';
+  const declared = change.section !== 'resolved';
+  return added && declared;
+};
 
 const unusedChangeNames = (changes, used) => {
   if (!used || !used.size) return [];
@@ -330,15 +323,10 @@ const unusedDeclaredChanges = (pkg, used, exportEntries) => {
     taken.add(name);
     const action = 'removed';
     const to = '';
-    changes.push({
-      name,
-      section,
-      action,
-      from,
-      to,
-      propose: true,
-      unused: true,
-    });
+    const propose = true;
+    const unused = true;
+    const change = { name, section, action, from, to, propose, unused };
+    changes.push(change);
   }
   return changes;
 };
@@ -438,28 +426,26 @@ const placeFolded = (items, { folded, synthetic, leftoverNames }) => {
   return spliceAtSlots(out, synthetic, slot);
 };
 
-const foldDepItems = (
-  items,
-  readSides = () => ({ oldText: '', newText: '' }),
-  usedNames = null,
-  audit = null,
-  outdated = null,
-  extra = {},
-) => {
+const foldDepItems = (items, readSides, usedNames, audit, outdated, extra) => {
+  const read = readSides ?? (() => ({ oldText: '', newText: '' }));
+  const used = usedNames ?? null;
+  const auditMap = audit ?? null;
+  const outdatedMap = outdated ?? null;
+  const options = extra ?? {};
   const groups = collectGroups(items);
   if (!groups.size) return items;
   const folded = new Set();
   const synthetic = new Map();
   const leftoverNames = new Map();
   for (const [key, group] of groups) {
-    const summary = summarizeGroup(group, readSides);
-    const unusedNames = unusedChangeNames(summary.changes, usedNames);
-    const exportEntries = loadExportEntries(unusedNames, extra, group.dir);
+    const summary = summarizeGroup(group, read);
+    const unusedNames = unusedChangeNames(summary.changes, used);
+    const exportEntries = loadExportEntries(unusedNames, options, group.dir);
     const { pkg } = summary;
     let changes = summary.changes;
-    changes = markUnusedChanges(changes, usedNames, pkg, exportEntries);
-    changes = markChanges(changes, audit, 'audit');
-    changes = markChanges(changes, outdated, 'outdated');
+    changes = markUnusedChanges(changes, used, pkg, exportEntries);
+    changes = markChanges(changes, auditMap, 'audit');
+    changes = markChanges(changes, outdatedMap, 'outdated');
     const next = { ...summary, changes };
     leftoverNames.set(key, foldedDepNames(changes));
     const taken = takeManifestItems(next);

package/lib/{deps-diff.js → deps/diff.js}

@@ -1,13 +1,10 @@
 'use strict';
 
-const metautil = require('metautil');
-const { jsonParse } = metautil;
-const files = require('./files.js');
-const { itemPath } = files;
-const patch = require('./diff/patch.js');
+const { jsonParse } = require('metautil');
+const { itemPath } = require('../common/files.js');
+const patch = require('../diff/patch.js');
 const { countSides, formatHunkHeader, formatPatch } = patch;
-const diff = require('./diff/diff.js');
-const { isCtxType } = diff;
+const { isCtxType } = require('../diff/diff.js');
 const manifest = require('./manifest.js');
 const { MANIFEST, LOCKFILE, SECTION_KEYS, depFileMeta, relOf } = manifest;
 const { listFilePath, readSections, emptySectionMaps } = manifest;
@@ -66,8 +63,10 @@ const lineEntryName = (text) => {
   return entry ? entry[1] : '';
 };
 
-const lineInBlock = (item, line) =>
-  typeof item.blockId !== 'number' || line.blockId === item.blockId;
+const lineInBlock = (item, line) => {
+  const open = typeof item.blockId !== 'number';
+  return open || line.blockId === item.blockId;
+};
 
 const hunkOnlyFoldedDeps = (item, names) => {
   if (!item.hunk || !names.size) return false;
@@ -86,8 +85,10 @@ const hunkOnlyFoldedDeps = (item, names) => {
 
 const stripFoldedDepItem = (item, names) => {
   if (!item.hunk || !names.size) return item;
-  const isFolded = (line) =>
-    line.type !== 'ctx' && names.has(lineEntryName(line.text));
+  const isFolded = (line) => {
+    const changed = line.type !== 'ctx';
+    return changed && names.has(lineEntryName(line.text));
+  };
   const lines = item.hunk.lines.filter((line) => !isFolded(line));
   if (lines.length === item.hunk.lines.length) return item;
   const isEdit = (line) => line.type !== 'ctx' && lineInBlock(item, line);
@@ -164,8 +165,15 @@ const mergeResolved = (changes, oldResolved, newResolved, oldMaps, newMaps) => {
     const action = changeAction(from, to);
     const resolvedFrom = from;
     const resolvedTo = to;
-    const section = 'resolved';
-    merged.push({ name, section, action, from, to, resolvedFrom, resolvedTo });
+    merged.push({
+      name,
+      section: 'resolved',
+      action,
+      from,
+      to,
+      resolvedFrom,
+      resolvedTo,
+    });
   }
   return merged;
 };
@@ -194,29 +202,31 @@ const readJsonSides = (readSides, origin, rel) => {
 
 const sectionMapsOf = (pkg, lock, manifestItems) => {
   if (pkg.before || pkg.after) {
-    return {
-      oldMaps: readSections(pkg.before),
-      newMaps: readSections(pkg.after),
-    };
+    const oldMaps = readSections(pkg.before);
+    const newMaps = readSections(pkg.after);
+    return { oldMaps, newMaps };
   }
   if (manifestItems.length) return mapsFromHunks(manifestItems);
   const oldMaps = lockRootSections(lock.before);
-  return { oldMaps, newMaps: lockRootSections(lock.after) };
+  const newMaps = lockRootSections(lock.after);
+  return { oldMaps, newMaps };
 };
 
 const manifestPolicy = (manifestItems, pkg, hasChanges) => {
   if (!manifestItems.length) {
-    return { foldManifest: false, takeAllManifest: false };
+    const foldManifest = false;
+    const takeAllManifest = false;
+    return { foldManifest, takeAllManifest };
   }
   if (pkg.before || pkg.after) {
     const onlyDeps = !hasFieldChanges(pkg.before, pkg.after);
-    return {
-      foldManifest: hasChanges,
-      takeAllManifest: hasChanges && onlyDeps,
-    };
+    const foldManifest = hasChanges;
+    const takeAllManifest = hasChanges && onlyDeps;
+    return { foldManifest, takeAllManifest };
   }
-  const fold = hasChanges && manifestItems.every(isDepOnlyItem);
-  return { foldManifest: fold, takeAllManifest: fold };
+  const foldManifest = hasChanges && manifestItems.every(isDepOnlyItem);
+  const takeAllManifest = foldManifest;
+  return { foldManifest, takeAllManifest };
 };
 
 const summarizeGroup = (group, readSides) => {

package/lib/{manifest.js → deps/manifest.js}

@@ -1,14 +1,10 @@
 'use strict';
 
-const path = require('node:path');
-const metautil = require('metautil');
-const { isHashObject, jsonParse } = metautil;
-const utilities = require('./utilities.js');
-const { parseVersion, cmpVersion } = utilities;
-
-const MANIFEST = 'package.json';
-const LOCKFILE = 'package-lock.json';
-const DEP_KIND = { [MANIFEST]: 'manifest', [LOCKFILE]: 'lockfile' };
+const { isHashObject, jsonParse } = require('metautil');
+const { parseVersion, cmpVersion } = require('../common/utilities.js');
+const files = require('../common/files.js');
+const { MANIFEST, LOCKFILE, depFileMeta, relOf, listFilePath } = files;
+
 const SECTION_KEYS = [
   'dependencies',
   'devDependencies',
@@ -19,23 +15,6 @@ const LOCK_PREFIX = 'node_modules/';
 
 const isObject = (value) => !!value && typeof value === 'object';
 
-const posixRel = (rel) => `${rel ?? ''}`.replaceAll('\\', '/');
-
-const depFileMeta = (rel) => {
-  const normalized = posixRel(rel);
-  const kind = DEP_KIND[path.posix.basename(normalized)];
-  if (!normalized || !kind) return null;
-  return { kind, dir: path.posix.dirname(normalized) };
-};
-
-const relOf = (dir, name) => (dir === '.' ? name : `${dir}/${name}`);
-
-const listFilePath = (rel) => {
-  const meta = depFileMeta(rel);
-  if (meta && meta.kind === 'lockfile') return relOf(meta.dir, MANIFEST);
-  return posixRel(rel);
-};
-
 const readSectionMap = (pkg, key) => {
   const map = new Map();
   const raw = pkg ? pkg[key] : null;
@@ -155,14 +134,17 @@ const seedManifest = (oldObj, newObj) => {
   return base;
 };
 
+const mergedBase = (parsedBase, oldObj, newObj, kind) => {
+  if (parsedBase) return cloneJson(parsedBase);
+  if (kind === 'manifest') return seedManifest(oldObj, newObj);
+  return cloneJson(oldObj) || {};
+};
+
 const mergeDepFile = (baseText, oldText, newText, change, side, kind) => {
   const oldObj = jsonParse(oldText ?? '');
   const newObj = jsonParse(newText ?? '');
   const parsedBase = jsonParse(baseText ?? '');
-  let base;
-  if (parsedBase) base = cloneJson(parsedBase);
-  else if (kind === 'manifest') base = seedManifest(oldObj, newObj);
-  else base = cloneJson(oldObj) || {};
+  const base = mergedBase(parsedBase, oldObj, newObj, kind);
   if (kind === 'lockfile') applyLockChange(base, change, side, oldObj, newObj);
   else applyManifestChange(base, change, side);
   return stringifyJson(base, baseText || newText || oldText || '');
@@ -247,7 +229,42 @@ const proposedWanted = (out, vul) => {
   return '';
 };
 
+const cmpText = (left, right) => {
+  const a = parseVersion(left);
+  const b = parseVersion(right);
+  if (!a || !b) return null;
+  return cmpVersion(a, b);
+};
+
+const boundHolds = (cmp, op) => {
+  if (op === '<') return cmp < 0;
+  if (op === '<=') return cmp <= 0;
+  if (op === '>') return cmp > 0;
+  return cmp >= 0;
+};
+
+const inClause = (version, clause) => {
+  const ver = parseVersion(version);
+  if (!ver) return false;
+  const bounds = [...clause.matchAll(/(>=|<=|>|<)\s*(\d+\.\d+\.\d+)/g)];
+  if (!bounds.length) return false;
+  for (const match of bounds) {
+    const bound = parseVersion(match[2]);
+    if (!bound) return false;
+    if (!boundHolds(cmpVersion(ver, bound), match[1])) return false;
+  }
+  return true;
+};
+
+const inRange = (version, range) =>
+  `${range ?? ''}`.split('||').some((clause) => inClause(version, clause));
+
+const hasRange = (range) => /[<>]=?\s*\d+\.\d+\.\d+/.test(`${range ?? ''}`);
+
 module.exports = {
+  cmpText,
+  inRange,
+  hasRange,
   MANIFEST,
   LOCKFILE,
   SECTION_KEYS,

package/lib/diff/align.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const inline = require('./inline.js');
-const { diffChars, tokenSimilarity } = inline;
+const { diffChars, tokenSimilarity } = require('./inline.js');
 
 const PAIR_MIN_SIM = 0.3;
 const PAIR_HEAD_WEIGHT = 0.4;

package/lib/diff/diff.js

@@ -5,7 +5,6 @@ const align = require('./align.js');
 const parse = require('./parse.js');
 const patch = require('./patch.js');
 const display = require('./display.js');
-const edit = require('./edit.js');
 const items = require('./items.js');
 const unit = require('./unit.js');
 
@@ -19,7 +18,8 @@ module.exports = {
   flattenBlock: patch.flattenBlock,
   formatPatch: patch.formatPatch,
   ...display,
-  ...edit,
+  addBlockRange: patch.addBlockRange,
+  replaceBlockAdds: patch.replaceBlockAdds,
   ...items,
   ...unit,
 };