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

package/dist/ideal/refresh-ideal-graph.d.ts

@@ -0,0 +1,43 @@
+import type { PathScurry } from 'path-scurry';
+import type { PackageInfoClient } from '@vltpkg/package-info';
+import type { SpecOptions } from '@vltpkg/spec';
+import type { RollbackRemove } from '@vltpkg/rollback-remove';
+import type { BuildIdealAddOptions, BuildIdealFromGraphOptions, BuildIdealRemoveOptions, TransientAddMap, TransientRemoveMap } from './types.ts';
+import type { GraphModifier } from '../modifiers.ts';
+import type { Graph } from '../graph.ts';
+export type RefreshIdealGraphOptions = BuildIdealAddOptions & BuildIdealRemoveOptions & BuildIdealFromGraphOptions & SpecOptions & {
+    /**
+     * The graph modifiers helper object.
+     */
+    modifiers?: GraphModifier;
+    /**
+     * A {@link PathScurry} instance based on the `projectRoot` path
+     */
+    scurry: PathScurry;
+    /**
+     * A {@link PackageInfoClient} instance to read manifest info from.
+     */
+    packageInfo: PackageInfoClient;
+    /**
+     * The actual graph to compare against for early extraction
+     */
+    actual?: Graph;
+    /**
+     * A {@link RollbackRemove} instance to handle extraction rollbacks
+     */
+    remover: RollbackRemove;
+    /**
+     * Dependencies to be added to non-importer nodes when they are placed.
+     * Used for nested folder dependencies that are not importers.
+     */
+    transientAdd?: TransientAddMap;
+    /**
+     * Dependencies to be removed from non-importer nodes when they are placed.
+     * Used for nested folder dependencies that are not importers.
+     */
+    transientRemove?: TransientRemoveMap;
+};
+/**
+ * Rebuilds the provided ideal graph.
+ */
+export declare const refreshIdealGraph: ({ add, graph, modifiers, packageInfo, scurry, actual, remove, remover, transientAdd, transientRemove, ...specOptions }: RefreshIdealGraphOptions) => Promise<void>;

package/dist/ideal/refresh-ideal-graph.js

@@ -0,0 +1,62 @@
+import { appendNodes } from "./append-nodes.js";
+import { compareByHasPeerDeps, getNodeOrderedDependencies, } from "./sorting.js";
+/**
+ * Returns an ordered list of importer nodes.
+ */
+const getOrderedImporters = (graph) => {
+    const orderedImporters = [...graph.importers].sort((a, b) => {
+        // mainImporter always comes first
+        /* c8 ignore next */
+        if (a === graph.mainImporter)
+            return -1;
+        if (b === graph.mainImporter)
+            return 1;
+        return compareByHasPeerDeps({ manifest: a.manifest }, { manifest: b.manifest });
+    });
+    return orderedImporters;
+};
+/**
+ * Rebuilds the provided ideal graph.
+ */
+export const refreshIdealGraph = async ({ add, graph, modifiers, packageInfo, scurry, actual, remove, remover, transientAdd, transientRemove, ...specOptions }) => {
+    const seen = new Set();
+    const extractPromises = [];
+    const seenExtracted = new Set();
+    // gets an ordered list of importers to ensure deterministic processing
+    const orderedImporters = getOrderedImporters(graph);
+    const depsPerImporter = new Map();
+    for (const importer of orderedImporters) {
+        // gets an ordered list of dependencies for this importer
+        // while also taking into account additions and removals
+        const deps = getNodeOrderedDependencies(importer, { add, remove });
+        depsPerImporter.set(importer, deps);
+    }
+    // removes all edges to start recalculating the graph
+    if (add.modifiedDependencies || remove.modifiedDependencies) {
+        graph.resetEdges();
+    }
+    // iterates on the list of dependencies per importer updating
+    // the graph using metadata fetch from the registry manifest files
+    for (const importer of orderedImporters) {
+        modifiers?.tryImporter(importer);
+        // gets a ref to the map of dependencies being added to this importer
+        const addedDeps = add.get(importer.id);
+        const deps = depsPerImporter.get(importer);
+        /* c8 ignore next */
+        if (!deps)
+            continue;
+        // gets a ref to the list of modifier functions for this set of deps
+        const modifierRefs = modifiers?.tryDependencies(importer, deps);
+        // Add new nodes for packages defined in the dependencies list fetching
+        // metadata from the registry manifests and updating the graph
+        await appendNodes(packageInfo, graph, importer, deps, scurry, specOptions, seen, addedDeps, modifiers, modifierRefs, extractPromises, actual, seenExtracted, remover, transientAdd, transientRemove);
+    }
+    // set default node locations, if possible
+    for (const node of graph.nodes.values()) {
+        node.setDefaultLocation();
+    }
+    // Wait for all extraction promises to complete
+    if (extractPromises.length > 0) {
+        await Promise.all(extractPromises);
+    }
+};

