@vltpkg/graph 1.0.2 → 1.0.4

package/dist/actual/load.d.ts

@@ -4,6 +4,7 @@ import type { DepID } from '@vltpkg/dep-id';
 import type { PackageJson } from '@vltpkg/package-json';
 import type { SpecOptions } from '@vltpkg/spec';
 import type { NormalizedManifest } from '@vltpkg/types';
+import type { LockfileData, SpecCache } from '../lockfile/types.ts';
 import type { Monorepo } from '@vltpkg/workspaces';
 import type { Path, PathScurry } from 'path-scurry';
 import type { GraphModifier } from '../modifiers.ts';
@@ -65,6 +66,15 @@ export type LoadOptions = SpecOptions & {
      * operations. Skips package extraction, filesystem operations, and hidden lockfile saves.
      */
     lockfileOnly?: boolean;
+    /**
+     * Shared intern cache for parsed lockfile specs.
+     */
+    specCache?: SpecCache;
+    /**
+     * Already-parsed main lockfile data. When set, ideal build skips
+     * re-reading `vlt-lock.json`.
+     */
+    lockfileData?: LockfileData;
 };
 export type ReadEntry = {
     alias: string;

package/dist/browser.d.ts

@@ -5,7 +5,7 @@ import { stringifyNode } from './stringify-node.ts';
 export type { LoadResult, TransferData, } from './transfer-data/load.ts';
 export * from './virtual-root.ts';
 declare const lockfile: {
-    loadEdges: (graph: import("@vltpkg/types").GraphLike, edges: import("./lockfile/types.ts").LockfileData["edges"], options: import("@vltpkg/spec").SpecOptions) => void;
+    loadEdges: (graph: import("@vltpkg/types").GraphLike, edges: import("./lockfile/types.ts").LockfileData["edges"], options: import("@vltpkg/spec").SpecOptions, cache?: import("./lockfile/load-edges.ts").LoadEdgesCache) => 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;
 };
 declare const transfer: {

package/dist/ideal/peers.d.ts

@@ -41,6 +41,17 @@ export declare const checkPeerEdgesCompatible: (existingNode: Node, fromNode: No
  * Retrieve a unique hash value for a given peer context set.
  */
 export declare const retrievePeerContextHash: (peerContext: PeerContext | undefined) => string | undefined;
+/**
+ * Generate a dedupe key for a spec stored in a peer context entry's
+ * `specs` map. Two specs with the same key are interchangeable for the
+ * purposes of `incompatibleSpecs()`/`satisfies()` checks, so only one
+ * needs to be retained regardless of how many dependents contribute it.
+ *
+ * Keyed on type + textual spec (name@bareSpec) + registry, since specs
+ * that are textually identical but resolve against different registries
+ * are not interchangeable.
+ */
+export declare const peerSpecKey: (spec: Spec) => string;
 /**
  * Checks if a given spec is compatible with the specs already
  * assigned to a peer context entry.

package/dist/ideal/peers.js

@@ -179,7 +179,7 @@ export const checkPeerEdgesCompatible = (existingNode, fromNode, peerContext, gr
             const existingTarget = existingEdge.to;
             const existingTargetSatisfiesPeer = satisfiesNodeSpec(existingTarget, peerSpec);
             if (existingTargetSatisfiesPeer &&
-                nodeSatisfiesAll(existingTarget, contextEntry.specs)) {
+                nodeSatisfiesAll(existingTarget, contextEntry.specs.values())) {
                 continue; // Truly no conflict
             }
             const result = buildIncompatibleResult(contextEntry.target, peerSpec, contextEntry.type, fromNode, graph);
@@ -259,6 +259,20 @@ export const retrievePeerContextHash = (peerContext) => {
         return undefined;
     return `peer.${peerContext.index}`;
 };
+/**
+ * Generate a dedupe key for a spec stored in a peer context entry's
+ * `specs` map. Two specs with the same key are interchangeable for the
+ * purposes of `incompatibleSpecs()`/`satisfies()` checks, so only one
+ * needs to be retained regardless of how many dependents contribute it.
+ *
+ * Keyed on type + textual spec (name@bareSpec) + registry, since specs
+ * that are textually identical but resolve against different registries
+ * are not interchangeable.
+ */
+export const peerSpecKey = (spec) => {
+    const f = spec.final;
+    return `${f.type}\0${String(f)}\0${f.registry ?? ''}`;
+};
 /**
  * Checks if a given spec is compatible with the specs already
  * assigned to a peer context entry.
@@ -276,7 +290,7 @@ export const retrievePeerContextHash = (peerContext) => {
  */
 export const incompatibleSpecs = (spec, entry) => {
     if (entry.specs.size > 0) {
-        for (const s_ of entry.specs) {
+        for (const s_ of entry.specs.values()) {
             const s = s_.final;
             if (
             // Registry types: check semver range intersection
@@ -337,7 +351,7 @@ export const addEntriesToPeerContext = (peerContext, entries, fromNode, monorepo
         if (!entry) {
             entry = {
                 active: true,
-                specs: new Set([spec]),
+                specs: new Map([[peerSpecKey(spec), spec]]),
                 target,
                 type,
                 contextDependents: new Set(),
@@ -352,7 +366,7 @@ export const addEntriesToPeerContext = (peerContext, entries, fromNode, monorepo
             return true;
         // update target if compatible with all specs
         if (target &&
-            [...entry.specs].every(s => satisfies(target.id, s, fromNode.location, fromNode.projectRoot, monorepo))) {
+            [...entry.specs.values()].every(s => satisfies(target.id, s, fromNode.location, fromNode.projectRoot, monorepo))) {
             if (target.id !== entry.target?.id &&
                 target.version !== entry.target?.version) {
                 // update dependents to point to new target
@@ -368,7 +382,9 @@ export const addEntriesToPeerContext = (peerContext, entries, fromNode, monorepo
             }
             entry.target ??= target;
         }
-        entry.specs.add(spec);
+        const specKey = peerSpecKey(spec);
+        if (!entry.specs.has(specKey))
+            entry.specs.set(specKey, spec);
         if (dependent)
             entry.contextDependents.add(dependent);
     }
@@ -395,7 +411,7 @@ export const forkPeerContext = (graph, peerContext, entries) => {
     for (const [name, entry] of peerContext.entries()) {
         nextPeerContext.set(name, {
             active: false,
-            specs: new Set(entry.specs),
+            specs: new Map(entry.specs),
             target: undefined,
             type: entry.type,
             contextDependents: new Set(entry.contextDependents),
@@ -408,7 +424,7 @@ export const forkPeerContext = (graph, peerContext, entries) => {
         const name = target?.name /* c8 ignore next */ ?? spec.final.name;
         const newEntry = {
             active: true,
-            specs: new Set([spec]),
+            specs: new Map([[peerSpecKey(spec), spec]]),
             target,
             type,
             contextDependents: dependent ? new Set([dependent]) : new Set(),
@@ -610,7 +626,10 @@ export const endPeerPlacement = (peerContext, nextDeps, nextPeerDeps, graph, spe
                 entry?.target &&
                 nodeSatisfiesSpec(entry.target, spec, fromNode, graph)) {
                 graph.addEdge(type, spec, node, entry.target);
-                entry.specs.add(spec.final);
+                const finalKey = peerSpecKey(spec.final);
+                if (!entry.specs.has(finalKey)) {
+                    entry.specs.set(finalKey, spec.final);
+                }
                 continue;
             }
             // PRIORITY 4: Fallback - add to nextDeps or create dangling edge

package/dist/ideal/types.d.ts

@@ -81,8 +81,12 @@ export type PeerContextEntry = {
      * 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>;
+    /**
+     * Full Spec objects that are part of this peer context entry, keyed by
+     * `peerSpecKey()` so textually identical specs collapse into one entry
+     * instead of piling up per dependent.
+     */
+    specs: Map<string, Spec>;
     /** The target Node that satisfies all specs for this peer context entry */
     target: Node | undefined;
     /** The type of dependency this entry represents */

package/dist/index.d.ts

@@ -22,7 +22,8 @@ export declare const actual: {
 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;
+    loadData: (projectRoot: string, lockfilePath?: string) => import("./lockfile/types.ts").LockfileData;
+    loadEdges: (graph: import("@vltpkg/types").GraphLike, edges: import("./lockfile/types.ts").LockfileData["edges"], options: import("@vltpkg/spec").SpecOptions, cache?: import("./lockfile/load-edges.ts").LoadEdgesCache) => 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;
 };

package/dist/index.js

@@ -17,12 +17,13 @@ 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 { load as lockfileLoad, loadData as lockfileLoadData, } 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,
+    loadData: lockfileLoadData,
     loadEdges,
     loadNodes,
     save,

package/dist/install.js

@@ -9,7 +9,7 @@ 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 { load as loadVirtual, loadData } 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";
@@ -50,6 +50,8 @@ export const install = async (options, add) => {
         packageJson: options.packageJson,
         scurry: options.scurry,
     });
+    const specCache = new Map();
+    const lockfileData = options.frozenLockfile ? loadData(options.projectRoot) : undefined;
     if (options.frozenLockfile) {
         // validates no add/remove operations are requested
         if (add?.modifiedDependencies) {
@@ -65,6 +67,8 @@ export const install = async (options, add) => {
             ...options,
             mainManifest,
             monorepo: fullMonorepo,
+            specCache,
+            lockfileData,
         });
         const emptyAdd = Object.assign(new Map(), { modifiedDependencies: false });
         const emptyRemove = Object.assign(new Map(), {
@@ -149,6 +153,7 @@ export const install = async (options, add) => {
             loadManifests: true,
             modifiers: undefined, // modifiers should not be used here
             monorepo: fullMonorepo,
+            specCache,
         });
         // 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
@@ -166,6 +171,8 @@ export const install = async (options, add) => {
             remove,
             remover,
             monorepo: fullMonorepo,
+            specCache,
+            lockfileData,
         });
         // If lockfileOnly is enabled, skip reify and only save the lockfile
         if (options.lockfileOnly) {

package/dist/lockfile/load-edges.d.ts

@@ -1,11 +1,15 @@
 import { Spec } from '@vltpkg/spec/browser';
 import type { SpecOptions } from '@vltpkg/spec/browser';
 import type { DependencyTypeShort, GraphLike, NodeLike } from '@vltpkg/types';
-import type { LockfileData } from './types.ts';
+import type { LockfileData, SpecCache } from './types.ts';
+export type LoadEdgesCache = {
+    specCache: SpecCache;
+    prefix: string;
+};
 export type ProcessingEdge = {
     fromNode: NodeLike;
     toNode: NodeLike | undefined;
     depType: DependencyTypeShort;
     spec: Spec;
 };
-export declare const loadEdges: (graph: GraphLike, edges: LockfileData["edges"], options: SpecOptions) => void;
+export declare const loadEdges: (graph: GraphLike, edges: LockfileData["edges"], options: SpecOptions, cache?: LoadEdgesCache) => void;

package/dist/lockfile/load-edges.js

@@ -26,7 +26,20 @@ const retrieveNodeFromGraph = (key, value, graph, fromId, seenNodes) => {
     }
     return foundNode;
 };
-export const loadEdges = (graph, edges, options) => {
+const parseEdgeSpec = (specName, bareSpec, options, cache) => {
+    // graph.addEdge mutates name/spec on '(unknown)' instances
+    if (!cache || specName === '(unknown)') {
+        return Spec.parse(specName, bareSpec, options);
+    }
+    const key = `${cache.prefix}\0${specName}\0${bareSpec}`;
+    const cached = cache.specCache.get(key);
+    if (cached)
+        return cached;
+    const spec = Spec.parse(specName, bareSpec, options);
+    cache.specCache.set(key, spec);
+    return spec;
+};
+export const loadEdges = (graph, edges, options, cache) => {
     const entries = Object.entries(edges);
     const edgeCount = entries.length;
     // Only use optimizations for non-trivial graphs
@@ -93,7 +106,7 @@ export const loadEdges = (graph, edges, options) => {
         // 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);
+        const spec = parseEdgeSpec(specName, valRest.substring(0, vrSplit), options, cache);
         if (useOptimizations) {
             edgeProcessingQueue.push({
                 fromNode,

package/dist/lockfile/load-nodes.js

@@ -73,6 +73,7 @@ export const loadNodes = (graph, nodes, options, actual, throwOnMissingManifest)
         node.integrity = integrity ?? referenceNode?.integrity;
         node.resolved =
             type === 'remote' ? filepath : ((resolved ?? referenceNode?.resolved));
+        node.resolvedFromLockfile = !!(node.integrity && node.resolved);
         node.projectRoot = graph.projectRoot;
         if (!node.resolved)
             node.setResolved();

package/dist/lockfile/load.d.ts

@@ -4,7 +4,7 @@ import { Graph } from '../graph.ts';
 import type { PathScurry } from 'path-scurry';
 import type { NormalizedManifest } from '@vltpkg/types';
 import type { SpecOptions } from '@vltpkg/spec';
-import type { LockfileData } from './types.ts';
+import type { LockfileData, SpecCache } from './types.ts';
 import type { GraphModifier } from '../modifiers.ts';
 export type LoadOptions = SpecOptions & {
     /**
@@ -39,7 +39,16 @@ export type LoadOptions = SpecOptions & {
      * Whether to throw an error if a manifest is missing when loading nodes.
      */
     throwOnMissingManifest?: boolean;
+    /**
+     * Shared intern cache for parsed lockfile specs.
+     */
+    specCache?: SpecCache;
+    /**
+     * Already-parsed lockfile data. When set, skips the filesystem read.
+     */
+    lockfileData?: LockfileData;
 };
+export declare const loadData: (projectRoot: string, lockfilePath?: string) => LockfileData;
 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;

package/dist/lockfile/load.js

@@ -12,9 +12,11 @@ import { LOCKFILE_VERSION } from "./types.js";
 const loadLockfile = (projectRoot, lockfilePath) => JSON.parse(readFileSync(resolve(projectRoot, lockfilePath), {
     encoding: 'utf8',
 }));
+export const loadData = (projectRoot, lockfilePath = 'vlt-lock.json') => loadLockfile(projectRoot, lockfilePath);
 export const load = (options) => {
     const { projectRoot } = options;
-    return loadObject(options, loadLockfile(projectRoot, 'vlt-lock.json'));
+    return loadObject(options, options.lockfileData ??
+        loadLockfile(projectRoot, 'vlt-lock.json'));
 };
 export const loadHidden = (options) => {
     const { projectRoot } = options;
@@ -159,7 +161,14 @@ export const loadObject = (options, lockfileData) => {
     });
     graph.optionsChanged = optionsChanged;
     loadNodes(graph, lockfileData.nodes, mergedOptions, options.actual, options.throwOnMissingManifest);
-    loadEdges(graph, lockfileData.edges, mergedOptions);
+    // Skip interning when modifiers are active — they mutate Spec.overridden
+    const specCache = options.modifiers || !options.specCache ?
+        undefined
+        : {
+            specCache: options.specCache,
+            prefix: JSON.stringify(lockfileOptions),
+        };
+    loadEdges(graph, lockfileData.edges, mergedOptions, specCache);
     // hydrate missing node-level registry data
     for (const node of graph.nodes.values()) {
         const [firstEdge] = node.edgesIn;

package/dist/lockfile/types.d.ts

@@ -25,6 +25,12 @@ export type LockfileData = {
     nodes: Record<DepID, LockfileNode>;
     edges: LockfileEdges;
 };
+/**
+ * Per-install intern cache for parsed lockfile specs. Shared across
+ * hidden + main lockfile loads so identical (name, bareSpec) pairs
+ * reuse one Spec instance.
+ */
+export type SpecCache = Map<string, Spec>;
 /**
  * Current lockfile format version.
  * Only lockfiles with matching version are considered valid.

package/dist/node.d.ts

@@ -76,6 +76,11 @@ export declare class Node implements NodeLike {
      * The manifest integrity value.
      */
     integrity?: Integrity;
+    /**
+     * True when `integrity` and `resolved` came from a lockfile, i.e. they were
+     * verified by the install that wrote them.
+     */
+    resolvedFromLockfile: boolean;
     /**
      * The manifest this node represents in the graph.
      */

package/dist/node.js

@@ -101,6 +101,11 @@ export class Node {
      * The manifest integrity value.
      */
     integrity;
+    /**
+     * True when `integrity` and `resolved` came from a lockfile, i.e. they were
+     * verified by the install that wrote them.
+     */
+    resolvedFromLockfile = false;
     /**
      * The manifest this node represents in the graph.
      */

package/dist/reify/extract-node.js

@@ -38,15 +38,17 @@ export const extractNode = async (node, scurry, remover, options, packageInfo, d
             error: new Error('Platform check failed or package deprecated'),
         };
     }
+    const extractOptions = {
+        from,
+        integrity,
+        resolved,
+        fromLockfile: node.resolvedFromLockfile,
+    };
     try {
         await remover.rm(target);
         if (removeOptionalFailedNode) {
             try {
-                const result = await packageInfo.extract(spec, target, {
-                    from,
-                    integrity,
-                    resolved,
-                });
+                const result = await packageInfo.extract(spec, target, extractOptions);
                 // Store computed integrity for git/remote deps
                 if (result.integrity && !node.integrity) {
                     node.integrity = result.integrity;
@@ -59,11 +61,7 @@ export const extractNode = async (node, scurry, remover, options, packageInfo, d
             }
         }
         else {
-            const result = await packageInfo.extract(spec, target, {
-                from,
-                integrity,
-                resolved,
-            });
+            const result = await packageInfo.extract(spec, target, extractOptions);
             // Store computed integrity for git/remote deps
             if (result.integrity && !node.integrity) {
                 node.integrity = result.integrity;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vltpkg/graph",
   "description": "A library that helps understanding & expressing what happens on an install",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/vltpkg/vltpkg.git",
@@ -13,26 +13,26 @@
     "url": "http://vlt.sh"
   },
   "dependencies": {
-    "@vltpkg/cmd-shim": "1.0.2",
-    "@vltpkg/dep-id": "1.0.2",
-    "@vltpkg/dss-breadcrumb": "1.0.2",
-    "@vltpkg/error-cause": "1.0.2",
-    "@vltpkg/fast-split": "1.0.2",
-    "@vltpkg/graph-run": "1.0.2",
-    "@vltpkg/init": "1.0.2",
-    "@vltpkg/output": "1.0.2",
-    "@vltpkg/package-info": "1.0.2",
-    "@vltpkg/package-json": "1.0.2",
-    "@vltpkg/pick-manifest": "1.0.2",
-    "@vltpkg/query": "1.0.2",
-    "@vltpkg/rollback-remove": "1.0.2",
-    "@vltpkg/run": "1.0.2",
-    "@vltpkg/satisfies": "1.0.2",
-    "@vltpkg/security-archive": "1.0.2",
-    "@vltpkg/spec": "1.0.2",
-    "@vltpkg/types": "1.0.2",
-    "@vltpkg/vlt-json": "1.0.2",
-    "@vltpkg/workspaces": "1.0.2",
+    "@vltpkg/cmd-shim": "1.0.4",
+    "@vltpkg/dep-id": "1.0.4",
+    "@vltpkg/dss-breadcrumb": "1.0.4",
+    "@vltpkg/error-cause": "1.0.4",
+    "@vltpkg/fast-split": "1.0.4",
+    "@vltpkg/graph-run": "1.0.4",
+    "@vltpkg/init": "1.0.4",
+    "@vltpkg/output": "1.0.4",
+    "@vltpkg/package-info": "1.0.4",
+    "@vltpkg/package-json": "1.0.4",
+    "@vltpkg/pick-manifest": "1.0.4",
+    "@vltpkg/query": "1.0.4",
+    "@vltpkg/rollback-remove": "1.0.4",
+    "@vltpkg/run": "1.0.4",
+    "@vltpkg/satisfies": "1.0.4",
+    "@vltpkg/security-archive": "1.0.4",
+    "@vltpkg/spec": "1.0.4",
+    "@vltpkg/types": "1.0.4",
+    "@vltpkg/vlt-json": "1.0.4",
+    "@vltpkg/workspaces": "1.0.4",
     "path-scurry": "^2.0.1",
     "promise-call-limit": "^3.0.2"
   },