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

package/dist/reify/add-edge.js

@@ -0,0 +1,71 @@
+import { cmdShimIfExists } from '@vltpkg/cmd-shim';
+import { mkdir, symlink } from 'node:fs/promises';
+import { dirname, relative, resolve } from 'node:path';
+const clobberSymlink = async (target, link, remover, type = 'file') => {
+    // On Windows, directory symlinks require elevated privileges.
+    // Use junctions instead, which work without special permissions.
+    // Junctions require absolute target paths, so resolve relative targets.
+    const symlinkType = type === 'dir' && process.platform === 'win32' ? 'junction' : type;
+    const symlinkTarget = symlinkType === 'junction' ?
+        resolve(dirname(link), target)
+        : target;
+    await mkdir(dirname(link), { recursive: true });
+    try {
+        await symlink(symlinkTarget, link, symlinkType);
+    }
+    catch (er) {
+        /* c8 ignore start */
+        if (er.code !== 'EEXIST') {
+            throw er;
+        }
+        /* c8 ignore stop */
+        // if the symlink exists, remove it
+        await remover.rm(link);
+        try {
+            // then try to create it again
+            await symlink(symlinkTarget, link, symlinkType);
+            /* c8 ignore start */
+        }
+        catch (er) {
+            // if the symlink still exists, then multiple paths could be writing to it
+            // so now just ignore that error. See https://github.com/vltpkg/vltpkg/issues/797
+            if (er.code !== 'EEXIST') {
+                throw er;
+            }
+        }
+        /* c8 ignore stop */
+    }
+};
+/**
+ * reify an edge into a node_modules folder, with bins linked
+ * this does NOT chmod the bins to 0o777, because they might not exist
+ * until scripts are run, in the case of non-store deps like workspaces
+ */
+export const addEdge = async (edge, scurry, remover, bins) => {
+    if (!edge.to)
+        return;
+    const binRoot = scurry.resolve(edge.from.nodeModules(scurry), '.bin');
+    const path = scurry.resolve(edge.from.nodeModules(scurry), edge.spec.name);
+    const promises = [];
+    const target = relative(dirname(path), edge.to.resolvedLocation(scurry));
+    // can only parallelize this on posix, because the win32 shims
+    // need to know that they will exist before being created.
+    const p = clobberSymlink(target, path, remover, 'dir');
+    if (process.platform === 'win32')
+        await p;
+    else
+        promises.push(p);
+    if (bins) {
+        for (const [key, val] of Object.entries(bins)) {
+            const link = scurry.resolve(binRoot, key);
+            const absTarget = scurry.resolve(path, val);
+            const target = relative(binRoot, absTarget);
+            // TODO: bash/cmd/ps1 shims on Windows
+            promises.push(process.platform === 'win32' ?
+                cmdShimIfExists(absTarget, link, remover)
+                : clobberSymlink(target, link, remover));
+        }
+    }
+    if (promises.length)
+        await Promise.all(promises);
+};

package/dist/reify/add-edges.d.ts

@@ -0,0 +1,4 @@
+import type { RollbackRemove } from '@vltpkg/rollback-remove';
+import type { PathScurry } from 'path-scurry';
+import type { Diff } from '../diff.ts';
+export declare const addEdges: (diff: Diff, scurry: PathScurry, remover: RollbackRemove) => (() => Promise<unknown>)[];

package/dist/reify/add-edges.js

@@ -0,0 +1,12 @@
+import { addEdge } from "./add-edge.js";
+export const addEdges = (diff, scurry, remover) => {
+    const actions = [];
+    for (const edge of diff.edges.add) {
+        const { to } = edge;
+        if (!to)
+            continue;
+        const bins = to.bins;
+        actions.push(() => addEdge(edge, scurry, remover, bins));
+    }
+    return actions;
+};

package/dist/reify/add-nodes.d.ts

@@ -0,0 +1,6 @@
+import type { PackageInfoClient } from '@vltpkg/package-info';
+import type { RollbackRemove } from '@vltpkg/rollback-remove';
+import type { SpecOptions } from '@vltpkg/spec';
+import type { PathScurry } from 'path-scurry';
+import type { Diff } from '../diff.ts';
+export declare const addNodes: (diff: Diff, scurry: PathScurry, remover: RollbackRemove, options: SpecOptions, packageInfo: PackageInfoClient) => (() => Promise<unknown>)[];

package/dist/reify/add-nodes.js