package/dist/{esm/ideal → ideal}/remove-satisfied-specs.d.ts

@@ -5,4 +5,3 @@ export type RemoveSatisfiedSpecsOptions = BuildIdealAddOptions & BuildIdealFromG
  * that are already satisfied by the contents of the actual `graph`.
  */
 export declare const removeSatisfiedSpecs: ({ add, graph, }: RemoveSatisfiedSpecsOptions) => void;
-//# sourceMappingURL=remove-satisfied-specs.d.ts.map

package/dist/{esm/ideal → ideal}/remove-satisfied-specs.js

@@ -18,6 +18,14 @@ export const removeSatisfiedSpecs = ({ add, graph, }) => {
                 // brand new edge being added
                 continue;
             }
+            // If the spec type has changed (e.g., from "registry" to
+            // "catalog" or vice versa), keep it in the add list so the
+            // edge gets rebuilt with the updated spec, even if the
+            // resolved node is the same.
+            const edgeIsCatalog = edge.spec.type === 'catalog';
+            const depIsCatalog = dependency.spec.type === 'catalog';
+            if (edgeIsCatalog !== depIsCatalog)
+                continue;
             // If the current graph edge is already valid, then we remove that
             // dependency item from the list of items to be added to the graph
             if (satisfies(edge.to?.id, dependency.spec, edge.from.location, graph.projectRoot, graph.monorepo)) {
@@ -32,4 +40,3 @@ export const removeSatisfiedSpecs = ({ add, graph, }) => {
         }
     }
 };
-//# sourceMappingURL=remove-satisfied-specs.js.map

package/dist/ideal/sorting.d.ts

@@ -0,0 +1,45 @@
+import type { BuildIdealAddOptions, BuildIdealRemoveOptions } from './types.ts';
+import type { Spec } from '@vltpkg/spec';
+import type { Manifest, NormalizedManifest } from '@vltpkg/types';
+import type { Node } from '../node.ts';
+import type { Dependency } from '../dependencies.ts';
+type SortableByHasPeerDeps = {
+    /** Package manifest containing dependency information */
+    manifest?: Manifest | NormalizedManifest;
+    /** Package name */
+    name?: string;
+    /** Package specifier */
+    spec?: Spec;
+};
+type SortableByType = {
+    /** Dependency type (e.g., 'prod', 'dev', 'peer', 'peerOptional') */
+    type: string;
+    /** Target node with package name */
+    target?: {
+        name: string;
+    };
+    /** Package specifier */
+    spec?: Spec;
+};
+/**
+ * Checks if a dependency type is a peer dependency.
+ */
+export declare const isPeerType: (type: string) => type is "peer" | "peerOptional";
+/**
+ * Sorts a list of dependencies by whether they have peer dependencies.
+ */
+export declare const compareByHasPeerDeps: (a: SortableByHasPeerDeps, b: SortableByHasPeerDeps) => number;
+/**
+ * Sorts a list of dependencies by type and name.
+ */
+export declare const compareByType: (a: SortableByType, b: SortableByType) => number;
+/**
+ * Computes the ordered list of dependencies for an given node,
+ * taking into account additions and removals.
+ */
+export declare const getNodeOrderedDependencies: (fromNode: Node, options?: BuildIdealAddOptions & BuildIdealRemoveOptions) => Dependency[];
+/**
+ * Sorts a list of dependencies by type.
+ */
+export declare const getOrderedDependencies: (deps: Dependency[]) => Dependency[];
+export {};

