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

package/dist/reify/index.d.ts

@@ -0,0 +1,34 @@
+import type { PackageInfoClient } from '@vltpkg/package-info';
+import type { RollbackRemove } from '@vltpkg/rollback-remove';
+import type { DepID } from '@vltpkg/dep-id';
+import type { LoadOptions } from '../actual/load.ts';
+import type { AddImportersDependenciesMap, RemoveImportersDependenciesMap } from '../dependencies.ts';
+import { Diff } from '../diff.ts';
+import type { Graph } from '../graph.ts';
+import type { GraphModifier } from '../modifiers.ts';
+export type ReifyOptions = LoadOptions & {
+    add?: AddImportersDependenciesMap;
+    allowScripts: string;
+    remove?: RemoveImportersDependenciesMap;
+    graph: Graph;
+    actual?: Graph;
+    packageInfo: PackageInfoClient;
+    modifiers?: GraphModifier;
+    remover: RollbackRemove;
+    update?: boolean;
+};
+export type ReifyResult = {
+    /**
+     * The diff object that was used to reify the project.
+     */
+    diff: Diff;
+    /**
+     * Optional queue of DepIDs that requires building (running lifecycle scripts
+     * and binary linking) after the reification is complete.
+     */
+    buildQueue?: DepID[];
+};
+/**
+ * Make the current project match the supplied graph.
+ */
+export declare const reify: (options: ReifyOptions) => Promise<ReifyResult>;

package/dist/reify/index.js