@@ -0,0 +1,16 @@
+import { extractNode } from "./extract-node.js";
+export const addNodes = (diff, scurry, remover, options, packageInfo) => {
+    const actions = [];
+    // fetch and extract all the nodes, removing any in the way
+    for (const node of diff.nodes.add) {
+        // if it's not in the store, we don't have to extract it, because
+        // we're just linking to a location that already exists.
+        if (!node.inVltStore())
+            continue;
+        // skip nodes that have already been extracted
+        if (node.extracted)
+            continue;
+        actions.push(() => extractNode(node, scurry, remover, options, packageInfo, diff));
+    }
+    return actions;
+};

package/dist/reify/bin-chmod.d.ts

@@ -0,0 +1,10 @@
+import type { PathScurry } from 'path-scurry';
+import type { Node } from '../node.ts';
+/**
+ * Make all the packages' bins executable.
+ */
+export declare const binChmodAll: (nodes: Iterable<Node>, scurry: PathScurry) => Promise<void>;
+/**
+ * Make all the package's bins executable.
+ */
+export declare const binChmod: (node: Node, scurry: PathScurry) => Promise<void>;

package/dist/reify/bin-chmod.js

@@ -0,0 +1,38 @@
+import { statSync, existsSync } from 'node:fs';
+import { chmod } from 'node:fs/promises';
+/**
+ * Make all the packages' bins executable.
+ */
+export const binChmodAll = async (nodes, scurry) => {
+    const chmods = [];
+    for (const node of nodes) {
+        chmods.push(binChmod(node, scurry));
+    }
+    await Promise.all(chmods);
+};
+/**
+ * Make all the package's bins executable.
+ */
+export const binChmod = async (node, scurry) => {
+    const chmods = [];
+    if (!node.bins)
+        return;
+    for (const bin of Object.values(node.bins)) {
+        const path = scurry.resolve(`${node.resolvedLocation(scurry)}/${bin}`);
+        // only try to make executable if the file exists
+        if (existsSync(path)) {
+            chmods.push(makeExecutable(path));
+        }
+    }
+    await Promise.all(chmods);
+};
+// 0 is "not yet set"
+// This is defined by doing `0o111 | <mode>` so that systems
+// that create files group-writable result in 0o775 instead of 0o755
+let execMode = 0;
+const makeExecutable = async (path) => {
+    if (!execMode) {
+        execMode = (statSync(path).mode & 0o777) | 0o111;
+    }
+    await chmod(path, execMode);
+};

package/dist/reify/build.d.ts

@@ -0,0 +1,13 @@
+import type { PackageJson } from '@vltpkg/package-json';
+import type { PathScurry } from 'path-scurry';
+import type { DepID } from '@vltpkg/dep-id';
+import type { Diff } from '../diff.ts';
+import type { Node } from '../node.ts';
+/**
+ * Returns an object mapping registries to the names of the packages built.
+ */
+export type BuildResult = {
+    success: Node[];
+    failure: Node[];
+};
+export declare const build: (diff: Diff, packageJson: PackageJson, scurry: PathScurry, allowScriptsNodes: Set<DepID>) => Promise<BuildResult>;

package/dist/reify/build.js

