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

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);

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

@@ -58,6 +58,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",
@@ -177,6 +185,25 @@ 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;
@@ -226,4 +253,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.71",
   "private": false,
   "description": "Universal lockfile model and converter for npm, yarn, pnpm, bun",
   "type": "module",