@@ -0,0 +1,161 @@
+import { graphStep } from '@vltpkg/output';
+import { availableParallelism } from 'node:os';
+import { callLimit } from 'promise-call-limit';
+import { load as loadActual } from "../actual/load.js";
+import { Diff } from "../diff.js";
+import { lockfileData, saveData, saveHidden, } from "../lockfile/save.js";
+import { addEdges } from "./add-edges.js";
+import { addNodes } from "./add-nodes.js";
+import { build } from "./build.js";
+import { deleteEdges } from "./delete-edges.js";
+import { checkNeededBuild } from "./check-needed-build.js";
+import { deleteNodes } from "./delete-nodes.js";
+import { internalHoist } from "./internal-hoist.js";
+import { rollback } from "./rollback.js";
+import { updatePackageJson } from "./update-importers-package-json.js";
+import { copyFileSync } from 'node:fs';
+import { Query } from '@vltpkg/query';
+import { SecurityArchive } from '@vltpkg/security-archive';
+import { binChmodAll } from "./bin-chmod.js";
+const limit = Math.max(availableParallelism() - 1, 1) * 8;
+/**
+ * Filter nodes using a DSS query string
+ */
+const filterNodesByQuery = async (graph, allowScriptsQuery) => {
+    // shortcut no packages included
+    if (allowScriptsQuery === ':not(*)' /* c8 ignore next */ ||
+        !allowScriptsQuery) {
+        return new Set();
+    }
+    // shortcut all packages included
+    if (allowScriptsQuery === '*') {
+        return new Set(graph.nodes.keys());
+    }
+    /* c8 ignore start */
+    const securityArchive = Query.hasSecuritySelectors(allowScriptsQuery) ?
+        await SecurityArchive.start({
+            nodes: [...graph.nodes.values()],
+        })
+        : undefined;
+    /* c8 ignore stop */
+    const edges = graph.edges;
+    const nodes = new Set(graph.nodes.values());
+    const importers = graph.importers;
+    const query = new Query({
+        edges,
+        nodes,
+        importers,
+        securityArchive,
+    });
+    const { nodes: resultNodes } = await query.search(allowScriptsQuery, {
+        signal: new AbortController().signal,
+    });
+    return new Set(resultNodes.map(node => node.id));
+};
+/**
+ * Make the current project match the supplied graph.
+ */
+export const reify = async (options) => {
+    const done = graphStep('reify');
+    const { graph, scurry, remover } = options;
+    const actual = options.actual ??
+        loadActual({
+            ...options,
+            loadManifests: true,
+        });
+    const diff = new Diff(actual, graph);
+    const noModifiedDependencies = !options.add?.modifiedDependencies &&
+        !options.remove?.modifiedDependencies;
+    const skipOptionalOnly = noModifiedDependencies && diff.optionalOnly;
+    const skippable = skipOptionalOnly && !options.update;
+    const res = { diff };
+    if (!diff.hasChanges() || skippable) {
+        // nothing to do, so just return the diff
+        done();
+        return res;
+    }
+    let success = false;
+    try {
+        const { buildQueue } = await reify_(options, diff, remover);
+        remover.confirm();
+        success = true;
+        res.buildQueue = buildQueue;
+    }
+    finally {
+        /* c8 ignore start */
+        if (!success) {
+            await rollback(remover, diff, scurry).catch(() => { });
+        }
+        /* c8 ignore stop */
+    }
+    done();
+    return res;
+};
+const reify_ = async (options, diff, remover) => {
+    const res = {};
+    const { add, remove, packageInfo, packageJson, scurry, allowScripts, } = options;
+    const saveImportersPackageJson = 
+    /* c8 ignore next */
+    add?.modifiedDependencies || remove?.modifiedDependencies ?
+        updatePackageJson({
+            add,
+            remove,
+            graph: options.graph,
+            packageJson,
+        })
+        : undefined;
+    // before anything else happens, grab the ideal tree as it was resolved
+    // so that we can store it in the lockfile. We do this here so that
+    // any failed/removed optional deps are not reflected in the lockfile
+    // data as it is saved.
+    const lfData = lockfileData(options);
+    const actions = addNodes(diff, scurry, remover, options, packageInfo).concat(deleteEdges(diff, scurry, remover));
+    // need to wait, so that the nodes exist to link to
+    if (actions.length)
+        await callLimit(actions, { limit });
+    // create all node_modules symlinks, and link bins to nm/.bin
+    const edgeActions = addEdges(diff, scurry, remover);
+    if (edgeActions.length)
+        await callLimit(edgeActions, { limit });
+    await internalHoist(diff.to, options, remover);
+    // looks up all nodes setting buildState = 'needed'
+    // on nodes that require building
+    checkNeededBuild({ diff, scurry, packageJson });
+    // Filter nodes allowed to run scripts if allowScripts query is provided
+    const allowScriptsNodes = await filterNodesByQuery(diff.to, allowScripts);
+    // ensure that all added bins are chmod +x
+    await binChmodAll(diff.nodes.add, scurry);
+    // run install lifecycle scripts and link any binary files
+    await build(diff, packageJson, scurry, allowScriptsNodes);
+    // set the buildQueue on the result object containing
+    // an array with all the ids of nodes that need building
+    res.buildQueue = [...diff.nodes.add]
+        .filter(node => node.buildState === 'needed')
+        .map(node => node.id);
+    // if we had to change the actual graph along the way,
+    // make sure we do not leave behind any unreachable nodes
+    // TODO: add tests to cover this
+    /* c8 ignore start */
+    if (diff.hadOptionalFailures) {
+        for (const node of options.graph.gc().values()) {
+            diff.nodes.add.delete(node);
+            diff.nodes.delete.add(node);
+        }
+    }
+    /* c8 ignore stop */
+    saveHidden(options);
+    // delete garbage from the store.
+    const rmActions = deleteNodes(diff, remover, scurry);
+    if (rmActions.length)
+        await Promise.all(rmActions);
+    // updates package.json files if anything was added / removed
+    saveImportersPackageJson?.();
+    // write the ideal graph data to the lockfile
+    saveData(lfData, scurry.resolve('vlt-lock.json'), false);
+    // update the store config reference if a config file was used
+    if (scurry.lstatSync('vlt.json')) {
+        copyFileSync(scurry.resolve('vlt.json'), scurry.resolve('node_modules/.vlt/vlt.json'));
+    }
+    // returns the result object
+    return res;
+};

package/dist/reify/internal-hoist.d.ts

@@ -0,0 +1,8 @@
+import type { RollbackRemove } from '@vltpkg/rollback-remove';
+import type { Graph } from '../graph.ts';
+import type { Node } from '../node.ts';
+import type { ReifyOptions } from './index.ts';
+type InternalHoistOptions = Pick<ReifyOptions, 'projectRoot' | 'scurry'>;
+export declare const pickNodeToHoist: (nodes: Set<Node>) => Node | undefined;
+export declare const internalHoist: (graph: Graph, options: InternalHoistOptions, remover: RollbackRemove) => Promise<void>;
+export {};

package/dist/reify/internal-hoist.js