@@ -0,0 +1,111 @@
+// walk the graph of added nodes, building and chmoding their bins
+// at the end, we get back to the importers, and run their prepare
+// script as well as install script.
+import { join } from 'node:path';
+import { run } from '@vltpkg/run';
+import { graphRun } from '@vltpkg/graph-run';
+import { nonEmptyList } from "../non-empty-list.js";
+import { optionalFail } from "./optional-fail.js";
+import { binChmod } from "./bin-chmod.js";
+export const build = async (diff, packageJson, scurry, allowScriptsNodes) => {
+    const graph = diff.to;
+    const nodes = nonEmptyList([...graph.importers]);
+    const res = { success: [], failure: [] };
+    // determine if scripts should run - check if node is in allowed set
+    const shouldRunScripts = (node) => allowScriptsNodes.has(node.id);
+    /* c8 ignore next - all graphs have at least one importer */
+    if (!nodes)
+        return res;
+    await graphRun({
+        graph: nodes,
+        visit: async (node, signal, path) => {
+            // if it's not an importer or an added node, nothing to do.
+            // TODO: only build importers if it has changed deps, there's never
+            // been a previous build, or it contains something newer than the
+            // most recent build.
+            // For now, just always build all importers, because we don't
+            // track all that other stuff.
+            if (!node.importer &&
+                (!diff.nodes.add.has(node) || !shouldRunScripts(node)))
+                return;
+            try {
+                await visit(packageJson, scurry, node, signal, path);
+                if (!node.importer) {
+                    node.buildState = 'built';
+                    res.success.push(node);
+                }
+                /* c8 ignore start - windows on CI is missing those tests */
+            }
+            catch (err) {
+                // Check if this is an optional failure that was handled
+                if (node.optional) {
+                    node.buildState = 'failed';
+                    res.failure.push(node);
+                    // Let optionalFail handle the error
+                    await Promise.reject(err).catch(optionalFail(diff, node));
+                }
+                else {
+                    // Re-throw non-optional failures
+                    throw err;
+                }
+            }
+            /* c8 ignore stop */
+        },
+        getDeps: node => {
+            const deps = [];
+            for (const { to } of node.edgesOut.values()) {
+                /* c8 ignore next - vanishingly unlikely in practice */
+                if (to)
+                    deps.push(to);
+            }
+            return deps;
+        },
+    });
+    return res;
+};
+const visit = async (packageJson, scurry, node, signal, _path) => {
+    // at this point we might have to read the manifest from disk if it's
+    // currently nullish, that could happen in a scenario where the ideal
+    // graph is from a lockfile and there's no actual graph available
+    // to hydrate the manifest data from.
+    node.manifest ??= packageJson.read(node.resolvedLocation(scurry));
+    const { manifest } = node;
+    const { scripts = {} } = manifest;
+    const { install, preinstall, postinstall, prepare, preprepare, postprepare, } = scripts;
+    // Check for binding.gyp file (npm's implicit install detection)
+    // "If there is a binding.gyp file in the root of your package and you
+    // haven't defined your own install or preinstall scripts, npm will default
+    // the install command to compile using node-gyp via node-gyp rebuild"
+    const hasBindingGyp = scurry
+        .lstatSync(join(node.resolvedLocation(scurry), 'binding.gyp'))
+        ?.isFile() ?? false;
+    const hasImplicitInstall = hasBindingGyp && !install && !preinstall;
+    // if it has install script or binding.gyp (implicit install), run it
+    const runInstall = !!(install || preinstall || postinstall) || hasImplicitInstall;
+    if (runInstall) {
+        await run({
+            signal,
+            arg0: 'install',
+            ignoreMissing: true,
+            packageJson,
+            cwd: node.resolvedLocation(scurry),
+            projectRoot: node.projectRoot,
+            manifest,
+        });
+    }
+    // if it's an importer or git, run prepare
+    const prepable = node.id.startsWith('git') || node.importer || !node.inVltStore();
+    const runPrepare = !!(prepare || preprepare || postprepare) && prepable;
+    if (runPrepare) {
+        await run({
+            signal,
+            arg0: 'prepare',
+            ignoreMissing: true,
+            packageJson,
+            cwd: node.resolvedLocation(scurry),
+            projectRoot: node.projectRoot,
+            manifest,
+        });
+    }
+    await binChmod(node, scurry);
+};

package/dist/reify/calculate-save-value.d.ts

@@ -0,0 +1,2 @@
+import type { Spec } from '@vltpkg/spec';
+export declare const calculateSaveValue: (nodeType: string, spec: Spec, existing: string | undefined, nodeVersion: string | undefined) => string;

package/dist/reify/calculate-save-value.js

