@vltpkg/graph 1.0.0-rc.3 → 1.0.0-rc.31

package/dist/{esm/graph.js → graph.js}

@@ -1,7 +1,7 @@
-import { getId, joinDepIDTuple } from '@vltpkg/dep-id';
+import { getId, joinDepIDTuple, splitExtra } from '@vltpkg/dep-id';
 import { error } from '@vltpkg/error-cause';
 import { satisfies } from '@vltpkg/satisfies';
-import { Spec } from '@vltpkg/spec';
+import { getOptions, Spec } from '@vltpkg/spec';
 import { inspect } from 'node:util';
 import { lockfileData } from "./lockfile/save.js";
 import { Edge } from "./edge.js";
@@ -17,7 +17,7 @@ const getMap = (m) => m ?? new Map();
  * Get a cache key for a resolution based on the
  * spec, location and query modifier.
  */
-const getResolutionCacheKey = (spec, location, queryModifier) => {
+const getResolutionCacheKey = (spec, location, extra) => {
     const f = spec.final;
     // if it's a file: dep, then the fromNode location matters
     const fromPrefix = f.type === 'file' ? location + ' : ' : '';
@@ -29,7 +29,7 @@ const getResolutionCacheKey = (spec, location, queryModifier) => {
         : f.gitRemote ?
             `${cacheKeySeparator}git` + `${cacheKeySeparator}${f.gitRemote}`
             : `${cacheKeySeparator}${f.type}`;
-    const modifierSuffix = `${cacheKeySeparator}${queryModifier}`;
+    const modifierSuffix = `${cacheKeySeparator}${extra}`;
     return fromPrefix + String(f) + typePrecisionKey + modifierSuffix;
 };
 export class Graph {
@@ -82,13 +82,40 @@ export class Graph {
      * The root of the project this graph represents
      */
     projectRoot;
+    /**
+     * The peer context sets used to resolve peer dependencies within this graph.
+     */
+    peerContexts;
+    /**
+     * Cache of forked peer contexts so identical fork operations can reuse
+     * previously created contexts instead of duplicating them.
+     *
+     * Key format is internal and constructed in `ideal/peers.ts`.
+     */
+    peerContextForkCache = new Map();
+    /**
+     * Tracks the current peer context index.
+     */
+    currentPeerContextIndex = 0;
     constructor(options) {
         const { mainManifest, monorepo } = options;
         this.#options = options;
+        // hydrate spec options to their full contents, including defaults
+        const specOptions = getOptions({
+            registry: options.registry,
+            registries: options.registries,
+            'git-hosts': options['git-hosts'],
+            'git-host-archives': options['git-host-archives'],
+            'scoped-registries': options['scoped-registries'],
+            'jsr-registries': options['jsr-registries'],
+            catalog: options.catalog,
+            catalogs: options.catalogs,
+        });
         this.manifests = getMap(options.manifests);
         this.projectRoot = options.projectRoot;
         this.#nodeOptions = {
             ...this.#options,
+            ...specOptions,
             graph: this,
         };
         // add the project root node
@@ -110,6 +137,12 @@ export class Graph {
                 wsNode.setImporterLocation(`./${ws.path}`);
                 if (wsNode.manifest) {
                     this.manifests.set(wsNode.id, wsNode.manifest);
+                    // set bins for workspace nodes so they can be linked
+                    // when another importer depends on this workspace
+                    /* c8 ignore next 3 - tested by integration tests */
+                    if (wsNode.manifest.bin) {
+                        wsNode.bins = wsNode.manifest.bin;
+                    }
                 }
                 this.importers.add(wsNode);
                 // creates a virtual edge to connect the workspaces to the root node
@@ -117,6 +150,16 @@ export class Graph {
                 this.mainImporter.workspaces.set(wsNode.name, edge);
             }
         }
+        // initializes the peer context set collection
+        const initialPeerContext = new Map();
+        initialPeerContext.index = this.currentPeerContextIndex;
+        this.peerContexts = [initialPeerContext];
+    }
+    /**
+     * Get the next peer context index.
+     */
+    nextPeerContextIndex() {
+        return ++this.currentPeerContextIndex;
     }
     /**
      * Delete all nodes and edges that are unreachable from the importers.
@@ -191,9 +234,9 @@ export class Graph {
     /**
      * Find an existing node to satisfy a dependency
      */
-    findResolution(spec, fromNode, queryModifier = '') {
+    findResolution(spec, fromNode, extra = '') {
         const f = spec.final;
-        const sf = getResolutionCacheKey(f, fromNode.location, queryModifier);
+        const sf = getResolutionCacheKey(f, fromNode.location, extra);
         const cached = this.resolutions.get(sf);
         if (cached)
             return cached;
@@ -217,7 +260,10 @@ export class Graph {
         this.nodes.set(node.id, node);
         const nbn = this.nodesByName.get(node.name) ?? new Set();
         nbn.add(node);
-        this.nodesByName.set(node.name, nbn);
+        // ensure the nodes by name set is always sorted, this will help
+        // keeping a deterministic graph resolution when reusing nodes
+        const newByNameSet = new Set([...nbn].sort((a, b) => a.id.localeCompare(b.id)));
+        this.nodesByName.set(node.name, newByNameSet);
         if (manifest) {
             this.manifests.set(node.id, manifest);
         }
@@ -261,8 +307,21 @@ export class Graph {
             this.addEdge(depType, spec, fromNode, toFoundNode);
             // the current only stays dev/optional if this dep lets it remain so
             // if it's not already, we don't make it dev or optional.
+            toFoundNode.detached = false;
             toFoundNode.dev &&= flags.dev;
             toFoundNode.optional &&= flags.optional;
+            // Hydrate manifest and integrity on existing nodes (e.g. loaded
+            // from a lockfile without manifest data).  Without this, nodes
+            // that already have `resolved` set from the lockfile will never
+            // get their integrity populated because `setResolved()` is
+            // skipped when `resolved` is already present.
+            if (manifest) {
+                if (!toFoundNode.manifest) {
+                    toFoundNode.manifest = manifest;
+                    this.manifests.set(toFoundNode.id, manifest);
+                }
+                toFoundNode.integrity ??= manifest.dist?.integrity;
+            }
             return toFoundNode;
         }
         // creates a new node and edges to its parent
@@ -270,12 +329,17 @@ export class Graph {
         toNode.registry = spec.registry;
         toNode.dev = flags.dev;
         toNode.optional = flags.optional;
-        toNode.modifier = extra;
+        // split extra into modifier and peerSetHash
+        if (extra) {
+            const { modifier, peerSetHash } = splitExtra(extra);
+            toNode.modifier = modifier;
+            toNode.peerSetHash = peerSetHash;
+        }
         // add extra manifest info if available
         if (manifest) {
-            const { bin, engines, os, cpu } = manifest;
+            const { bin, engines, os, cpu, libc } = manifest;
             // add platform info if available
-            if (engines || os || cpu) {
+            if (engines || os || cpu || libc) {
                 const platform = {};
                 if (engines)
                     platform.engines = engines;
@@ -283,6 +347,8 @@ export class Graph {
                     platform.os = os;
                 if (cpu)
                     platform.cpu = cpu;
+                if (libc)
+                    platform.libc = libc;
                 toNode.platform = platform;
             }
             // add bin info if available
@@ -343,9 +409,9 @@ export class Graph {
     /**
      * Removes the resolved node of a given edge.
      */
-    removeEdgeResolution(edge, queryModifier = '') {
+    removeEdgeResolution(edge, extra = '') {
         const node = edge.to;
-        const resolutionKey = getResolutionCacheKey(edge.spec, edge.from.location, queryModifier);
+        const resolutionKey = getResolutionCacheKey(edge.spec, edge.from.location, extra);
         if (node) {
             edge.to = undefined;
             this.resolutions.delete(resolutionKey);
@@ -358,38 +424,22 @@ export class Graph {
         }
     }
     /**
-     * Reset resolution cache data.
+     * Remove all edges from the graph while preserving nodes and resolution caches.
+     * This allows the graph to be reconstructed efficiently using the existing nodes.
      */
-    resetResolution() {
-        // Clear all cache structures
-        this.resolutions.clear();
-        this.resolutionsReverse.clear();
-        this.nodesByName.clear();
-        // Rebuild nodesByName from all nodes
+    resetEdges() {
+        // Clear the global edges set
+        this.edges.clear();
+        // Clear all node edge relationships
         for (const node of this.nodes.values()) {
-            const nbn = this.nodesByName.get(node.name) ?? new Set();
-            nbn.add(node);
-            this.nodesByName.set(node.name, nbn);
-        }
-        // Rebuild resolution caches from all edges that have resolved targets
-        const seenNodes = new Set();
-        for (const edge of this.edges) {
-            const { to: node } = edge;
-            if (!node)
-                continue; // Skip unresolved edges
-            // Only process each node once to avoid duplicate cache entries
-            if (seenNodes.has(node))
-                continue;
-            seenNodes.add(node);
-            // Initialize resolutionsReverse entry for this node if it doesn't exist
-            if (!this.resolutionsReverse.has(node)) {
-                this.resolutionsReverse.set(node, new Set());
-            }
-            // Get the modifier if the node has one associated to it
-            const queryModifier = node.modifier || '';
-            const resolutionKey = getResolutionCacheKey(edge.spec.final, edge.from.location, queryModifier);
-            this.resolutions.set(resolutionKey, node);
-            this.resolutionsReverse.get(node)?.add(resolutionKey);
+            // Mark nodes as detached so ideal rebuild treats them as candidates
+            // that must be (re)placed during traversal. Detached nodes with a
+            // manifest can skip refetch; detached nodes without a manifest must
+            // fetch from package-info during ideal rebuild.
+            node.detached = true;
+            // detaches all edges from this node
+            node.edgesOut.clear();
+            node.edgesIn.clear();
         }
     }
     toJSON() {
@@ -404,4 +454,3 @@ export class Graph {
         return `${this[Symbol.toStringTag]} ${inspect(data, options)}`;
     }
 }
-//# sourceMappingURL=graph.js.map

package/dist/ideal/append-nodes.d.ts

@@ -0,0 +1,31 @@
+import type { DepID } from '@vltpkg/dep-id';
+import type { PackageInfoClient } from '@vltpkg/package-info';
+import type { SpecOptions } from '@vltpkg/spec';
+import type { PathScurry } from 'path-scurry';
+import type { Dependency } from '../dependencies.ts';
+import type { Graph } from '../graph.ts';
+import type { Node } from '../node.ts';
+import type { GraphModifier, ModifierActiveEntry } from '../modifiers.ts';
+import type { ExtractResult } from '../reify/extract-node.ts';
+import type { RollbackRemove } from '@vltpkg/rollback-remove';
+import type { TransientAddMap, TransientRemoveMap } from './types.ts';
+/**
+ * Append new nodes in the given `graph` for dependencies specified at `add`
+ * and missing dependencies from the `deps` parameter.
+ *
+ * Uses **breadth-first traversal** (BFS) with **deterministic ordering** to
+ * ensure reproducible builds. The algorithm:
+ *
+ * 1. Process all deps at the current level in parallel
+ * 2. After each level, run `postPlacementPeerCheck` to handle peer contexts
+ * 3. Collect child deps for the next level
+ * 4. Repeat until no more deps to process
+ *
+ * **Peer Context Isolation**: Each workspace importer gets its own peer context
+ * to prevent cross-workspace leakage. Without this, `react@^18` from workspace A
+ * could incorrectly satisfy `react@^19` peer deps in workspace B.
+ *
+ * **Early Extraction**: When `actual` graph is provided, nodes are extracted
+ * to the vlt store during graph construction (not after), improving performance.
+ */
+export declare const appendNodes: (packageInfo: PackageInfoClient, graph: Graph, fromNode: Node, deps: Dependency[], scurry: PathScurry, options: SpecOptions, seen: Set<DepID>, add?: Map<string, Dependency>, modifiers?: GraphModifier, modifierRefs?: Map<string, ModifierActiveEntry>, extractPromises?: Promise<ExtractResult>[], actual?: Graph, seenExtracted?: Set<DepID>, remover?: RollbackRemove, transientAdd?: TransientAddMap, transientRemove?: TransientRemoveMap) => Promise<void>;