@@ -0,0 +1,133 @@
+import { splitDepID } from '@vltpkg/dep-id';
+import { Version } from '@vltpkg/semver';
+import { mkdir, symlink } from 'node:fs/promises';
+import { dirname, relative } from 'node:path';
+export const pickNodeToHoist = (nodes) => {
+    let pick = undefined;
+    let pickNode = undefined;
+    for (const node of nodes) {
+        if (node.importer || !node.inVltStore()) {
+            continue;
+        }
+        const id = splitDepID(node.id);
+        if (!pick || !pickNode) {
+            pick = id;
+            pickNode = node;
+            continue;
+        }
+        // if one is a dep of an importer, privilege that one
+        const impDep = [...node.edgesIn].some(n => n.from.importer);
+        const pickImpDep = [...pickNode.edgesIn].some(n => n.from.importer);
+        if (impDep !== pickImpDep) {
+            if (!pickImpDep) {
+                pick = id;
+                pickNode = node;
+            }
+            continue;
+        }
+        if (id[0] === 'registry') {
+            if (pick[0] !== 'registry') {
+                pick = id;
+                pickNode = node;
+                continue;
+            }
+            // both registry.
+            // otherwise, privilege the higher-version dependency
+            const pickVersion = pickNode.version;
+            const nodeVersion = node.version;
+            if (pickVersion) {
+                if (!nodeVersion)
+                    continue;
+                if (Version.parse(nodeVersion).greaterThan(Version.parse(pickVersion))) {
+                    pick = id;
+                    pickNode = node;
+                }
+                continue;
+            }
+            else if (nodeVersion) {
+                pick = id;
+                pickNode = node;
+                continue;
+            }
+        }
+        else {
+            // current node is not registry
+            if (pick[0] === 'registry')
+                continue;
+            // neither is pick node, select highest lexically sorted
+            if (pickNode.id.localeCompare(node.id, 'en') > 0) {
+                pick = id;
+                pickNode = node;
+            }
+        }
+    }
+    return pickNode;
+};
+export const internalHoist = async (graph, options, remover) => {
+    // create a list of all the nodes that we need to hoist.
+    // For each name, we prioritize registry deps over other types,
+    // and higher versions over lower ones. In the case of non-registry
+    // deps, we just pick the first item by sorting the DepIDs.
+    const links = new Map();
+    for (const [name, nodes] of graph.nodesByName) {
+        const pickNode = pickNodeToHoist(nodes);
+        if (pickNode) {
+            let picked = false;
+            if (pickNode.edgesIn.size > 0) {
+                for (const edgeIn of pickNode.edgesIn) {
+                    const otherName = edgeIn.name;
+                    if (otherName !== name && !links.has(otherName)) {
+                        picked = true;
+                        links.set(otherName, pickNode);
+                    }
+                }
+            }
+            if (!picked) {
+                links.set(name, pickNode);
+            }
+        }
+    }
+    // now we have a list of everything to hoist
+    // first, remove anything that is not what we want, and skip
+    // anything that would be linking what we already indend to link.
+    const { scurry } = options;
+    const hoistDir = scurry.cwd.resolve('node_modules/.vlt/node_modules');
+    await mkdir(hoistDir.fullpath(), { recursive: true });
+    const removes = [];
+    for (const entry of await hoistDir.readdir()) {
+        const name = entry.name;
+        // scoped package namespace
+        if (name.startsWith('@')) {
+            for (const pkg of await entry.readdir()) {
+                await checkExisting(`${name}/${pkg.name}`, pkg, links, removes, scurry, remover);
+            }
+        }
+        else {
+            await checkExisting(name, entry, links, removes, scurry, remover);
+        }
+    }
+    await Promise.all(removes);
+    const symlinks = [];
+    for (const [name, { name: nodeName, id }] of links) {
+        const target = scurry.resolve(`node_modules/.vlt/${id}/node_modules/${nodeName}`);
+        const path = scurry.resolve(`node_modules/.vlt/node_modules/${name}`);
+        if (name.includes('/')) {
+            await mkdir(dirname(path), { recursive: true });
+        }
+        symlinks.push(symlink(relative(dirname(path), target), path, 'dir'));
+    }
+    await Promise.all(symlinks);
+};
+const checkExisting = async (name, entry, links, removes, scurry, remover) => {
+    const target = await entry.readlink();
+    const { id } = links.get(name) /* c8 ignore next */ ?? {};
+    if (!target ||
+        !id ||
+        target !==
+            scurry.cwd.resolve(`node_modules/.vlt/${id}/node_modules/${name}`)) {
+        removes.push(remover.rm(entry.fullpath()));
+    }
+    else {
+        links.delete(name);
+    }
+};

