@antongolub/lockfile 0.0.0-snapshot.70 → 0.0.0-snapshot.72

package/dist/index.js

@@ -10609,6 +10609,12 @@ async function replaceVersion(graph, selector, toRange, context, options = {}) {
         currentGraph = currentGraph.mutate((m) => {
           for (const e of staleOut) m.removeEdge(targetId, e.dst, e.kind);
         }).graph;
+        for (const e of staleOut) {
+          const dst = currentGraph.getNode(e.dst);
+          if (dst !== void 0 && dst.workspacePath === void 0 && currentGraph.in(e.dst).length === 0) {
+            recentlyOrphaned.add(e.dst);
+          }
+        }
       }
       replaced.push({ from: node.id, to: targetId });
       recentlyAdded.add(targetId);
@@ -10939,6 +10945,12 @@ function optimize(graph, options = {}) {
       }
     }
   }
+  for (const node of graph.nodes()) {
+    if (!live.has(node.id)) continue;
+    if (node.patch === void 0 && node.source === void 0) continue;
+    const baseId = serializeNodeId(node.name, node.version, node.peerContext, void 0, void 0);
+    if (baseId !== node.id && graph.getNode(baseId) !== void 0) live.add(baseId);
+  }
   const removed = [];
   const unresolved = [];
   let next = graph;

package/dist/modify.js

@@ -628,6 +628,12 @@ async function replaceVersion(graph, selector, toRange, context, options = {}) {
         currentGraph = currentGraph.mutate((m) => {
           for (const e of staleOut) m.removeEdge(targetId, e.dst, e.kind);
         }).graph;
+        for (const e of staleOut) {
+          const dst = currentGraph.getNode(e.dst);
+          if (dst !== void 0 && dst.workspacePath === void 0 && currentGraph.in(e.dst).length === 0) {
+            recentlyOrphaned.add(e.dst);
+          }
+        }
       }
       replaced.push({ from: node.id, to: targetId });
       recentlyAdded.add(targetId);

package/dist/optimize.d.ts

@@ -9,9 +9,17 @@ interface PruneOrphansOptions {
     /**
      * Bound the sweep to a candidate set. When provided, ONLY these NodeIds (and
      * the closure they transitively strand) are removal candidates — any OTHER
-     * pre-existing in-degree-0 node is left untouched. Pass the mutation's removed
-     * / orphaned NodeIds (e.g. `replaceVersion`'s `recentlyOrphaned`) for a purely
-     * differential GC. Omit for a whole-graph sweep.
+     * pre-existing in-degree-0 node is left untouched.
+     *
+     * **Seeded is the SAFE / recommended mode for post-mutation GC.** Pass the
+     * mutation's orphaned NodeIds (`replaceVersion`'s `recentlyOrphaned` — which
+     * now includes the targets whose last incoming edge a rebind's edge-refresh
+     * dropped). The sweep then retires exactly that delta and CANNOT touch a node
+     * the mutation never affected — including ones that only LOOK orphaned because
+     * an incoming edge is unresolved in the parse (e.g. berry `@patch:…!builtin`
+     * fsevents). Omit only for a whole-graph sweep on a graph whose edges you trust
+     * to be complete; the unseeded path over-prunes such unresolved-edge nodes and
+     * is guarded against wiping a rootless lock (PRUNE_NO_ROOTS).
      */
     seed?: ReadonlySet<NodeId>;
 }
