@vltpkg/graph 1.0.0-rc.22 → 1.0.0-rc.24

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/ideal/remove-satisfied-specs.d.ts

@@ -0,0 +1,7 @@
+import type { BuildIdealAddOptions, BuildIdealFromGraphOptions } from './types.ts';
+export type RemoveSatisfiedSpecsOptions = BuildIdealAddOptions & BuildIdealFromGraphOptions;
+/**
+ * Traverse the objects defined in `add` and removes any references to specs
+ * that are already satisfied by the contents of the actual `graph`.
+ */
+export declare const removeSatisfiedSpecs: ({ add, graph, }: RemoveSatisfiedSpecsOptions) => void;

package/dist/ideal/remove-satisfied-specs.js

@@ -0,0 +1,34 @@
+import { error } from '@vltpkg/error-cause';
+import { satisfies } from '@vltpkg/satisfies';
+/**
+ * Traverse the objects defined in `add` and removes any references to specs
+ * that are already satisfied by the contents of the actual `graph`.
+ */
+export const removeSatisfiedSpecs = ({ add, graph, }) => {
+    for (const [depID, dependencies] of add.entries()) {
+        const importer = graph.nodes.get(depID);
+        if (!importer) {
+            throw error('Referred importer node id could not be found', {
+                found: depID,
+            });
+        }
+        for (const [name, dependency] of dependencies) {
+            const edge = importer.edgesOut.get(name);
+            if (!edge) {
+                // brand new edge being added
+                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)) {
+                dependencies.delete(name);
+            }
+        }
+    }
+    // Removes any references to an importer that no longer has specs
+    for (const [depID, dependencies] of add.entries()) {
+        if (dependencies.size === 0) {
+            add.delete(depID);
+        }
+    }
+};

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/index.d.ts

@@ -0,0 +1,38 @@
+export * from './build.ts';
+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';
+export * from './visualization/mermaid-output.ts';
+export * from './stringify-node.ts';
+export * from './install.ts';
+export * from './uninstall.ts';
+export * from './update.ts';
+export * from './diff.ts';
+export * from './modifiers.ts';
+export * from './virtual-root.ts';
+import type { LoadOptions as ActualLoadOptions } from './actual/load.ts';
+export declare const actual: {
+    load: (options: ActualLoadOptions) => import("./graph.ts").Graph;
+};
+import type { LoadOptions as LockfileLoadOptions } from './lockfile/load.ts';
+export declare const lockfile: {
+    load: (options: LockfileLoadOptions) => import("./graph.ts").Graph;
+    loadEdges: (graph: import("@vltpkg/types").GraphLike, edges: import("./lockfile/types.ts").LockfileData["edges"], options: import("@vltpkg/spec").SpecOptions) => void;
+    loadNodes: (graph: import("@vltpkg/types").GraphLike, nodes: import("./lockfile/types.ts").LockfileData["nodes"], options: import("@vltpkg/spec").SpecOptions, actual?: import("@vltpkg/types").GraphLike, throwOnMissingManifest?: boolean) => void;
+    save: (options: Omit<import("./lockfile/save.ts").SaveOptions, "saveManifests">) => void;
+};
+export type { ActualLoadOptions, LockfileLoadOptions };
+export type { SaveOptions } from './lockfile/save.ts';
+import type { BuildIdealOptions } from './ideal/build.ts';
+export type { BuildIdealOptions };
+export declare const ideal: {
+    build: (options: BuildIdealOptions) => Promise<import("./graph.ts").Graph>;
+};
+export { reify } from './reify/index.ts';
+export type { ReifyOptions } from './reify/index.ts';
+export type { BuildResult } from './reify/build.ts';

package/dist/index.js

@@ -0,0 +1,32 @@
+export * from "./build.js";
+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";
+export * from "./visualization/mermaid-output.js";
+export * from "./stringify-node.js";
+export * from "./install.js";
+export * from "./uninstall.js";
+export * from "./update.js";
+export * from "./diff.js";
+export * from "./modifiers.js";
+export * from "./virtual-root.js";
+import { load as actualLoad } from "./actual/load.js";
+export const actual = { load: actualLoad };
+import { load as lockfileLoad } from "./lockfile/load.js";
+import { loadEdges } from "./lockfile/load-edges.js";
+import { loadNodes } from "./lockfile/load-nodes.js";
+import { save } from "./lockfile/save.js";
+export const lockfile = {
+    load: lockfileLoad,
+    loadEdges,
+    loadNodes,
+    save,
+};
+import { build } from "./ideal/build.js";
+export const ideal = { build };
+export { reify } from "./reify/index.js";

package/dist/install.d.ts

@@ -0,0 +1,19 @@
+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: Graph;
+    diff: undefined;
+    buildQueue?: undefined;
+} | {
+    buildQueue: DepID[] | undefined;
+    graph: Graph;
+    diff: import("./diff.ts").Diff;
+}>;

package/dist/install.js