package/dist/reify/optional-fail.d.ts

@@ -0,0 +1,15 @@
+import type { Diff } from '../diff.ts';
+import type { Node } from '../node.ts';
+/**
+ * If the node is optional, then returns an error handler that removes
+ * the node and its connected optional subgraph, by moving them into the
+ * "deleted" portion of the Diff object.
+ * Otherwise, it returns `undefined` so that the promise will simply reject.
+ */
+export declare function optionalFail(diff: Diff, node: Node & {
+    optional: true;
+}): () => void;
+export declare function optionalFail(diff: Diff, node: Node & {
+    optional: false;
+}): undefined;
+export declare function optionalFail(diff: Diff, node: Node): (() => void) | undefined;

package/dist/reify/optional-fail.js

@@ -0,0 +1,15 @@
+import { removeOptionalSubgraph } from "../remove-optional-subgraph.js";
+export function optionalFail(diff, node) {
+    return node.isOptional() ? () => del(diff, node) : undefined;
+}
+const del = (diff, node) => {
+    diff.hadOptionalFailures = true;
+    for (const del of removeOptionalSubgraph(diff.to, node)) {
+        // add it to the set of nodes being deleted
+        diff.nodes.delete.add(del);
+        // delete it from the set of nodes being added
+        diff.nodes.add.delete(del);
+    }
+    diff.nodes.add.delete(node);
+    diff.nodes.delete.add(node);
+};

package/dist/reify/rollback.d.ts

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

package/dist/reify/rollback.js

@@ -0,0 +1,23 @@
+import { RollbackRemove } from '@vltpkg/rollback-remove';
+import { deleteEdge } from "./delete-edge.js";
+export const rollback = async (remover, diff, scurry) => {
+    const promises = [];
+    const store = scurry.resolve('node_modules/.vlt');
+    // remove everything the diff tried to add
+    const backRoller = new RollbackRemove();
+    for (const node of diff.nodes.add) {
+        if (!node.inVltStore())
+            continue;
+        const path = scurry.resolve(store, node.id);
+        /* c8 ignore next */
+        promises.push(backRoller.rm(path).catch(() => { }));
+    }
+    for (const edge of diff.edges.add) {
+        promises.push(deleteEdge(edge, scurry, backRoller));
+    }
+    /* c8 ignore next */
+    await Promise.all(promises).catch(() => { });
+    backRoller.confirm();
+    /* c8 ignore next */
+    await remover.rollback().catch(() => { });
+};

package/dist/reify/update-importers-package-json.d.ts

@@ -0,0 +1,35 @@
+import type { PackageJson } from '@vltpkg/package-json';
+import type { AddImportersDependenciesMap, RemoveImportersDependenciesMap } from '../dependencies.ts';
+import type { Graph } from '../graph.ts';
+export type UpdatePackageJsonOptions = {
+    /**
+     * A `Map` 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;
+    /**
+     * A `Map` 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;
+    /**
+     * The {@link Graph} instance that contain the importer nodes to which
+     * the manifest data (and it's corresponding `package.json` file) are
+     * going to be updated.
+     */
+    graph: Graph;
+    /**
+     * An instance of {@link PackageJson} to use when writing updated manifest
+     * data to `package.json` files. It's necessary that this is the same
+     * instance used to load these `package.json` files previously.
+     */
+    packageJson: PackageJson;
+};
+/**
+ * Updates nodes of a provided {@link Graph} accordingly to the
+ * provided add or remove arguments.
+ */
+export declare const updatePackageJson: ({ add, graph, packageJson, remove, }: UpdatePackageJsonOptions) => () => void;

package/dist/reify/update-importers-package-json.js

