@vltpkg/graph 1.0.0-rc.9 → 1.0.2

package/dist/{esm/ideal → ideal}/refresh-ideal-graph.d.ts

@@ -41,8 +41,3 @@ export type RefreshIdealGraphOptions = BuildIdealAddOptions & BuildIdealRemoveOp
  * Rebuilds the provided ideal graph.
  */
 export declare const refreshIdealGraph: ({ add, graph, modifiers, packageInfo, scurry, actual, remove, remover, transientAdd, transientRemove, ...specOptions }: RefreshIdealGraphOptions) => Promise<void>;
-/**
- * Retrieve the next unique index for a peer context set.
- */
-export declare const nextPeerContextIndex: () => number;
-//# sourceMappingURL=refresh-ideal-graph.d.ts.map

package/dist/{esm/ideal → ideal}/refresh-ideal-graph.js

@@ -1,25 +1,17 @@
 import { appendNodes } from "./append-nodes.js";
-import { getNodeOrderedDependencies } from "./get-ordered-dependencies.js";
+import { compareByHasPeerDeps, getNodeOrderedDependencies, } from "./sorting.js";
 /**
  * Returns an ordered list of importer nodes.
  */
 const getOrderedImporters = (graph) => {
     const orderedImporters = [...graph.importers].sort((a, b) => {
-        // sorts importers first by usage of peer deps
-        const aIsPeer = (a.manifest?.peerDependencies &&
-            Object.keys(a.manifest.peerDependencies).length > 0) ?
-            1
-            : 0;
-        const bIsPeer = (b.manifest?.peerDependencies &&
-            Object.keys(b.manifest.peerDependencies).length > 0) ?
-            1
-            : 0;
-        // importers with regular deps only first, with peer deps last
-        if (aIsPeer !== bIsPeer) {
-            return aIsPeer - bIsPeer;
-        }
-        // if both are in the same group, sort alphabetically by manifest name
-        return a.name.localeCompare(b.name, 'en');
+        // 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;
 };
@@ -40,7 +32,9 @@ export const refreshIdealGraph = async ({ add, graph, modifiers, packageInfo, sc
         depsPerImporter.set(importer, deps);
     }
     // removes all edges to start recalculating the graph
-    if (add.modifiedDependencies || remove.modifiedDependencies) {
+    if (add.modifiedDependencies ||
+        remove.modifiedDependencies ||
+        graph.optionsChanged) {
         graph.resetEdges();
     }
     // iterates on the list of dependencies per importer updating
@@ -68,12 +62,3 @@ export const refreshIdealGraph = async ({ add, graph, modifiers, packageInfo, sc
         await Promise.all(extractPromises);
     }
 };
-/**
- * Global index to assign unique ids used to track peer context sets.
- */
-let peerContextIndex = 0;
-/**
- * Retrieve the next unique index for a peer context set.
- */
-export const nextPeerContextIndex = () => peerContextIndex++;
-//# sourceMappingURL=refresh-ideal-graph.js.map

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/{esm/ideal → ideal}/types.d.ts

@@ -59,11 +59,7 @@ export type AppendNodeEntry = {
     depth: number;
     peerContext: PeerContext;
     updateContext: {
-        putEntries: () => {
-            dependent: Node;
-            spec: Spec;
-            type: DependencySaveType;
-        }[] | undefined;
+        putEntries: () => PeerContextEntryInput[] | undefined;
         resolvePeerDeps: () => void;
     };
 };
@@ -109,4 +105,3 @@ export type PeerContextEntryInput = {
 export type PeerContext = Map<string, PeerContextEntry> & {
     index?: number;
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/ideal/types.js

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

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

@@ -36,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}

@@ -30,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}

@@ -7,6 +7,8 @@ export type InstallOptions = LoadOptions & {
     packageInfo: PackageInfoClient;
     cleanInstall?: boolean;
     allowScripts: string;
+    saveExact?: boolean;
+    savePrefix?: string;
 };
 export declare const install: (options: InstallOptions, add?: AddImportersDependenciesMap) => Promise<{
     graph: Graph;
@@ -17,4 +19,3 @@ export declare const install: (options: InstallOptions, add?: AddImportersDepend
     graph: Graph;
     diff: import("./diff.ts").Diff;
 }>;
-//# sourceMappingURL=install.d.ts.map

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

@@ -13,6 +13,7 @@ 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,6 +42,14 @@ 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) {
@@ -55,6 +64,7 @@ export const install = async (options, add) => {
         const lockfileGraph = loadVirtual({
             ...options,
             mainManifest,
+            monorepo: fullMonorepo,
         });
         const emptyAdd = Object.assign(new Map(), { modifiedDependencies: false });
         const emptyRemove = Object.assign(new Map(), {
@@ -84,8 +94,12 @@ export const install = async (options, add) => {
         }
         if (importerSpecs.add.modifiedDependencies ||
             importerSpecs.remove.modifiedDependencies ||
-            specChanges.length > 0) {
+            specChanges.length > 0 ||
+            lockfileGraph.optionsChanged) {
             const details = [];
+            if (lockfileGraph.optionsChanged) {
+                details.push('  Configuration options have changed (e.g. modifiers, registries, catalogs)');
+            }
             if (specChanges.length > 0) {
                 details.push(...specChanges);
             }
@@ -134,6 +148,7 @@ export const install = async (options, add) => {
             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
@@ -150,11 +165,17 @@ export const install = async (options, add) => {
             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 || remove.modifiedDependencies ?
@@ -194,4 +215,3 @@ export const install = async (options, add) => {
         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

@@ -7,6 +7,11 @@ import { isDependencyTypeShort } from "../dependencies.js";
 const retrieveNodeFromGraph = (key, value, graph, fromId, seenNodes) => {
     const foundNode = graph.nodes.get(asDepID(fromId));
     if (!foundNode) {
+        // workspace or file nodes may be missing if the folder was removed
+        // while still referenced in the lockfile — skip gracefully
+        if (fromId.startsWith('workspace') || fromId.startsWith('file')) {
+            return undefined;
+        }
         throw error('Edge info missing its `from` node', {
             found: {
                 nodes: [...graph.nodes].map(([id]) => id),
@@ -59,6 +64,9 @@ export const loadEdges = (graph, edges, options) => {
         else {
             fromNode = retrieveNodeFromGraph(key, value, graph, fromId);
         }
+        // skip edges from workspace nodes that no longer exist
+        if (!fromNode)
+            continue;
         const toId = valRest.substring(vrSplit + 1);
         let toNode = undefined;
         if (toId !== 'MISSING') {
@@ -78,11 +86,14 @@ export const loadEdges = (graph, edges, options) => {
                 toNode = graph.nodes.get(asDepID(toId));
             }
         }
-        // Parse spec once we know the nodes are valid
-        const spec = Spec.parse(specName, valRest.substring(0, vrSplit), {
-            ...options,
-            registry: fromNode.registry,
-        });
+        // 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);
         if (useOptimizations) {
             edgeProcessingQueue.push({
                 fromNode,
@@ -103,4 +114,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, splitExtra } from '@vltpkg/dep-id/browser';
+import { asDepID, 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);
@@ -8,6 +8,9 @@ export const loadNodes = (graph, nodes, options, actual, throwOnMissingManifest)
     // Only used for non-trivial graphs
     const registryVersionCache = nodeCount > 50 ? new Map() : null;
     for (const [id, lockfileNode] of entries) {
+        // lockfile keys have never been through `encode`, so they can hold
+        // anything, and the id is the store directory name
+        asDepID(id);
         const [flags, name, integrity, resolved, location, manifest, rawManifest, platform, bins, buildState,] = lockfileNode;
         // workspace nodes and the project root node are already part of the
         // graph and it should not create new nodes if an existing one is there
@@ -68,7 +71,8 @@ export const loadNodes = (graph, nodes, options, actual, throwOnMissingManifest)
         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();
@@ -98,4 +102,3 @@ export const loadNodes = (graph, nodes, options, actual, throwOnMissingManifest)
         }
     }
 };
-//# sourceMappingURL=load-nodes.js.map

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

@@ -43,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

package/dist/lockfile/load.js

@@ -0,0 +1,171 @@
+import { error } from '@vltpkg/error-cause';
+import { PackageJson } from '@vltpkg/package-json';
+import { defaultGitHostArchives, defaultGitHosts, defaultJsrRegistries, defaultRegistries, defaultRegistryName, defaultScopeRegistries, } from '@vltpkg/spec';
+import { isRecordStringString } from '@vltpkg/types';
+import { Monorepo } from '@vltpkg/workspaces';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { loadEdges } from "./load-edges.js";
+import { loadNodes } from "./load-nodes.js";
+import { Graph } from "../graph.js";
+import { LOCKFILE_VERSION } from "./types.js";
+const loadLockfile = (projectRoot, lockfilePath) => JSON.parse(readFileSync(resolve(projectRoot, lockfilePath), {
+    encoding: 'utf8',
+}));
+export const load = (options) => {
+    const { projectRoot } = options;
+    return loadObject(options, loadLockfile(projectRoot, 'vlt-lock.json'));
+};
+export const loadHidden = (options) => {
+    const { projectRoot } = options;
+    // Ensure that missing manifests throw an error when loading hidden lockfiles
+    options.throwOnMissingManifest = true;
+    return loadObject(options, loadLockfile(projectRoot, 'node_modules/.vlt-lock.json'));
+};
+/**
+ * Removes entries from `items` that match the corresponding
+ * entry in `defaultItems`, returning only non-default values.
+ */
+const removeDefaultItems = (defaultItems, items) => {
+    const res = {};
+    for (const [key, value] of Object.entries(items)) {
+        if (!defaultItems[key] || defaultItems[key] !== value) {
+            res[key] = value;
+        }
+    }
+    return res;
+};
+/**
+ * Builds a normalized options object from the current runtime config
+ * using the same cleaning logic as `lockfile/save.ts` so that it can
+ * be compared directly against the options stored in a lockfile.
+ */
+const buildCurrentOptions = (options) => {
+    const hasItems = (o) => o && Object.keys(o).length > 0;
+    const cleanModifiers = (options.modifiers &&
+        isRecordStringString(options.modifiers.config)) ?
+        options.modifiers.config
+        : undefined;
+    const cleanRegistries = isRecordStringString(options.registries) ?
+        removeDefaultItems(defaultRegistries, options.registries)
+        : undefined;
+    const cleanScopeRegistries = isRecordStringString(options['scoped-registries']) ?
+        removeDefaultItems(defaultScopeRegistries, options['scoped-registries'])
+        : undefined;
+    const cleanJsrRegistries = isRecordStringString(options['jsr-registries']) ?
+        removeDefaultItems(defaultJsrRegistries, options['jsr-registries'])
+        : undefined;
+    const cleanGitHosts = isRecordStringString(options['git-hosts']) ?
+        removeDefaultItems(defaultGitHosts, options['git-hosts'])
+        : undefined;
+    const cleanGitHostArchives = isRecordStringString(options['git-host-archives']) ?
+        removeDefaultItems(defaultGitHostArchives, options['git-host-archives'])
+        : undefined;
+    return {
+        ...(hasItems(cleanModifiers) ?
+            { modifiers: cleanModifiers }
+            : {}),
+        ...(hasItems(options.catalog) ?
+            { catalog: options.catalog }
+            : {}),
+        ...(hasItems(options.catalogs) ?
+            { catalogs: options.catalogs }
+            : {}),
+        ...(hasItems(cleanScopeRegistries) ?
+            { 'scoped-registries': cleanScopeRegistries }
+            : undefined),
+        ...(hasItems(cleanJsrRegistries) ?
+            { 'jsr-registries': cleanJsrRegistries }
+            : undefined),
+        ...(options.registry !== undefined ?
+            { registry: options.registry }
+            : undefined),
+        ...((options['default-registry-alias'] !== undefined &&
+            options['default-registry-alias'] !== defaultRegistryName) ?
+            { 'default-registry-alias': options['default-registry-alias'] }
+            : undefined),
+        ...(hasItems(cleanRegistries) ?
+            { registries: cleanRegistries }
+            : undefined),
+        ...(hasItems(cleanGitHosts) ?
+            { 'git-hosts': cleanGitHosts }
+            : undefined),
+        ...(hasItems(cleanGitHostArchives) ?
+            { 'git-host-archives': cleanGitHostArchives }
+            : undefined),
+    };
+};
+export const loadObject = (options, lockfileData) => {
+    const version = lockfileData.lockfileVersion;
+    // Lockfile version is required, likely a corrupted lockfile if missing
+    if (version == null) {
+        throw error('Missing lockfile version', {
+            code: 'ELOCKFILEVERSION',
+            found: version,
+            wanted: LOCKFILE_VERSION,
+        });
+    }
+    // Lockfile version must match current version
+    if (version !== LOCKFILE_VERSION) {
+        throw error(`Unsupported lockfile version.
+
+  Run: \`vlt update\` to start a new, supported lockfile.`, {
+            code: 'ELOCKFILEVERSION',
+            found: version,
+            wanted: LOCKFILE_VERSION,
+        });
+    }
+    const { mainManifest, scurry } = options;
+    const packageJson = options.packageJson ?? new PackageJson();
+    const monorepo = options.monorepo ??
+        Monorepo.maybeLoad(options.projectRoot, { packageJson, scurry });
+    const { catalog = {}, catalogs = {}, 'scoped-registries': scopedRegistriesOption, registry, registries, 'default-registry-alias': defaultRegistryAlias, 'git-hosts': gitHosts, 'git-host-archives': gitHostArchives,
+    /* c8 ignore next */
+     } = lockfileData.options ?? {};
+    // backwards-compat: legacy lockfiles wrote this field as `scope-registries`
+    const scopeRegistries = scopedRegistriesOption ??
+        lockfileData.options['scope-registries'];
+    // Detect whether the current config options differ from those
+    // stored in the lockfile.  When they do the ideal builder must
+    // reset edges and rebuild the graph.
+    const currentOptions = buildCurrentOptions(options);
+    /* c8 ignore next */
+    const lockfileOptions = lockfileData.options ?? {};
+    const optionsChanged = JSON.stringify(currentOptions) !== JSON.stringify(lockfileOptions);
+    // Optimize options merging - only create new objects when needed
+    const mergedOptions = {
+        ...options,
+        catalog,
+        catalogs,
+        'scoped-registries': scopeRegistries ?
+            { ...options['scoped-registries'], ...scopeRegistries }
+            : options['scoped-registries'],
+        registry: registry ?? options.registry,
+        'default-registry-alias': defaultRegistryAlias ?? options['default-registry-alias'],
+        registries: registries ?
+            { ...options.registries, ...registries }
+            : options.registries,
+        'git-hosts': gitHosts ?
+            { ...options['git-hosts'], ...gitHosts }
+            : options['git-hosts'],
+        'git-host-archives': gitHostArchives ?
+            { ...options['git-host-archives'], ...gitHostArchives }
+            : options['git-host-archives'],
+    };
+    const graph = new Graph({
+        ...mergedOptions,
+        mainManifest,
+        monorepo,
+    });
+    graph.optionsChanged = optionsChanged;
+    loadNodes(graph, lockfileData.nodes, mergedOptions, options.actual, options.throwOnMissingManifest);
+    loadEdges(graph, lockfileData.edges, mergedOptions);
+    // hydrate missing node-level registry data
+    for (const node of graph.nodes.values()) {
+        const [firstEdge] = node.edgesIn;
+        if (firstEdge?.spec.registry) {
+            node.registry = firstEdge.spec.registry;
+        }
+    }
+    return graph;
+};

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

@@ -24,8 +24,7 @@ export type SaveOptions = SpecOptions & {
      */
     throwOnMissingManifest?: boolean;
 };
-export declare const lockfileData: ({ graph, catalog, catalogs, "git-hosts": gitHosts, "git-host-archives": gitHostArchives, modifiers, registry, registries, saveManifests, saveBuildData, "scope-registries": scopeRegistries, "jsr-registries": jsrRegistries, throwOnMissingManifest, }: SaveOptions) => LockfileData;
+export declare const lockfileData: ({ graph, catalog, catalogs, "git-hosts": gitHosts, "git-host-archives": gitHostArchives, modifiers, registry, registries, "default-registry-alias": defaultRegistryAlias, saveManifests, saveBuildData, "scoped-registries": scopeRegistries, "jsr-registries": jsrRegistries, throwOnMissingManifest, }: SaveOptions) => LockfileData;
 export declare const saveData: (data: LockfileData, fileName: string, saveManifests?: boolean) => void;
 export declare const save: (options: Omit<SaveOptions, "saveManifests">) => void;
 export declare const saveHidden: (options: Omit<SaveOptions, "saveManifests" | "saveBuildData">) => void;
-//# sourceMappingURL=save.d.ts.map