reslop 0.2.5 → 0.2.7

package/lib/deps-diff.js

@@ -13,25 +13,29 @@ const { MANIFEST, LOCKFILE, SECTION_KEYS, depFileMeta, relOf } = manifest;
 const { listFilePath, readSections, emptySectionMaps } = manifest;
 const { lockRootSections, lockEntries, lockPackageCount } = manifest;
 
-const SECTION_ORDER = [...SECTION_KEYS, 'resolved', 'field'];
+const SECTION_ORDER = [...SECTION_KEYS, 'resolved'];
 const ACTION_ORDER = ['added', 'removed', 'changed', 'vulnerable'];
 const SECTION_NAMES = SECTION_KEYS.join('|');
 const SECTION_OPEN = new RegExp(`^\\s*"(${SECTION_NAMES})"\\s*:\\s*\\{\\s*$`);
 const SECTION_END = /^\s*\},?\s*$/;
 const DEP_ENTRY = /^\s*"([^"]+)"\s*:\s*"([^"]*)"\s*,?\s*$/;
+const DEP_CAPTION = 'Dependencies in package.json & package-lock.json';
+
+const changeAction = (hadOld, hasNew) => {
+  if (!hadOld) return 'added';
+  if (!hasNew) return 'removed';
+  return 'changed';
+};
+
+const sortedUnion = (left, right) => [...new Set([...left, ...right])].sort();
 
 const diffMaps = (oldMap, newMap, section) => {
-  const keys = [...oldMap.keys(), ...newMap.keys()];
-  const names = [...new Set(keys)];
-  names.sort();
   const changes = [];
-  for (const name of names) {
-    const from = oldMap.has(name) ? oldMap.get(name) : '';
-    const to = newMap.has(name) ? newMap.get(name) : '';
+  for (const name of sortedUnion(oldMap.keys(), newMap.keys())) {
+    const from = oldMap.get(name) ?? '';
+    const to = newMap.get(name) ?? '';
     if (from === to) continue;
-    let action = 'changed';
-    if (!oldMap.has(name)) action = 'added';
-    else if (!newMap.has(name)) action = 'removed';
+    const action = changeAction(oldMap.has(name), newMap.has(name));
     changes.push({ name, section, action, from, to });
   }
   return changes;
@@ -40,64 +44,37 @@ const diffMaps = (oldMap, newMap, section) => {
 const diffSections = (oldMaps, newMaps) =>
   SECTION_KEYS.flatMap((key) => diffMaps(oldMaps[key], newMaps[key], key));
 
-const fieldText = (value) => {
-  if (value === undefined) return '';
-  if (typeof value === 'string') return value;
-  return JSON.stringify(value);
-};
-
-const diffOtherFields = (oldPkg, newPkg) => {
-  if (!oldPkg && !newPkg) return [];
+const hasFieldChanges = (oldPkg, newPkg) => {
   const oldObj = oldPkg ?? {};
   const newObj = newPkg ?? {};
-  const keys = [...Object.keys(oldObj), ...Object.keys(newObj)];
-  const names = [...new Set(keys)];
-  names.sort();
-  const changes = [];
-  for (const name of names) {
+  for (const name of new Set([
+    ...Object.keys(oldObj),
+    ...Object.keys(newObj),
+  ])) {
     if (SECTION_KEYS.includes(name)) continue;
-    const prev = oldObj[name];
-    const next = newObj[name];
-    if (JSON.stringify(prev) === JSON.stringify(next)) continue;
-    let action = 'changed';
-    if (!Object.hasOwn(oldObj, name)) action = 'added';
-    else if (!Object.hasOwn(newObj, name)) action = 'removed';
-    const from = fieldText(prev);
-    const to = fieldText(next);
-    const section = 'field';
-    changes.push({ name, section, action, from, to });
+    const prev = JSON.stringify(oldObj[name]);
+    if (prev !== JSON.stringify(newObj[name])) return true;
   }
-  return changes;
+  return false;
 };
 
-const foldedDepNames = (changes) => {
-  const names = new Set();
-  for (const change of changes) {
-    if (change.section === 'field') continue;
-    names.add(change.name);
-  }
-  return names;
-};
+const foldedDepNames = (changes) =>
+  new Set(changes.map((change) => change.name));
 
 const lineEntryName = (text) => {
   const entry = DEP_ENTRY.exec(text);
   return entry ? entry[1] : '';
 };
 
-const lineInBlock = (item, line) => {
-  const blockId = item.blockId;
-  if (typeof blockId !== 'number') return true;
-  return line.blockId === blockId;
-};
+const lineInBlock = (item, line) =>
+  typeof item.blockId !== 'number' || line.blockId === item.blockId;
 
 const hunkOnlyFoldedDeps = (item, names) => {
   if (!item.hunk || !names.size) return false;
   let folded = 0;
   for (const line of item.hunk.lines) {
-    if (line.type === 'ctx') continue;
-    if (!lineInBlock(item, line)) continue;
-    const name = lineEntryName(line.text);
-    if (name && names.has(name)) {
+    if (line.type === 'ctx' || !lineInBlock(item, line)) continue;
+    if (names.has(lineEntryName(line.text))) {
       folded += 1;
       continue;
     }
@@ -109,67 +86,33 @@ const hunkOnlyFoldedDeps = (item, names) => {
 
 const stripFoldedDepItem = (item, names) => {
   if (!item.hunk || !names.size) return item;
-  const lines = [];
-  let removed = false;
-  for (const line of item.hunk.lines) {
-    if (line.type !== 'ctx') {
-      const name = lineEntryName(line.text);
-      if (name && names.has(name)) {
-        removed = true;
-        continue;
-      }
-    }
-    lines.push(line);
-  }
-  if (!removed) return item;
-  let hasEdit = false;
-  for (const line of lines) {
-    if (line.type === 'ctx') continue;
-    if (!lineInBlock(item, line)) continue;
-    hasEdit = true;
-    break;
-  }
-  if (!hasEdit) return null;
-  const counts = countSides(lines);
-  const hunk = {
-    ...item.hunk,
-    oldCount: counts.oldCount,
-    newCount: counts.newCount,
-    header: formatHunkHeader(
-      item.hunk.oldStart,
-      counts.oldCount,
-      item.hunk.newStart,
-      counts.newCount,
-    ),
-    lines,
-  };
+  const isFolded = (line) =>
+    line.type !== 'ctx' && 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);
+  if (!lines.some(isEdit)) return null;
+  const { oldStart, newStart } = item.hunk;
+  const { oldCount, newCount } = countSides(lines);
+  const header = formatHunkHeader(oldStart, oldCount, newStart, newCount);
+  const hunk = { ...item.hunk, oldCount, newCount, header, lines };
   const patchAdd = formatPatch(item.file, hunk, item.blockId, 'old');
   const patchRevert = formatPatch(item.file, hunk, item.blockId, 'new');
   return { ...item, hunk, patchAdd, patchRevert };
 };
 
-const onlyDepEdits = (items) => {
-  if (!items.length) return false;
-  for (const item of items) {
-    if (!item.hunk) return false;
-    const blockId = item.blockId;
-    const scoped = typeof blockId === 'number';
-    let section = '';
-    for (const line of item.hunk.lines) {
-      const open = SECTION_OPEN.exec(line.text);
-      let nextSection = section;
-      if (open) nextSection = open[1];
-      else if (section && SECTION_END.test(line.text)) nextSection = '';
-      const inBlock = !scoped || line.blockId === blockId;
-      if (inBlock && line.type !== 'ctx') {
-        const inDep = !!(open || section);
-        if (!inDep) return false;
-        const isEntry = DEP_ENTRY.test(line.text);
-        const isClose = SECTION_END.test(line.text);
-        if (!open && !isEntry && !isClose) return false;
-      }
-      section = nextSection;
+const isDepOnlyItem = (item) => {
+  if (!item.hunk) return false;
+  let section = '';
+  for (const line of item.hunk.lines) {
+    const open = SECTION_OPEN.exec(line.text);
+    const close = SECTION_END.test(line.text);
+    if (line.type !== 'ctx' && lineInBlock(item, line) && !open) {
+      if (!section) return false;
+      if (!close && !DEP_ENTRY.test(line.text)) return false;
     }
+    if (open) section = open[1];
+    else if (close) section = '';
   }
   return true;
 };
@@ -190,56 +133,38 @@ const mapsFromHunks = (items) => {
         section = '';
         continue;
       }
-      if (!section) continue;
-      const entry = DEP_ENTRY.exec(line.text);
+      const entry = section ? DEP_ENTRY.exec(line.text) : null;
       if (!entry) continue;
       const name = entry[1];
       const version = entry[2];
-      if (line.type === 'del' || line.type === 'ctx') {
-        oldMaps[section].set(name, version);
-      }
-      if (line.type === 'add' || line.type === 'ctx') {
-        newMaps[section].set(name, version);
-      }
+      const isCtx = line.type === 'ctx';
+      if (isCtx || line.type === 'del') oldMaps[section].set(name, version);
+      if (isCtx || line.type === 'add') newMaps[section].set(name, version);
     }
   }
   return { oldMaps, newMaps };
 };
 
-const directNames = (oldMaps, newMaps) => {
-  const names = new Set();
-  for (const key of SECTION_KEYS) {
-    for (const name of oldMaps[key].keys()) names.add(name);
-    for (const name of newMaps[key].keys()) names.add(name);
-  }
-  return names;
-};
-
 const mergeResolved = (changes, oldResolved, newResolved, oldMaps, newMaps) => {
-  const seen = new Set();
-  const { length } = changes;
-  const merged = new Array(length);
-  for (let i = 0; i < length; i++) {
-    const change = changes[i];
-    seen.add(change.name);
-    const resolvedFrom = oldResolved.get(change.name) ?? '';
-    const resolvedTo = newResolved.get(change.name) ?? '';
-    merged[i] = { ...change, resolvedFrom, resolvedTo };
-  }
-  const names = [...directNames(oldMaps, newMaps)];
-  names.sort();
-  for (const name of names) {
+  const merged = changes.map((change) => ({
+    ...change,
+    resolvedFrom: oldResolved.get(change.name) ?? '',
+    resolvedTo: newResolved.get(change.name) ?? '',
+  }));
+  const seen = new Set(changes.map((change) => change.name));
+  const direct = SECTION_KEYS.flatMap((key) => [
+    ...oldMaps[key].keys(),
+    ...newMaps[key].keys(),
+  ]);
+  for (const name of [...new Set(direct)].sort()) {
     if (seen.has(name)) continue;
     const from = oldResolved.get(name) ?? '';
     const to = newResolved.get(name) ?? '';
     if (from === to) continue;
-    if (!from && !to) continue;
-    let action = 'changed';
-    if (!from) action = 'added';
-    else if (!to) action = 'removed';
-    const section = 'resolved';
+    const action = changeAction(from, to);
     const resolvedFrom = from;
     const resolvedTo = to;
+    const section = 'resolved';
     merged.push({ name, section, action, from, to, resolvedFrom, resolvedTo });
   }
   return merged;
@@ -255,128 +180,81 @@ const compareChangeOrder = (left, right) => {
   return left.name.localeCompare(right.name);
 };
 
-const orderedChanges = (changes) => [...changes].sort(compareChangeOrder);
+const kindOf = (rel) => depFileMeta(rel)?.kind;
 
 const kindItems = (items, kind) =>
-  items.filter((item) => depFileMeta(itemPath(item))?.kind === kind);
-
-const readGroupSnapshot = (group, readSides) => {
-  const origin = group.origin;
-  const dir = group.dir;
-  const groupItems = group.items;
-  const manifestItems = kindItems(groupItems, 'manifest');
-  const lockItems = kindItems(groupItems, 'lockfile');
-  const manifestRel = relOf(dir, MANIFEST);
-  const lockRel = relOf(dir, LOCKFILE);
-  const manifestSides = readSides(origin, manifestRel);
-  const lockSides = readSides(origin, lockRel);
-  const oldPkg = jsonParse(manifestSides.oldText ?? '');
-  const newPkg = jsonParse(manifestSides.newText ?? '');
-  const oldLock = jsonParse(lockSides.oldText ?? '');
-  const newLock = jsonParse(lockSides.newText ?? '');
-  const parsedManifest = !!(oldPkg || newPkg);
-  return {
-    origin,
-    dir,
-    groupItems,
-    manifestItems,
-    lockItems,
-    oldPkg,
-    newPkg,
-    oldLock,
-    newLock,
-    parsedManifest,
-  };
-};
+  items.filter((item) => kindOf(itemPath(item)) === kind);
 
-const sectionMapsOf = (snapshot) => {
-  if (snapshot.parsedManifest) {
-    const oldMaps = readSections(snapshot.oldPkg);
-    const newMaps = readSections(snapshot.newPkg);
-    return { oldMaps, newMaps };
-  }
-  if (snapshot.manifestItems.length) {
-    return mapsFromHunks(snapshot.manifestItems);
-  }
-  const oldMaps = lockRootSections(snapshot.oldLock);
-  const newMaps = lockRootSections(snapshot.newLock);
-  return { oldMaps, newMaps };
+const readJsonSides = (readSides, origin, rel) => {
+  const sides = readSides(origin, rel);
+  const before = jsonParse(sides.oldText ?? '');
+  const after = jsonParse(sides.newText ?? '');
+  return { before, after };
 };
 
-const comparedChanges = (snapshot) => {
-  const maps = sectionMapsOf(snapshot);
-  const oldMaps = maps.oldMaps;
-  const newMaps = maps.newMaps;
-  const manifestChanges = diffSections(oldMaps, newMaps);
-  const parsed = snapshot.parsedManifest;
-  let otherChanges = [];
-  if (parsed) {
-    otherChanges = diffOtherFields(snapshot.oldPkg, snapshot.newPkg);
+const sectionMapsOf = (pkg, lock, manifestItems) => {
+  if (pkg.before || pkg.after) {
+    return {
+      oldMaps: readSections(pkg.before),
+      newMaps: readSections(pkg.after),
+    };
   }
-  const oldResolved = lockEntries(snapshot.oldLock);
-  const newResolved = lockEntries(snapshot.newLock);
-  const changes = mergeResolved(
-    manifestChanges,
-    oldResolved,
-    newResolved,
-    oldMaps,
-    newMaps,
-  );
-  const oldCount = lockPackageCount(snapshot.oldLock);
-  const newCount = lockPackageCount(snapshot.newLock);
-  return { changes, otherChanges, oldCount, newCount };
+  if (manifestItems.length) return mapsFromHunks(manifestItems);
+  const oldMaps = lockRootSections(lock.before);
+  return { oldMaps, newMaps: lockRootSections(lock.after) };
 };
 
-const foldingPolicy = (snapshot, compared) => {
-  const foldLock = snapshot.lockItems.length > 0;
-  const hasDepChanges = compared.changes.length > 0;
-  if (!snapshot.manifestItems.length) {
-    const foldManifest = false;
-    const takeAllManifest = false;
-    return { foldLock, foldManifest, takeAllManifest };
+const manifestPolicy = (manifestItems, pkg, hasChanges) => {
+  if (!manifestItems.length) {
+    return { foldManifest: false, takeAllManifest: false };
   }
-  if (snapshot.parsedManifest) {
-    const foldManifest = hasDepChanges;
-    const takeAllManifest = hasDepChanges && compared.otherChanges.length === 0;
-    return { foldLock, foldManifest, takeAllManifest };
+  if (pkg.before || pkg.after) {
+    const onlyDeps = !hasFieldChanges(pkg.before, pkg.after);
+    return {
+      foldManifest: hasChanges,
+      takeAllManifest: hasChanges && onlyDeps,
+    };
   }
-  const foldManifest = hasDepChanges && onlyDepEdits(snapshot.manifestItems);
-  const takeAllManifest = foldManifest;
-  return { foldLock, foldManifest, takeAllManifest };
+  const fold = hasChanges && manifestItems.every(isDepOnlyItem);
+  return { foldManifest: fold, takeAllManifest: fold };
 };
 
 const summarizeGroup = (group, readSides) => {
-  const snapshot = readGroupSnapshot(group, readSides);
-  const compared = comparedChanges(snapshot);
-  const policy = foldingPolicy(snapshot, compared);
+  const { origin, dir } = group;
+  const manifestItems = kindItems(group.items, 'manifest');
+  const lockItems = kindItems(group.items, 'lockfile');
+  const pkg = readJsonSides(readSides, origin, relOf(dir, MANIFEST));
+  const lock = readJsonSides(readSides, origin, relOf(dir, LOCKFILE));
+  const { oldMaps, newMaps } = sectionMapsOf(pkg, lock, manifestItems);
+  const changes = mergeResolved(
+    diffSections(oldMaps, newMaps),
+    lockEntries(lock.before),
+    lockEntries(lock.after),
+    oldMaps,
+    newMaps,
+  );
   return {
-    changes: compared.changes,
-    oldCount: compared.oldCount,
-    newCount: compared.newCount,
-    foldLock: policy.foldLock,
-    foldManifest: policy.foldManifest,
-    takeAllManifest: policy.takeAllManifest,
-    manifestItems: snapshot.manifestItems,
-    lockItems: snapshot.lockItems,
-    pkg: snapshot.newPkg || snapshot.oldPkg,
+    changes,
+    oldCount: lockPackageCount(lock.before),
+    newCount: lockPackageCount(lock.after),
+    foldLock: lockItems.length > 0,
+    ...manifestPolicy(manifestItems, pkg, changes.length > 0),
+    manifestItems,
+    lockItems,
+    pkg: pkg.after || pkg.before,
   };
 };
 
 const collectGroups = (items) => {
   const groups = new Map();
   for (const item of items) {
-    const rel = itemPath(item);
-    const meta = depFileMeta(rel);
+    const meta = depFileMeta(itemPath(item));
     if (!meta) continue;
     const key = `${item.origin}\0${meta.dir}`;
-    let group = groups.get(key);
-    if (!group) {
-      const dir = meta.dir;
-      const origin = item.origin;
-      group = { dir, origin, items: [] };
-      groups.set(key, group);
+    if (!groups.has(key)) {
+      groups.set(key, { dir: meta.dir, origin: item.origin, items: [] });
     }
-    group.items.push(item);
+    groups.get(key).items.push(item);
   }
   return groups;
 };
@@ -385,17 +263,11 @@ const takeManifestItems = (summary) => {
   if (!summary.foldManifest) return [];
   if (summary.takeAllManifest) return [...summary.manifestItems];
   const names = foldedDepNames(summary.changes);
-  const taken = [];
-  for (const item of summary.manifestItems) {
-    if (onlyDepEdits([item]) || hunkOnlyFoldedDeps(item, names)) {
-      taken.push(item);
-    }
-  }
-  return taken;
+  return summary.manifestItems.filter(
+    (item) => isDepOnlyItem(item) || hunkOnlyFoldedDeps(item, names),
+  );
 };
 
-const DEP_CAPTION = 'Dependencies in package.json & package-lock.json';
-
 const changeMarks = (change) => {
   const marks = [];
   if (change.unused) marks.push('unused');
@@ -405,191 +277,113 @@ const changeMarks = (change) => {
 };
 
 const changeSources = (change) => {
+  if (change.unused) return ['npm uninstall'];
   const sources = [];
-  if (change.unused) {
-    sources.push('npm uninstall');
-    return sources;
-  }
   if (change.propose && change.outdated) sources.push('npm outdated');
   if (change.audit) sources.push('npm audit');
   return sources;
 };
 
-const sectionTitle = (section, action, marks, sources) => {
+const sectionTitle = (change, marks, sources) => {
+  const { section, action } = change;
   const title = action === 'changed' ? 'version changed' : action;
   const kind = section.replace(/ies$/, 'y');
   let label = `${kind} ${title}`;
-  if (section === 'field') label = `package.json ${title}`;
   if (section === 'resolved' && action === 'vulnerable') {
     label = 'lockfile vulnerable';
   } else if (section === 'resolved') {
     label = `lockfile resolved ${title}`;
   }
-  if (marks.includes('unused')) {
-    label = `${kind} unused`;
-    const extra = [];
-    for (const mark of marks) {
-      if (mark !== 'unused') extra.push(mark);
-    }
-    if (extra.length) label = `${label}, ${extra.join(', ')}`;
-  } else if (marks.length) {
-    label = `${label}, ${marks.join(', ')}`;
-  }
+  if (marks.includes('unused')) label = `${kind} unused`;
+  const extra = marks.filter((mark) => mark !== 'unused');
+  if (extra.length) label = `${label}, ${extra.join(', ')}`;
   if (!sources.length) return label;
   return `${sources.join(', ')}: ${label}`;
 };
 
-const entryText = (change, side) => {
-  const version = side === 'old' ? change.from : change.to;
-  return `"${change.name}": "${version}"`;
-};
-
-const ctxLine = (text) => ({ type: 'ctx', text });
-const warnLine = (text) => ({ type: 'warn', text });
-const noteLine = (text) => ({ type: 'note', text });
-const noteSepLine = () => ({ type: 'noteSep', text: '' });
+const row = (type, text) => ({ type, text });
 
-const changeLine = (type, change, side) => {
-  const text = entryText(change, side);
-  return { type, text };
+const entryRow = (type, change, side) => {
+  const version = side === 'old' ? change.from : change.to;
+  return row(type, `"${change.name}": "${version}"`);
 };
 
-const pushChangeLines = (rows, change) => {
+const changeLines = (change) => {
   if (change.unused) {
     const side = change.action === 'added' ? 'new' : 'old';
-    rows.push(changeLine('del', change, side));
-    return;
-  }
-  if (change.action === 'added') {
-    rows.push(changeLine('add', change, 'new'));
-    return;
-  }
-  if (change.action === 'removed') {
-    rows.push(changeLine('del', change, 'old'));
-    return;
+    return [entryRow('del', change, side)];
   }
-  if (change.from === change.to) {
-    rows.push(changeLine('ctx', change, 'old'));
-    return;
-  }
-  rows.push(changeLine('del', change, 'old'));
-  rows.push(changeLine('add', change, 'new'));
+  if (change.action === 'added') return [entryRow('add', change, 'new')];
+  if (change.action === 'removed') return [entryRow('del', change, 'old')];
+  if (change.from === change.to) return [entryRow('ctx', change, 'old')];
+  return [entryRow('del', change, 'old'), entryRow('add', change, 'new')];
 };
 
-const lockCountText = (oldCount, newCount) => {
-  if (oldCount === newCount) return '';
-  return `lockfile packages  ${oldCount} → ${newCount}`;
-};
-
-const auditNoteTexts = (audit) => {
+const auditRows = (audit) => {
   if (!audit) return [];
-  const notes = [];
-  if (Array.isArray(audit.titles)) {
-    for (const note of audit.titles) {
-      if (note && !notes.includes(note)) notes.push(note);
-    }
-  } else if (audit.title) {
-    notes.push(audit.title);
+  const titles = Array.isArray(audit.titles) ? audit.titles : [audit.title];
+  const notes = [...new Set(titles.filter(Boolean))];
+  const prefix = `npm audit  ${audit.severity}`;
+  if (!notes.length) return [row('ctx', ''), row('note', prefix)];
+  const rows = [row('ctx', '')];
+  for (const note of notes) {
+    if (rows.length > 1) rows.push(row('noteSep', ''));
+    rows.push(row('note', `${prefix}  ${note}`));
   }
-  const severity = audit.severity;
-  if (!notes.length) return [`npm audit  ${severity}`];
-  return notes.map((note) => `npm audit  ${severity}  ${note}`);
+  return rows;
 };
 
-const pushAuditNotes = (rows, audit) => {
-  const texts = auditNoteTexts(audit);
-  if (!texts.length) return;
-  rows.push(ctxLine(''));
-  let first = true;
-  for (const text of texts) {
-    if (!first) rows.push(noteSepLine());
-    first = false;
-    rows.push(noteLine(text));
-  }
+const changeRows = (change) => {
+  const sources = changeSources(change);
+  const title = sectionTitle(change, changeMarks(change), sources);
+  const audited = sources.includes('npm audit');
+  return [
+    row('ctx', DEP_CAPTION),
+    row('ctx', ''),
+    row(audited ? 'warn' : 'ctx', title),
+    row('ctx', ''),
+    ...changeLines(change),
+    ...auditRows(change.audit),
+  ];
 };
 
-const buildRows = (change, oldCount, newCount) => {
-  const rows = [ctxLine(DEP_CAPTION), ctxLine('')];
-  if (change) {
-    const marks = changeMarks(change);
-    const sources = changeSources(change);
-    const title = sectionTitle(change.section, change.action, marks, sources);
-    const audited = sources.includes('npm audit');
-    rows.push(audited ? warnLine(title) : ctxLine(title));
-    rows.push(ctxLine(''));
-    pushChangeLines(rows, change);
-    pushAuditNotes(rows, change.audit);
-  }
-  const countLine = lockCountText(oldCount, newCount);
-  if (countLine) {
-    if (rows.at(-1).text !== '') rows.push(ctxLine(''));
-    rows.push(ctxLine(countLine));
-  }
-  return rows;
-};
-
-const toHunkLine = (row, blockId) => ({
-  type: row.type,
-  text: row.text,
-  noNl: false,
-  blockId: isCtxType(row.type) ? null : blockId,
-});
+const countRows = (oldCount, newCount) => [
+  row('ctx', DEP_CAPTION),
+  row('ctx', ''),
+  row('ctx', `lockfile packages  ${oldCount} → ${newCount}`),
+];
 
 const makeHunk = (rows, blockId) => {
-  const lines = rows.map((row) => toHunkLine(row, blockId));
-  const counts = countSides(lines);
-  const oldCount = counts.oldCount;
-  const newCount = counts.newCount;
+  const lines = rows.map((entry) => ({
+    type: entry.type,
+    text: entry.text,
+    noNl: false,
+    blockId: isCtxType(entry.type) ? null : blockId,
+  }));
+  const { oldCount, newCount } = countSides(lines);
   const header = `@@ -1,${oldCount} +1,${newCount} @@`;
   return { oldStart: 1, oldCount, newStart: 1, newCount, header, lines };
 };
 
-const uniquePaths = (items) => {
-  const files = [];
-  const seen = new Set();
-  for (const item of items) {
-    const rel = itemPath(item);
-    if (!rel || seen.has(rel)) continue;
-    seen.add(rel);
-    files.push(rel);
-  }
-  return files;
-};
-
-const filesForChange = (change, files) => {
-  const manifest = [];
-  const lockfile = [];
-  for (const rel of files) {
-    const meta = depFileMeta(rel);
-    if (!meta) continue;
-    if (meta.kind === 'manifest') manifest.push(rel);
-    else lockfile.push(rel);
-  }
-  if (change.section === 'resolved') return lockfile.length ? lockfile : files;
-  if (change.section === 'field' || change.propose) {
-    return manifest.length ? manifest : files;
+const filesForChange = (change, rels) => {
+  const manifests = rels.filter((rel) => kindOf(rel) === 'manifest');
+  const lockfiles = rels.filter((rel) => kindOf(rel) === 'lockfile');
+  if (change.section === 'resolved') {
+    return lockfiles.length ? lockfiles : rels;
   }
-  return manifest.length || lockfile.length
-    ? [...manifest, ...lockfile]
-    : files;
+  if (change.propose) return manifests.length ? manifests : rels;
+  const both = [...manifests, ...lockfiles];
+  return both.length ? both : rels;
 };
 
-const pickPrimary = (items) => {
-  for (const item of items) {
-    const rel = itemPath(item);
-    const meta = depFileMeta(rel);
-    if (meta && meta.kind === 'manifest') return item;
-  }
-  return items[0];
-};
-
-const makeDepItem = (origin, fileItems, hidden, change, extra, blockId) => {
-  const allFiles = uniquePaths(fileItems);
-  const files = change ? filesForChange(change, allFiles) : allFiles;
-  const primary = pickPrimary(fileItems);
+const makeDepItem = (origin, fileItems, hidden, change, rows, blockId) => {
+  const paths = new Set(fileItems.map((item) => itemPath(item)));
+  const rels = [...paths].filter(Boolean);
+  const files = change ? filesForChange(change, rels) : rels;
+  const primary =
+    fileItems.find((item) => kindOf(itemPath(item)) === 'manifest') ??
+    fileItems[0];
   const rel = listFilePath(itemPath(primary));
-  const counts = change ? {} : extra;
-  const rows = buildRows(change, counts.oldCount ?? 0, counts.newCount ?? 0);
   const hunk = makeHunk(rows, blockId);
   return {
     origin,
@@ -612,16 +406,17 @@ const makeDepItem = (origin, fileItems, hidden, change, extra, blockId) => {
 };
 
 const makeDepItems = (origin, fileItems, hidden, summary) => {
-  const ordered = orderedChanges(summary.changes);
-  if (!ordered.length) {
-    const oldCount = summary.oldCount ?? 0;
-    const newCount = summary.newCount ?? 0;
-    if (oldCount === newCount) return [];
-    return [makeDepItem(origin, fileItems, hidden, null, summary, 0)];
-  }
-  return ordered.map((change, index) =>
-    makeDepItem(origin, fileItems, hidden, change, summary, index),
-  );
+  const ordered = [...summary.changes].sort(compareChangeOrder);
+  if (ordered.length) {
+    return ordered.map((change, index) =>
+      makeDepItem(origin, fileItems, hidden, change, changeRows(change), index),
+    );
+  }
+  const oldCount = summary.oldCount ?? 0;
+  const newCount = summary.newCount ?? 0;
+  if (oldCount === newCount) return [];
+  const rows = countRows(oldCount, newCount);
+  return [makeDepItem(origin, fileItems, hidden, null, rows, 0)];
 };
 
 const stubFileItem = (rel, origin) => ({