@@ -0,0 +1,208 @@
+import { load as actualLoad } from "./actual/load.js";
+import { build as idealBuild } from "./ideal/build.js";
+import { reify } from "./reify/index.js";
+import { GraphModifier } from "./modifiers.js";
+import { init } from '@vltpkg/init';
+import { error } from '@vltpkg/error-cause';
+import { asError } from '@vltpkg/types';
+import { getDependencies } from "./dependencies.js";
+import { RollbackRemove } from '@vltpkg/rollback-remove';
+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) {
+        throw error('Cannot use --lockfile-only with --clean-install (ci command). Clean install requires filesystem operations.');
+    }
+    if (options.expectLockfile || options.frozenLockfile) {
+        const lockfilePath = resolve(options.projectRoot, 'vlt-lock.json');
+        if (!existsSync(lockfilePath)) {
+            throw error('vlt-lock.json file is required when using --expect-lockfile, --frozen-lockfile, or ci command', {
+                path: lockfilePath,
+            });
+        }
+    }
+    let mainManifest = undefined;
+    try {
+        mainManifest = options.packageJson.read(options.projectRoot);
+    }
+    catch (err) {
+        if (asError(err).message === 'Could not read package.json file') {
+            await init({ cwd: options.projectRoot });
+            mainManifest = options.packageJson.read(options.projectRoot, {
+                reload: true,
+            });
+        }
+        else {
+            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) {
+                for (const [name] of deps) {
+                    dependencies.push(name);
+                }
+            }
+            throw error('Cannot add dependencies when using --frozen-lockfile', { found: dependencies.join(', ') });
+        }
+        const lockfileGraph = loadVirtual({
+            ...options,
+            mainManifest,
+            monorepo: fullMonorepo,
+        });
+        const emptyAdd = Object.assign(new Map(), { modifiedDependencies: false });
+        const emptyRemove = Object.assign(new Map(), {
+            modifiedDependencies: false,
+        });
+        const importerSpecs = getImporterSpecs({
+            graph: lockfileGraph,
+            add: emptyAdd,
+            remove: emptyRemove,
+            ...options,
+        });
+        // Check for spec changes by comparing package.json specs with lockfile edges
+        const specChanges = [];
+        for (const importer of lockfileGraph.importers) {
+            const deps = getDependencies(importer, options);
+            for (const [depName, dep] of deps) {
+                const edge = importer.edgesOut.get(depName);
+                if (edge?.spec) {
+                    if (edge.spec.toString() !== dep.spec.toString()) {
+                        const node = lockfileGraph.nodes.get(importer.id);
+                        /* c8 ignore next */
+                        const location = node?.location || importer.id;
+                        specChanges.push(`  ${location}: ${depName} spec changed from "${edge.spec}" to "${dep.spec}"`);
+                    }
+                }
+            }
+        }
+        if (importerSpecs.add.modifiedDependencies ||
+            importerSpecs.remove.modifiedDependencies ||
+            specChanges.length > 0) {
+            const details = [];
+            if (specChanges.length > 0) {
+                details.push(...specChanges);
+            }
+            for (const [importerId, deps] of importerSpecs.add) {
+                if (deps.size > 0) {
+                    const node = lockfileGraph.nodes.get(importerId);
+                    const location = node?.location || importerId;
+                    const depNames = Array.from(deps.keys());
+                    const depLabelAdd = deps.size === 1 ? 'dependency' : 'dependencies';
+                    details.push(`  ${location}: ${deps.size} ${depLabelAdd} to add (${depNames.join(', ')})`);
+                }
+            }
+            for (const [importerId, deps] of importerSpecs.remove) {
+                if (deps.size > 0) {
+                    const node = lockfileGraph.nodes.get(importerId);
+                    const location = node?.location || importerId;
+                    const depNames = Array.from(deps);
+                    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');
+            throw error('Lockfile is out of sync with package.json. Run "vlt install" to update.\n' +
+                details.join('\n'), {
+                path: lockfilePath,
+            });
+        }
+    }
+    const remover = new RollbackRemove();
+    if (options.cleanInstall) {
+        const nodeModulesPath = resolve(options.projectRoot, 'node_modules');
+        if (existsSync(nodeModulesPath)) {
+            await remover.rm(nodeModulesPath);
+            remover.confirm();
+        }
+    }
+    try {
+        const remove = Object.assign(new Map(), {
+            modifiedDependencies: false,
+        });
+        const modifiers = GraphModifier.maybeLoad(options);
+        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,
+            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 });
+            const saveImportersPackageJson = 
+            /* c8 ignore next */
+            add?.modifiedDependencies || remove.modifiedDependencies ?
+                updatePackageJson({
+                    ...options,
+                    add,
+                    graph,
+                    remove,
+                })
+                : undefined;
+            saveImportersPackageJson?.();
+            return { graph, diff: undefined };
+        }
+        const { diff, buildQueue } = await reify({
+            ...options,
+            add,
+            actual: act,
+            graph,
+            loadManifests: true,
+            modifiers,
+            remove,
+            remover,
+        });
+        return { buildQueue, graph, diff };
+    }
+    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;
+    }
+};