package/dist/ideal/sorting.js

@@ -0,0 +1,70 @@
+/**
+ * Checks if a dependency type is a peer dependency.
+ */
+export const isPeerType = (type) => type === 'peer' || type === 'peerOptional';
+/**
+ * Sorts a list of dependencies by whether they have peer dependencies.
+ */
+export const compareByHasPeerDeps = (a, b) => {
+    const aHasPeer = (a.manifest?.peerDependencies &&
+        Object.keys(a.manifest.peerDependencies).length > 0) ?
+        1
+        : 0;
+    const bHasPeer = (b.manifest?.peerDependencies &&
+        Object.keys(b.manifest.peerDependencies).length > 0) ?
+        1
+        : 0;
+    if (aHasPeer !== bHasPeer)
+        return aHasPeer - bHasPeer;
+    const aName = a.manifest?.name || a.spec?.name || a.name || '';
+    const bName = b.manifest?.name ||
+        /* c8 ignore next - very hard to test */ b.spec?.name ||
+        b.name ||
+        '';
+    return aName.localeCompare(bName, 'en');
+};
+/**
+ * Sorts a list of dependencies by type and name.
+ */
+export const compareByType = (a, b) => {
+    const aIsPeer = isPeerType(a.type) ? 1 : 0;
+    const bIsPeer = isPeerType(b.type) ? 1 : 0;
+    if (aIsPeer !== bIsPeer)
+        return aIsPeer - bIsPeer;
+    const aName = a.target?.name ?? a.spec?.name ?? '';
+    const bName = b.target?.name ?? b.spec?.name ?? '';
+    return aName.localeCompare(bName, 'en');
+};
+/**
+ * Computes the ordered list of dependencies for an given node,
+ * taking into account additions and removals.
+ */
+export const getNodeOrderedDependencies = (fromNode, options) => {
+    // using a map here instead of an array helps us get simpler
+    // deduplication while iterating through all the items at hand:
+    // existing dependencies in the graph, dependencies to be added, etc.
+    const deps = new Map();
+    for (const [name, { spec, type }] of fromNode.edgesOut.entries()) {
+        deps.set(name, { spec, type });
+    }
+    // next iterate through the list of dependencies to be added
+    const addedDeps = options?.add.get(fromNode.id);
+    if (addedDeps) {
+        for (const [name, { spec, type }] of addedDeps.entries()) {
+            deps.set(name, { spec, type });
+        }
+    }
+    // finally iterate through the list of dependencies to be removed
+    const removedDeps = options?.remove.get(fromNode.id);
+    if (removedDeps) {
+        for (const name of removedDeps) {
+            deps.delete(name);
+        }
+    }
+    // now turn the map into a sorted array
+    return getOrderedDependencies([...deps.values()]);
+};
+/**
+ * Sorts a list of dependencies by type.
+ */
+export const getOrderedDependencies = (deps) => [...deps].sort(compareByType);

package/dist/ideal/types.d.ts