@@ -0,0 +1,50 @@
+const SAVE_PREFIX = '^';
+export const calculateSaveValue = (nodeType, spec, existing, nodeVersion) => {
+    // Catalog specs should always be preserved as-is in package.json.
+    // The catalog reference (e.g. "catalog:dev") is the user's intent;
+    // the resolved version is tracked in the lockfile.
+    if (spec.type === 'catalog') {
+        return spec.bareSpec;
+    }
+    if (
+    // if not from the registry, save whatever we requested
+    nodeType === 'registry' &&
+        // if we installed exactly what we already wanted, leave it untouched
+        spec.bareSpec !== existing &&
+        // if we installed a specific version, keep that specific version.
+        !spec.final.range?.isSingle) {
+        // if we had a single version, and got that version, then
+        // leave it as-is.
+        if (existing && existing === nodeVersion) {
+            // depend on 1.2.3, got 1.2.3, keep unchanged
+            return existing;
+        }
+        else if (existing && !spec.bareSpec) {
+            // if we had `"express": "5.1"` and did `vlt i express`,
+            // then leave it as-is, because we just installed our pj dep
+            return existing;
+        }
+        else {
+            const finalRange = (spec.final.semver && spec.final.bareSpec) ||
+                `${SAVE_PREFIX}${nodeVersion}`;
+            // didn't have dep previously, or depended on a different thing
+            // than what was requested. Update with the ^ range based on
+            // the node that landed in the graph, but preserve alias prefix
+            if (spec.subspec && spec.final.namedRegistry) {
+                return `${spec.final.namedRegistry}:${spec.final.name}@${finalRange}`;
+            }
+            if (spec.final.namedJsrRegistry) {
+                // if we were given an alternative name, preserve that
+                // do this with a regexp because the Spec objects get a little
+                // weird here, and the string is relatively straightforward.
+                return spec.bareSpec
+                    .replace(new RegExp(`^(?:.*?@)?${spec.final.namedJsrRegistry}:(@[^/]+/[^@]+)(@.*?)?$`), `${spec.final.namedJsrRegistry}:$1@${finalRange}`)
+                    .replace(
+                // otherwise, swap out the final version for the save range
+                new RegExp(`^(?:.*?@)?${spec.final.namedJsrRegistry}:([^@].*?)?$`), `${spec.final.namedJsrRegistry}:${finalRange}`);
+            }
+            return finalRange;
+        }
+    }
+    return spec.bareSpec;
+};

package/dist/reify/check-needed-build.d.ts

@@ -0,0 +1,34 @@
+import type { PathScurry } from 'path-scurry';
+import type { PackageJson } from '@vltpkg/package-json';
+import type { Diff } from '../diff.ts';
+import type { Node } from '../node.ts';
+/**
+ * Build data containing the queue of DepIDs that need building
+ */
+export type BuildData = {
+    needsBuildNodes: Node[];
+};
+/**
+ * Options for checking needed build data
+ */
+export type CheckNeededBuildOptions = {
+    /**
+     * The diff object containing nodes to process
+     */
+    diff: Diff;
+    /**
+     * PathScurry instance for filesystem access
+     */
+    scurry: PathScurry;
+    /**
+     * PackageJson instance for reading manifests from disk
+     */
+    packageJson: PackageJson;
+};
+/**
+ * Check which nodes need to be built and set buildState accordingly
+ * Marks nodes with buildState = 'needed' for those that require
+ * install lifecycle scripts as part of `vlt build`
+ * @returns {BuildData} The BuildData object containing Node objects that need building
+ */
+export declare const checkNeededBuild: (options: CheckNeededBuildOptions) => BuildData;

package/dist/reify/check-needed-build.js

@@ -0,0 +1,71 @@
+import { join } from 'node:path';
+/**
+ * Checks if a node needs to be built based on the conditions from build.ts:
+ * 1. Has install lifecycle scripts (install, preinstall, postinstall)
+ * 2. Has binding.gyp file with no install/preinstall scripts (implicit install)
+ * 3. Is an importer or git dependency with prepare scripts (prepare, preprepare, postprepare)
+ * 4. Has binary files that need to be linked
+ */
+const nodeNeedsBuild = (node, scurry, packageJson) => {
+    // If the node has already been built during reify, no need to build again
+    if (node.built)
+        return false;
+    // If the manifest is not available on the node, read it from disk.
+    // This can happen when the ideal graph is loaded from a lockfile
+    // and there's no actual graph available to hydrate the manifest data from.
+    let manifest = node.manifest;
+    if (!manifest) {
+        try {
+            manifest = packageJson.read(node.resolvedLocation(scurry));
+            node.manifest = manifest;
+        }
+        catch {
+            // If the manifest cannot be read (missing/corrupted), treat as
+            // "no build needed" to avoid failing the entire reification.
+            return false;
+        }
+    }
+    const { scripts = {} } = manifest;
+    // Check for install lifecycle scripts
+    const runInstall = !!(scripts.install ||
+        scripts.preinstall ||
+        scripts.postinstall);
+    if (runInstall)
+        return true;
+    // Check for binding.gyp file (npm's implicit install detection)
+    // "If there is a binding.gyp file in the root of your package and you
+    // haven't defined your own install or preinstall scripts, npm will default
+    // the install command to compile using node-gyp via node-gyp rebuild"
+    const hasBindingGyp = scurry
+        .lstatSync(join(node.resolvedLocation(scurry), 'binding.gyp'))
+        ?.isFile() ?? false;
+    if (hasBindingGyp && !scripts.install && !scripts.preinstall)
+        return true;
+    // Check for prepare scripts on importers or git dependencies
+    const prepable = node.id.startsWith('git') || node.importer || !node.inVltStore();
+    const runPrepare = !!((scripts.prepare || scripts.preprepare || scripts.postprepare)
+    /* c8 ignore next 2 */
+    ) && prepable;
+    if (runPrepare)
+        return true;
+    return false;
+};
+/**
+ * Check which nodes need to be built and set buildState accordingly
+ * Marks nodes with buildState = 'needed' for those that require
+ * install lifecycle scripts as part of `vlt build`
+ * @returns {BuildData} The BuildData object containing Node objects that need building
+ */
+export const checkNeededBuild = (options) => {
+    const { diff, scurry, packageJson } = options;
+    // Filter nodes to only include those that actually need to be built
+    const nodesToBuild = [...diff.nodes.add].filter(node => nodeNeedsBuild(node, scurry, packageJson));
+    // Set buildState = 'needed' on all nodes that require building
+    for (const node of nodesToBuild) {
+        node.buildState = 'needed';
+    }
+    const buildData = {
+        needsBuildNodes: nodesToBuild,
+    };
+    return buildData;
+};