@@ -0,0 +1,122 @@
+import { splitDepID } from '@vltpkg/dep-id';
+import { error } from '@vltpkg/error-cause';
+import { longDependencyTypes } from '@vltpkg/types';
+import { resolveSaveType } from "../resolve-save-type.js";
+import { calculateSaveValue } from "./calculate-save-value.js";
+const depTypesMap = new Map([
+    ['prod', 'dependencies'],
+    ['dev', 'devDependencies'],
+    ['peer', 'peerDependencies'],
+    ['peerOptional', 'peerDependencies'],
+    ['optional', 'optionalDependencies'],
+]);
+const addOrRemoveDeps = (nodeId, graph, addOrRemove) => {
+    const node = graph.nodes.get(nodeId);
+    if (!node) {
+        throw error('Failed to retrieve node', {
+            found: nodeId,
+        });
+    }
+    const manifest = node.manifest;
+    if (!manifest) {
+        throw error('Could not find manifest data for node', {
+            found: nodeId,
+        });
+    }
+    const deps = addOrRemove?.get(nodeId);
+    /* c8 ignore start -- impossible but TS doesn't know that */
+    if (!deps) {
+        throw error('Failed to retrieve added deps info', {
+            manifest,
+        });
+    }
+    let manifestChanged = false;
+    /* c8 ignore stop */
+    for (const deleteNameOrAddItem of deps) {
+        if (typeof deleteNameOrAddItem === 'string') {
+            const name = deleteNameOrAddItem;
+            for (const depType of longDependencyTypes) {
+                if (manifest[depType]?.[name]) {
+                    delete manifest[depType][name];
+                    manifestChanged = true;
+                }
+            }
+            if (manifest.peerDependenciesMeta?.[name]) {
+                delete manifest.peerDependenciesMeta[name];
+                manifestChanged = true;
+            }
+        }
+        else {
+            const [name, dep] = deleteNameOrAddItem;
+            // peerOptional also needs to add peerDependenciesMeta entry
+            const depTypeShort = resolveSaveType(node, name, dep.type);
+            const depType = depTypesMap.get(depTypeShort);
+            if (!depType) {
+                throw error('Failed to retrieve dependency type', {
+                    validOptions: [...depTypesMap.keys()],
+                    found: dep.type,
+                });
+            }
+            const n = node.edgesOut.get(name)?.to;
+            if (!n) {
+                throw error('Dependency node could not be found');
+            }
+            const [nodeType] = splitDepID(n.id);
+            for (const dtype of longDependencyTypes) {
+                if (dtype === depType || !manifest[dtype])
+                    continue;
+                delete manifest[dtype][name];
+            }
+            if (depTypeShort === 'peerOptional') {
+                manifest.peerDependenciesMeta ??= {};
+                manifest.peerDependenciesMeta[name] = { optional: true };
+            }
+            else if (manifest.peerDependenciesMeta?.[name]) {
+                delete manifest.peerDependenciesMeta[name];
+            }
+            const dependencies = manifest[depType] ?? (manifest[depType] = {});
+            // check to see if we need to save a different version
+            // - If you install a single specific version, that is deliberate,
+            //   we save that exact version, no matter what.
+            // - If the requested spec matches the manifest, make no change
+            // If the requested spec had no bareSpec, and the manifest has
+            // a dependency entry, make no change.
+            // If the requested spec has a bareSpec that did NOT match the manifest,
+            // then update it.
+            // If the manifest does not contain anything, then update it.
+            // Only for registry dependencies
+            const existing = dependencies[name];
+            const saveValue = calculateSaveValue(nodeType, dep.spec, existing, n.version);
+            dependencies[name] = saveValue;
+            manifestChanged = manifestChanged || saveValue !== existing;
+        }
+    }
+    return manifestChanged ? manifest : undefined;
+};
+/**
+ * Updates nodes of a provided {@link Graph} accordingly to the
+ * provided add or remove arguments.
+ */
+export const updatePackageJson = ({ add, graph, packageJson, remove, }) => {
+    const manifestsToUpdate = new Set();
+    const operations = new Set([add, remove]);
+    for (const operation of operations) {
+        if (operation) {
+            // These node ids are from either importer nodes or dependencies
+            // that are nested folders from which the user can also add new
+            // dependencies to
+            for (const nodeId of operation.keys()) {
+                const manifest = addOrRemoveDeps(nodeId, graph, operation);
+                if (manifest) {
+                    manifestsToUpdate.add(manifest);
+                }
+            }
+        }
+    }
+    const commit = () => {
+        for (const manifest of manifestsToUpdate) {
+            packageJson.save(manifest);
+        }
+    };
+    return commit;
+};