@@ -42,7 +50,7 @@ interface OptimizeDiagnostic extends Diagnostic {
  * rationale — the NodeId alone may carry a long peerContext suffix.
  */
 declare function optimizeNodeRemoved(nodeId: NodeId): OptimizeDiagnostic;
-type PruneDiagnosticCode = 'PRUNE_NODE_REMOVED' | 'PRUNE_NOOP';
+type PruneDiagnosticCode = 'PRUNE_NODE_REMOVED' | 'PRUNE_NOOP' | 'PRUNE_NO_ROOTS';
 interface PruneDiagnostic extends Diagnostic {
     code: PruneDiagnosticCode;
 }
@@ -50,6 +58,15 @@ interface PruneDiagnostic extends Diagnostic {
 declare function pruneNodeRemoved(nodeId: NodeId): PruneDiagnostic;
 /** Fires once per `pruneOrphans(graph)` call when nothing was removed. */
 declare function pruneNoop(): PruneDiagnostic;
+/**
+ * Fires when an UNSEEDED pruneOrphans runs on a non-empty graph with no
+ * workspace anchor (e.g. a rootless yarn-classic lock). Without a workspace
+ * every top-level dependency is itself in-degree 0, so a whole-graph sweep would
+ * cascade and wipe the lock. We no-op instead — the caller bounds the sweep with
+ * an explicit `seed` (or `preserve`) to GC a rootless graph. Mirrors
+ * OPTIMIZE_NO_ROOTS.
+ */
+declare function pruneNoRoots(): PruneDiagnostic;
 declare function optimizeWorkspaceUnreachable(nodeId: NodeId): OptimizeDiagnostic;
 /**
  * Fires once per `optimize(graph)` call when `removed.length === 0`. The
@@ -60,4 +77,4 @@ declare function optimizeWorkspaceUnreachable(nodeId: NodeId): OptimizeDiagnosti
  */
 declare function optimizeNoop(): OptimizeDiagnostic;
 
-export { type OptimizeDiagnostic, type OptimizeDiagnosticCode, type PruneDiagnostic, type PruneDiagnosticCode, type PruneOrphansOptions, type PruneOrphansResult, optimizeNodeRemoved, optimizeNoop, optimizeWorkspaceUnreachable, pruneNodeRemoved, pruneNoop, pruneOrphans };
+export { type OptimizeDiagnostic, type OptimizeDiagnosticCode, type PruneDiagnostic, type PruneDiagnosticCode, type PruneOrphansOptions, type PruneOrphansResult, optimizeNodeRemoved, optimizeNoop, optimizeWorkspaceUnreachable, pruneNoRoots, pruneNodeRemoved, pruneNoop, pruneOrphans };

package/dist/optimize.js

@@ -1,7 +1,7 @@
 import 'crypto';
 import 'buffer';
 
-// src/main/ts/recipe/patch.ts
+// src/main/ts/errors.ts
 
 // src/main/ts/graph.ts
 function nameOf(id) {
@@ -15,6 +15,16 @@ function nameOf(id) {
   }
   return lastAt < 0 ? id : id.slice(0, lastAt);
 }
+function serializeNodeId(name, version, peerContext, patch, source) {
+  const base = toTarballKey({ name, version});
+  if (peerContext.length === 0) return base;
+  return base + peerContext.map((p) => `(${p})`).join("");
+}
+function toTarballKey(inputs) {
+  const slots = [];
+  return slots.length === 0 ? `${inputs.name}@${inputs.version}` : `${inputs.name}@${inputs.version}+${slots.sort(cmpStr).join("+")}`;
+}
+var cmpStr = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 
 // src/main/ts/optimize/diagnostics.ts
 function optimizeNodeRemoved(nodeId) {
@@ -58,6 +68,14 @@ function pruneNoop() {
     message: "pruneOrphans: no unreferenced nodes to collect"
   };
 }
+function pruneNoRoots() {
+  return {
+    code: "PRUNE_NO_ROOTS",
+    severity: "warning",
+    subject: "graph",
+    message: "pruneOrphans: no workspace anchor and no seed on a non-empty graph \u2014 kept all nodes to avoid wiping a rootless lock"
+  };
+}
 function optimizeWorkspaceUnreachable(nodeId) {
   return {
     code: "OPTIMIZE_WORKSPACE_UNREACHABLE",
@@ -128,6 +146,12 @@ function optimize(graph, options = {}) {
       }
     }
   }
+  for (const node of graph.nodes()) {
+    if (!live.has(node.id)) continue;
+    if (node.patch === void 0 && node.source === void 0) continue;
+    const baseId = serializeNodeId(node.name, node.version, node.peerContext);
+    if (baseId !== node.id && graph.getNode(baseId) !== void 0) live.add(baseId);
+  }
   const removed = [];
   const unresolved = [];
   let next = graph;
@@ -177,12 +201,33 @@ function pruneOrphans(graph, options = {}) {
     if (onDiagnostic !== void 0) onDiagnostic(d);
   };
   let current = graph;
+  if (options.seed === void 0) {
+    let hasNodes = false;
+    let hasWorkspace = false;
+    for (const node of current.nodes()) {
+      hasNodes = true;
+      if (node.workspacePath !== void 0) {
+        hasWorkspace = true;
+        break;
+      }
+    }
+    if (hasNodes && !hasWorkspace) {
+      const diag = pruneNoRoots();
+      const guarded = current.mutate((m) => {
+        m.diagnostic(diag);
+      }).graph;
+      emit(diag);
+      return { graph: guarded, removed, unresolved };
+    }
+  }
   const collectable = (id) => {
     const node = current.getNode(id);
     if (node === void 0) return false;
     if (node.workspacePath !== void 0) return false;
     if (preserve.has(id)) return false;
-    return current.in(id).length === 0;
+    if (current.in(id).length > 0) return false;
+    if (hasLivePatchedVariant(current, node)) return false;
+    return true;
   };
   const queue = [];
   if (options.seed !== void 0) {
@@ -217,6 +262,18 @@ function pruneOrphans(graph, options = {}) {
   }
   return { graph: current, removed, unresolved };
 }
+function hasLivePatchedVariant(graph, node) {
+  if (node.patch !== void 0 || node.source !== void 0) return false;
+  for (const id of graph.byName(node.name)) {
+    if (id === node.id) continue;
+    const other = graph.getNode(id);
+    if (other === void 0) continue;
+    if (other.patch === void 0 && other.source === void 0) continue;
+    if (other.version !== node.version) continue;
+    if (serializeNodeId(other.name, other.version, other.peerContext) === node.id) return true;
+  }
+  return false;
+}
 function tarballSharedByOther(graph, removingId, key) {
   for (const id of graph.byName(key.name)) {
     if (id === removingId) continue;
@@ -226,4 +283,4 @@ function tarballSharedByOther(graph, removingId, key) {
   return false;
 }
 
-export { optimize, optimizeNodeRemoved, optimizeNoop, optimizeWorkspaceUnreachable, pruneNodeRemoved, pruneNoop, pruneOrphans };
+export { optimize, optimizeNodeRemoved, optimizeNoop, optimizeWorkspaceUnreachable, pruneNoRoots, pruneNodeRemoved, pruneNoop, pruneOrphans };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antongolub/lockfile",
-  "version": "0.0.0-snapshot.70",
+  "version": "0.0.0-snapshot.72",
   "private": false,
   "description": "Universal lockfile model and converter for npm, yarn, pnpm, bun",
   "type": "module",