package/dist/reify/delete-edge.d.ts

@@ -0,0 +1,4 @@
+import type { RollbackRemove } from '@vltpkg/rollback-remove';
+import type { PathScurry } from 'path-scurry';
+import type { Edge } from '../edge.ts';
+export declare const deleteEdge: (edge: Edge, scurry: PathScurry, remover: RollbackRemove) => Promise<void>;

package/dist/reify/delete-edge.js

@@ -0,0 +1,27 @@
+const rmBinPosix = (remover, bin) => {
+    return [remover.rm(bin)];
+};
+const rmBinWin32 = (remover, bin) => {
+    return [
+        remover.rm(bin),
+        remover.rm(bin + '.cmd'),
+        remover.rm(bin + '.ps1'),
+    ];
+};
+const rmBin = process.platform === 'win32' ? rmBinWin32 : rmBinPosix;
+export const deleteEdge = async (edge, scurry, remover) => {
+    const { spec: { name }, to, } = edge;
+    const nm = edge.from.nodeModules(scurry);
+    const path = scurry.resolve(nm, name);
+    const binRoot = scurry.cwd.resolve(`${nm}/.bin`);
+    const promises = [];
+    promises.push(remover.rm(path));
+    const bins = to?.bins;
+    if (bins) {
+        for (const key of Object.keys(bins)) {
+            const bin = binRoot.resolve(key).fullpath();
+            promises.push(...rmBin(remover, bin));
+        }
+    }
+    await Promise.all(promises);
+};

package/dist/reify/delete-edges.d.ts

@@ -0,0 +1,4 @@
+import type { RollbackRemove } from '@vltpkg/rollback-remove';
+import type { PathScurry } from 'path-scurry';
+import type { Diff } from '../diff.ts';
+export declare const deleteEdges: (diff: Diff, scurry: PathScurry, remover: RollbackRemove) => (() => Promise<unknown>)[];

package/dist/reify/delete-edges.js

@@ -0,0 +1,13 @@
+import { deleteEdge } from "./delete-edge.js";
+export const deleteEdges = (diff, scurry, remover) => {
+    const promises = [];
+    for (const edge of diff.edges.delete) {
+        // if the edge.from is a deleted node in the store, no need
+        // the entire dir will be removed in a later step.
+        if (diff.nodes.delete.has(edge.from) && edge.from.inVltStore()) {
+            continue;
+        }
+        promises.push(() => deleteEdge(edge, scurry, remover));
+    }
+    return promises;
+};

package/dist/reify/delete-nodes.d.ts

@@ -0,0 +1,4 @@
+import type { RollbackRemove } from '@vltpkg/rollback-remove';
+import type { PathScurry } from 'path-scurry';
+import type { Diff } from '../diff.ts';
+export declare const deleteNodes: (diff: Diff, remover: RollbackRemove, scurry: PathScurry) => Promise<unknown>[];

package/dist/reify/delete-nodes.js