@@ -0,0 +1,107 @@
+import type { PackageInfoClient } from '@vltpkg/package-info';
+import type { Spec } from '@vltpkg/spec';
+import type { DependencySaveType } from '@vltpkg/types';
+import type { AddImportersDependenciesMap, Dependency, RemoveImportersDependenciesMap } from '../dependencies.ts';
+import type { ModifierActiveEntry } from '../modifiers.ts';
+import type { Graph } from '../graph.ts';
+import type { Node } from '../node.ts';
+/**
+ * A map of dependencies to be added to non-importer nodes.
+ * Keys are {@link DepID} of nodes that are not importers (e.g., nested folders).
+ * When these nodes are resolved and placed in the graph, their dependencies
+ * from this map are injected into the processing queue.
+ */
+export type TransientAddMap = Omit<AddImportersDependenciesMap, 'modifiedDependencies'>;
+/**
+ * A map of dependency names to be removed from non-importer nodes.
+ * Keys are {@link DepID} of nodes that are not importers (e.g., nested folders).
+ * When these nodes are processed, their dependencies in this map are excluded.
+ */
+export type TransientRemoveMap = Omit<RemoveImportersDependenciesMap, 'modifiedDependencies'>;
+export type BuildIdealAddOptions = {
+    /**
+     * A {@link AddImportersDependenciesMap} in which keys are {@link DepID}
+     * linking to another `Map` in which keys are the dependency names and values
+     * are {@link Dependency}. This structure represents dependencies that need
+     * to be added to the importer represented by {@link DepID}.
+     */
+    add: AddImportersDependenciesMap;
+};
+export type BuildIdealRemoveOptions = {
+    /**
+     * A {@link RemoveImportersDependenciesMap} object representing nodes to be
+     * removed from the ideal graph. Each {@link DepID} key represents an
+     * importer node and the `Set` of dependency names to be removed from its
+     * dependency list.
+     */
+    remove: RemoveImportersDependenciesMap;
+};
+export type BuildIdealFromGraphOptions = {
+    /**
+     * An initial {@link Graph} to start building from, adding nodes to any
+     * missing edges and appending any new specs defined in `addSpecs`.
+     */
+    graph: Graph;
+};
+export type BuildIdealPackageInfoOptions = {
+    /**
+     * A {@link PackageInfoClient} instance to read manifest info from.
+     */
+    packageInfo: PackageInfoClient;
+};
+/**
+ * Represents an ongoing append operation for a node and its dependencies.
+ */
+export type AppendNodeEntry = {
+    node: Node;
+    deps: Dependency[];
+    modifierRefs?: Map<string, ModifierActiveEntry>;
+    depth: number;
+    peerContext: PeerContext;
+    updateContext: {
+        putEntries: () => PeerContextEntryInput[] | undefined;
+        resolvePeerDeps: () => void;
+    };
+};
+/**
+ * The result of processing a given placed node in the graph.
+ */
+export type ProcessPlacementResultEntry = Omit<AppendNodeEntry, 'depth'>;
+/**
+ * The result of processing placement for nodes to be added to the graph.
+ */
+export type ProcessPlacementResult = ProcessPlacementResultEntry[];
+/**
+ * Entry in a peer context representing a resolved peer dependency.
+ */
+export type PeerContextEntry = {
+    /**
+     * True if this entry is currently being resolved and track by this
+     * peer context set, false in case this entry was inherit from a previous
+     * peer context set and should not be considered for resolution.
+     */
+    active: boolean;
+    /** List of full Spec objects that are part of this peer context entry */
+    specs: Set<Spec>;
+    /** The target Node that satisfies all specs for this peer context entry */
+    target: Node | undefined;
+    /** The type of dependency this entry represents */
+    type: DependencySaveType;
+    /** Context dependent nodes that had dependencies resolved to this entry */
+    contextDependents: Set<Node>;
+};
+/**
+ * Input for adding an entry to peer contexts.
+ */
+export type PeerContextEntryInput = {
+    /** Node that depends on this resolved peer context set entry */
+    dependent?: Node;
+    /** Node this peer context entry resolves to */
+    target?: Node;
+} & Dependency;
+/**
+ * Represents resolved peer dependencies in a given append-nodes context.
+ */
+export type PeerContext = Map<string, PeerContextEntry> & {
+    index?: number;
+};

package/dist/ideal/types.js

@@ -0,0 +1 @@
+export {};

package/dist/{esm/index.d.ts → index.d.ts}

@@ -3,6 +3,7 @@ export * from './edge.ts';
 export * from './graph.ts';
 export * from './node.ts';
 export * from './dependencies.ts';
+export * from './fixup-added-names.ts';
 export * from './lockfile/types.ts';
 export * from './visualization/json-output.ts';
 export * from './visualization/human-readable-output.ts';