package/dist/remove-optional-subgraph.d.ts

@@ -0,0 +1,33 @@
+import type { Graph } from './graph.ts';
+import type { Node } from './node.ts';
+/**
+ * Remove the affected optional nodes starting from a given optional node
+ * that failed to resolve/install.
+ *
+ * Removing these dependents will frequently leave optional *dependencies*
+ * behind that are made unreachable from any project importer. For performance
+ * reasons, `graph.gc()` is not called automatically by this method, since
+ * multiple optional subgraphs may need to be removed in a single operation,
+ * and the mark-and-sweep garbage collection (a) can be excessively expensive,
+ * and (b) may need to communicate the set of garbage-collected nodes
+ * for cleanup (as in the case of optional node build failures during
+ * reification).
+ */
+export declare const removeOptionalSubgraph: (graph: Graph, startingNode: Node & {
+    optional: true;
+}) => Set<Node>;
+/**
+ * Given a starting node, this generator will walk back from the optional node
+ * to all of its optional dependents, emitting each one, and skipping any
+ * cycles.
+ *
+ * Note that when these are removed, it may create unreachable nodes in the
+ * graph! Be sure to call `graph.gc()` if these are removed.
+ */
+export declare function findOptionalSubgraph(node: Node & {
+    optional: true;
+}, seen?: Set<Node & {
+    optional: true;
+}>): Generator<Node & {
+    optional: true;
+}, void>;

package/dist/remove-optional-subgraph.js

@@ -0,0 +1,47 @@
+/**
+ * Remove the affected optional nodes starting from a given optional node
+ * that failed to resolve/install.
+ *
+ * Removing these dependents will frequently leave optional *dependencies*
+ * behind that are made unreachable from any project importer. For performance
+ * reasons, `graph.gc()` is not called automatically by this method, since
+ * multiple optional subgraphs may need to be removed in a single operation,
+ * and the mark-and-sweep garbage collection (a) can be excessively expensive,
+ * and (b) may need to communicate the set of garbage-collected nodes
+ * for cleanup (as in the case of optional node build failures during
+ * reification).
+ */
+export const removeOptionalSubgraph = (graph, startingNode) => {
+    const removed = new Set();
+    for (const node of findOptionalSubgraph(startingNode)) {
+        graph.removeNode(node, undefined, true);
+        removed.add(node);
+    }
+    return removed;
+};
+/**
+ * Given a starting node, this generator will walk back from the optional node
+ * to all of its optional dependents, emitting each one, and skipping any
+ * cycles.
+ *
+ * Note that when these are removed, it may create unreachable nodes in the
+ * graph! Be sure to call `graph.gc()` if these are removed.
+ */
+export function* findOptionalSubgraph(node, seen = new Set()) {
+    // already visited, prevent looping
+    if (seen.has(node))
+        return;
+    // the node itself is part of the subgraph, of course
+    seen.add(node);
+    yield node;
+    // and any of its dependents that are also optional
+    for (const { from, optional } of node.edgesIn) {
+        // if it's an optional *edge*, we don't need to remove it, because it
+        // doesn't need the node anyway. But if the node is optional and the
+        // dep isn't, then we do need to remove it.
+        if (from.isOptional() && !optional) {
+            for (const dep of findOptionalSubgraph(from, seen))
+                yield dep;
+        }
+    }
+}

package/dist/resolve-save-type.d.ts

@@ -0,0 +1,5 @@
+import type { DependencySaveType, DependencyTypeShort, NodeLike } from '@vltpkg/types';
+/**
+ * Resolve a {@link DependencySaveType} to a {@link DependencyTypeShort}
+ */
+export declare const resolveSaveType: (node: NodeLike, name: string, saveType: DependencySaveType) => DependencyTypeShort;

package/dist/resolve-save-type.js

@@ -0,0 +1,4 @@
+/**
+ * Resolve a {@link DependencySaveType} to a {@link DependencyTypeShort}
+ */
+export const resolveSaveType = (node, name, saveType) => saveType !== 'implicit' ? saveType : ((node.edgesOut.get(name)?.type ?? 'prod'));

package/dist/stringify-node.d.ts

@@ -0,0 +1,2 @@
+import type { NodeLike } from '@vltpkg/types';
+export declare const stringifyNode: (node?: NodeLike) => string;