@@ -0,0 +1,15 @@
+import { deleteEdge } from "./delete-edge.js";
+export const deleteNodes = (diff, remover, scurry) => {
+    const store = scurry.resolve('node_modules/.vlt');
+    const rmActions = [];
+    for (const node of diff.nodes.delete) {
+        // do not delete workspaces or link targets
+        if (!node.inVltStore())
+            continue;
+        rmActions.push(remover.rm(scurry.resolve(store, node.id)));
+        for (const edge of node.edgesIn) {
+            rmActions.push(deleteEdge(edge, scurry, remover));
+        }
+    }
+    return rmActions;
+};

package/dist/reify/extract-node.d.ts

@@ -0,0 +1,23 @@
+import type { PackageInfoClient } from '@vltpkg/package-info';
+import type { RollbackRemove } from '@vltpkg/rollback-remove';
+import type { SpecOptions } from '@vltpkg/spec';
+import type { PathScurry } from 'path-scurry';
+import type { Diff } from '../diff.ts';
+import type { Node } from '../node.ts';
+/**
+ * Result of the extraction operation.
+ * Either the extracted package data or an error if extraction failed.
+ */
+export type ExtractResult = {
+    success: true;
+    node: Node;
+} | {
+    success: false;
+    node: Node;
+    error: unknown;
+};
+/**
+ * Extract a single node to the file system.
+ * Returns a promise that resolves when the extraction is complete.
+ */
+export declare const extractNode: (node: Node, scurry: PathScurry, remover: RollbackRemove, options: SpecOptions, packageInfo: PackageInfoClient, diff?: Diff) => Promise<ExtractResult>;

package/dist/reify/extract-node.js

@@ -0,0 +1,83 @@
+import { hydrate } from '@vltpkg/dep-id';
+import { platformCheck } from '@vltpkg/pick-manifest';
+import { optionalFail } from "./optional-fail.js";
+import { removeOptionalSubgraph } from "../remove-optional-subgraph.js";
+/**
+ * Returns a function that handles removing
+ * a failed optional node from its graph.
+ * Returns undefined for non-optional nodes when no diff is provided.
+ */
+const getOptionalFailedNodeRemover = (node, diff) => {
+    return (diff ? optionalFail(diff, node)
+        : node.isOptional() ?
+            () => removeOptionalSubgraph(node.graph, node)
+            : undefined);
+};
+/**
+ * Extract a single node to the file system.
+ * Returns a promise that resolves when the extraction is complete.
+ */
+export const extractNode = async (node, scurry, remover, options, packageInfo, diff) => {
+    node.extracted = true;
+    const { manifest = {} } = node;
+    const target = node.resolvedLocation(scurry);
+    const from = scurry.resolve('');
+    const spec = hydrate(node.id, node.name, options);
+    const removeOptionalFailedNode = getOptionalFailedNodeRemover(node, diff);
+    const { integrity, resolved } = node;
+    // Use platform data from node if available (from lockfile), otherwise fall back to manifest
+    const platformData = node.platform ?? manifest;
+    // Check if we should skip this node due to platform incompatibility or deprecation
+    if (removeOptionalFailedNode &&
+        (manifest.deprecated ||
+            !platformCheck(platformData, process.version, process.platform, process.arch))) {
+        removeOptionalFailedNode();
+        return {
+            success: false,
+            node,
+            error: new Error('Platform check failed or package deprecated'),
+        };
+    }
+    try {
+        await remover.rm(target);
+        if (removeOptionalFailedNode) {
+            try {
+                const result = await packageInfo.extract(spec, target, {
+                    from,
+                    integrity,
+                    resolved,
+                });
+                // Store computed integrity for git/remote deps
+                if (result.integrity && !node.integrity) {
+                    node.integrity = result.integrity;
+                }
+                return { success: true, node };
+            }
+            catch (error) {
+                removeOptionalFailedNode();
+                return { success: false, node, error };
+            }
+        }
+        else {
+            const result = await packageInfo.extract(spec, target, {
+                from,
+                integrity,
+                resolved,
+            });
+            // Store computed integrity for git/remote deps
+            if (result.integrity && !node.integrity) {
+                node.integrity = result.integrity;
+            }
+            return { success: true, node };
+        }
+    }
+    catch (error) {
+        /* c8 ignore start */
+        if (removeOptionalFailedNode) {
+            removeOptionalFailedNode();
+            return { success: false, node, error };
+        }
+        /* c8 ignore stop */
+        throw error;
+    }
+};