@@ -35,4 +36,3 @@ export declare const ideal: {
 export { reify } from './reify/index.ts';
 export type { ReifyOptions } from './reify/index.ts';
 export type { BuildResult } from './reify/build.ts';
-//# sourceMappingURL=index.d.ts.map

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

@@ -3,6 +3,7 @@ export * from "./edge.js";
 export * from "./graph.js";
 export * from "./node.js";
 export * from "./dependencies.js";
+export * from "./fixup-added-names.js";
 export * from "./lockfile/types.js";
 export * from "./visualization/json-output.js";
 export * from "./visualization/human-readable-output.js";
@@ -29,4 +30,3 @@ export const lockfile = {
 import { build } from "./ideal/build.js";
 export const ideal = { build };
 export { reify } from "./reify/index.js";
-//# sourceMappingURL=index.js.map

package/dist/{esm/install.d.ts → install.d.ts}

@@ -2,18 +2,18 @@ import type { PackageInfoClient } from '@vltpkg/package-info';
 import type { LoadOptions } from './actual/load.ts';
 import type { AddImportersDependenciesMap } from './dependencies.ts';
 import type { DepID } from '@vltpkg/dep-id';
+import type { Graph } from './index.ts';
 export type InstallOptions = LoadOptions & {
     packageInfo: PackageInfoClient;
     cleanInstall?: boolean;
     allowScripts: string;
 };
 export declare const install: (options: InstallOptions, add?: AddImportersDependenciesMap) => Promise<{
-    graph: import("./graph.ts").Graph;
+    graph: Graph;
     diff: undefined;
     buildQueue?: undefined;
 } | {
     buildQueue: DepID[] | undefined;
-    graph: import("./graph.ts").Graph;
+    graph: Graph;
     diff: import("./diff.ts").Diff;
 }>;
-//# sourceMappingURL=install.d.ts.map

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

@@ -7,12 +7,13 @@ import { error } from '@vltpkg/error-cause';
 import { asError } from '@vltpkg/types';
 import { getDependencies } from "./dependencies.js";
 import { RollbackRemove } from '@vltpkg/rollback-remove';
-import { existsSync } from 'node:fs';
+import { existsSync, rmSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { load as loadVirtual } from "./lockfile/load.js";
 import { getImporterSpecs } from "./ideal/get-importer-specs.js";
 import { lockfile } from "./index.js";
 import { updatePackageJson } from "./reify/update-importers-package-json.js";
+import { Monorepo } from '@vltpkg/workspaces';
 export const install = async (options, add) => {
     // Validate incompatible options
     if (options.lockfileOnly && options.cleanInstall) {
@@ -41,7 +42,16 @@ export const install = async (options, add) => {
             throw err;
         }
     }
+    // Load an unfiltered monorepo to ensure all workspace importers are
+    // included in the graph. This is necessary because the options.monorepo
+    // may be filtered by -w/--workspace flags, which would cause nodes/edges
+    // from other workspaces to be lost during graph construction.
+    const fullMonorepo = Monorepo.maybeLoad(options.projectRoot, {
+        packageJson: options.packageJson,
+        scurry: options.scurry,
+    });
     if (options.frozenLockfile) {
+        // validates no add/remove operations are requested
         if (add?.modifiedDependencies) {
             const dependencies = [];
             for (const [, deps] of add) {
@@ -54,7 +64,7 @@ export const install = async (options, add) => {
         const lockfileGraph = loadVirtual({
             ...options,
             mainManifest,
-            skipLoadingNodesOnModifiersChange: false,
+            monorepo: fullMonorepo,
         });
         const emptyAdd = Object.assign(new Map(), { modifiedDependencies: false });
         const emptyRemove = Object.assign(new Map(), {
@@ -94,7 +104,8 @@ export const install = async (options, add) => {
                     const node = lockfileGraph.nodes.get(importerId);
                     const location = node?.location || importerId;
                     const depNames = Array.from(deps.keys());
-                    details.push(`  ${location}: ${deps.size} dependencies to add (${depNames.join(', ')})`);
+                    const depLabelAdd = deps.size === 1 ? 'dependency' : 'dependencies';
+                    details.push(`  ${location}: ${deps.size} ${depLabelAdd} to add (${depNames.join(', ')})`);
                 }
             }
             for (const [importerId, deps] of importerSpecs.remove) {
@@ -102,7 +113,10 @@ export const install = async (options, add) => {
                     const node = lockfileGraph.nodes.get(importerId);
                     const location = node?.location || importerId;
                     const depNames = Array.from(deps);
-                    details.push(`  ${location}: ${deps.size} dependencies to remove (${depNames.join(', ')})`);
+                    const depLabelRemove = deps.size === 1 ?
+                        'dependency'
+                        : /* c8 ignore next */ 'dependencies';
+                    details.push(`  ${location}: ${deps.size} ${depLabelRemove} to remove (${depNames.join(', ')})`);
                 }
             }
             const lockfilePath = resolve(options.projectRoot, 'vlt-lock.json');
@@ -121,13 +135,23 @@ export const install = async (options, add) => {
         }
     }
     try {
+        const remove = Object.assign(new Map(), {
+            modifiedDependencies: false,
+        });
         const modifiers = GraphModifier.maybeLoad(options);
-        const act = actualLoad({
+        let act = actualLoad({
             ...options,
             mainManifest,
             loadManifests: true,
             modifiers: undefined, // modifiers should not be used here
+            monorepo: fullMonorepo,
         });
+        // if the actual graph has no dependencies, it's simpler to ignore it
+        // this allows us to check for its availability later on for properly
+        // handling situations like resetting edges for refreshing the ideal graph
+        if (act.importers.size === act.nodes.size) {
+            act = undefined;
+        }
         const graph = await idealBuild({
             ...options,
             actual: act,
@@ -135,19 +159,27 @@ export const install = async (options, add) => {
             mainManifest,
             loadManifests: true,
             modifiers,
+            remove,
             remover,
+            monorepo: fullMonorepo,
         });
         // If lockfileOnly is enabled, skip reify and only save the lockfile
         if (options.lockfileOnly) {
-            // Save only the main lockfile, skip all filesystem operations
-            lockfile.save({ graph, modifiers });
+            // Save only the main lockfile, skip all filesystem operations.
+            // Spread `options` so that spec-level config (registry,
+            // scoped-registries, git-hosts, catalogs, etc.) round-trips
+            // through the lockfile - otherwise subsequent installs lose
+            // the configured registry and rewrite node/edge DepIDs back
+            // to the default npm registry. (See vltpkg/vltpkg#1580.)
+            lockfile.save({ ...options, graph, modifiers });
             const saveImportersPackageJson = 
             /* c8 ignore next */
-            add?.modifiedDependencies ?
+            add?.modifiedDependencies || remove.modifiedDependencies ?
                 updatePackageJson({
                     ...options,
                     add,
                     graph,
+                    remove,
                 })
                 : undefined;
             saveImportersPackageJson?.();
@@ -160,6 +192,7 @@ export const install = async (options, add) => {
             graph,
             loadManifests: true,
             modifiers,
+            remove,
             remover,
         });
         return { buildQueue, graph, diff };
@@ -167,7 +200,14 @@ export const install = async (options, add) => {
     catch (err) {
         /* c8 ignore next */
         await remover.rollback().catch(() => { });
+        // Remove hidden lockfile on failure
+        try {
+            const hiddenLockfile = resolve(options.projectRoot, 'node_modules/.vlt-lock.json');
+            if (existsSync(hiddenLockfile)) {
+                rmSync(hiddenLockfile, { force: true });
+            }
+        }
+        catch { }
         throw err;
     }
 };
-//# sourceMappingURL=install.js.map

package/dist/{esm/lockfile → lockfile}/load-edges.d.ts

@@ -9,4 +9,3 @@ export type ProcessingEdge = {
     spec: Spec;
 };
 export declare const loadEdges: (graph: GraphLike, edges: LockfileData["edges"], options: SpecOptions) => void;
-//# sourceMappingURL=load-edges.d.ts.map

package/dist/{esm/lockfile → lockfile}/load-edges.js

@@ -78,10 +78,14 @@ export const loadEdges = (graph, edges, options) => {
                 toNode = graph.nodes.get(asDepID(toId));
             }
         }
-        // Parse spec once we know the nodes are valid
+        // Use the merged options directly — they already carry the
+        // correct registry from the lockfile's `options` + caller config.
+        // `fromNode.registry` is not populated yet at this point (the
+        // post-load hydration loop in load.ts sets it *after* edges are
+        // loaded), so overriding here would always inject `undefined`
+        // and silently revert to the default npm registry.
+        // See vltpkg/vltpkg#1580.
         const spec = Spec.parse(specName, valRest.substring(0, vrSplit), options);
-        // sets a registry for this spec to inherit from
-        spec.inheritedRegistry = fromNode.registry;
         if (useOptimizations) {
             edgeProcessingQueue.push({
                 fromNode,
@@ -102,4 +106,3 @@ export const loadEdges = (graph, edges, options) => {
         }
     }
 };
-//# sourceMappingURL=load-edges.js.map

package/dist/{esm/lockfile → lockfile}/load-nodes.d.ts

@@ -2,4 +2,3 @@ import type { LockfileData } from './types.ts';
 import type { GraphLike } from '@vltpkg/types';
 import type { SpecOptions } from '@vltpkg/spec/browser';
 export declare const loadNodes: (graph: GraphLike, nodes: LockfileData["nodes"], options: SpecOptions, actual?: GraphLike, throwOnMissingManifest?: boolean) => void;
-//# sourceMappingURL=load-nodes.d.ts.map

package/dist/{esm/lockfile → lockfile}/load-nodes.js

@@ -1,5 +1,5 @@
 import { error } from '@vltpkg/error-cause';
-import { splitDepID } from '@vltpkg/dep-id/browser';
+import { splitDepID, splitExtra } from '@vltpkg/dep-id/browser';
 import { getBooleanFlagsFromNum, getBuildStateFromNum, } from "./types.js";
 export const loadNodes = (graph, nodes, options, actual, throwOnMissingManifest) => {
     const entries = Object.entries(nodes);
@@ -55,14 +55,21 @@ export const loadNodes = (graph, nodes, options, actual, throwOnMissingManifest)
             graph.addNode(id, mani)
             : graph.addNode(id, undefined, undefined, name ?? undefined, version);
         if (extra) {
-            node.modifier = extra;
+            const { modifier, peerSetHash } = splitExtra(extra);
+            if (modifier) {
+                node.modifier = modifier;
+            }
+            if (peerSetHash) {
+                node.peerSetHash = peerSetHash;
+            }
         }
         const { dev, optional } = getBooleanFlagsFromNum(flags);
         node.options = options;
         node.dev = dev;
         node.optional = optional;
         node.integrity = integrity ?? referenceNode?.integrity;
-        node.resolved = resolved ?? referenceNode?.resolved;
+        node.resolved =
+            type === 'remote' ? filepath : ((resolved ?? referenceNode?.resolved));
         node.projectRoot = graph.projectRoot;
         if (!node.resolved)
             node.setResolved();
@@ -92,4 +99,3 @@ export const loadNodes = (graph, nodes, options, actual, throwOnMissingManifest)
         }
     }
 };
-//# sourceMappingURL=load-nodes.js.map

package/dist/{esm/lockfile → lockfile}/load.d.ts

@@ -35,10 +35,6 @@ export type LoadOptions = SpecOptions & {
      * A {@link PathScurry} object, for use in globs
      */
     scurry?: PathScurry;
-    /**
-     * Load only importers into the graph if the modifiers have changed.
-     */
-    skipLoadingNodesOnModifiersChange?: boolean;
     /**
      * Whether to throw an error if a manifest is missing when loading nodes.
      */
@@ -47,4 +43,3 @@ export type LoadOptions = SpecOptions & {
 export declare const load: (options: LoadOptions) => Graph;
 export declare const loadHidden: (options: LoadOptions) => Graph;
 export declare const loadObject: (options: LoadOptions, lockfileData: Omit<LockfileData, "options" | "lockfileVersion"> & Partial<Pick<LockfileData, "options" | "lockfileVersion">>) => Graph;
-//# sourceMappingURL=load.d.ts.map