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

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

@@ -0,0 +1,11 @@
+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';
+export type ProcessingEdge = {
+    fromNode: NodeLike;
+    toNode: NodeLike | undefined;
+    depType: DependencyTypeShort;
+    spec: Spec;
+};
+export declare const loadEdges: (graph: GraphLike, edges: LockfileData["edges"], options: SpecOptions) => void;

package/dist/lockfile/load-edges.js

@@ -0,0 +1,105 @@
+import { asDepID } from '@vltpkg/dep-id/browser';
+import { error } from '@vltpkg/error-cause';
+import { fastSplit } from '@vltpkg/fast-split';
+import { Spec } from '@vltpkg/spec/browser';
+import { longDependencyTypes } from '@vltpkg/types';
+import { isDependencyTypeShort } from "../dependencies.js";
+const retrieveNodeFromGraph = (key, value, graph, fromId, seenNodes) => {
+    const foundNode = graph.nodes.get(asDepID(fromId));
+    if (!foundNode) {
+        throw error('Edge info missing its `from` node', {
+            found: {
+                nodes: [...graph.nodes].map(([id]) => id),
+                from: foundNode,
+                fromId,
+                edge: { [key]: value },
+            },
+        });
+    }
+    if (seenNodes) {
+        seenNodes.set(fromId, foundNode);
+    }
+    return foundNode;
+};
+export const loadEdges = (graph, edges, options) => {
+    const entries = Object.entries(edges);
+    const edgeCount = entries.length;
+    // Only use optimizations for non-trivial graphs
+    const useOptimizations = edgeCount > 50;
+    const edgeProcessingQueue = [];
+    // Cache for frequently accessed nodes to avoid repeated Map lookups
+    const seenNodes = useOptimizations ? new Map() : undefined;
+    for (const [key, value] of entries) {
+        const [fromId, specName] = fastSplit(key, ' ', 2);
+        const [depType, valRest] = fastSplit(value, ' ', 2);
+        const vrSplit = valRest?.lastIndexOf(' ') ?? -1;
+        // not a valid edge record
+        /* c8 ignore start */
+        if (!valRest || !depType || !fromId || !specName || vrSplit < 1) {
+            continue;
+        }
+        /* c8 ignore stop */
+        // Validate dependency type early
+        if (!isDependencyTypeShort(depType)) {
+            throw error('Found unsupported dependency type in lockfile', {
+                validOptions: [...longDependencyTypes],
+            });
+        }
+        // Use cached node lookup for large graphs, direct lookup for small ones
+        let fromNode;
+        if (seenNodes) {
+            const seen = seenNodes.get(fromId);
+            if (seen) {
+                fromNode = seen;
+            }
+            else {
+                fromNode = retrieveNodeFromGraph(key, value, graph, fromId, seenNodes);
+            }
+        }
+        else {
+            fromNode = retrieveNodeFromGraph(key, value, graph, fromId);
+        }
+        const toId = valRest.substring(vrSplit + 1);
+        let toNode = undefined;
+        if (toId !== 'MISSING') {
+            if (seenNodes) {
+                const seen = seenNodes.get(toId);
+                if (seen) {
+                    toNode = seen;
+                }
+                else {
+                    toNode = graph.nodes.get(asDepID(toId));
+                    if (toNode) {
+                        seenNodes.set(toId, toNode);
+                    }
+                }
+            }
+            else {
+                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,
+        });
+        if (useOptimizations) {
+            edgeProcessingQueue.push({
+                fromNode,
+                toNode,
+                depType,
+                spec,
+            });
+        }
+        else {
+            // Process immediately for small graphs
+            graph.addEdge(depType, spec, fromNode, toNode);
+        }
+    }
+    // Batch process all edges (only for non-trivial graphs)
+    if (useOptimizations) {
+        for (const { fromNode, toNode, depType, spec, } of edgeProcessingQueue) {
+            graph.addEdge(depType, spec, fromNode, toNode);
+        }
+    }
+};

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

@@ -0,0 +1,4 @@
+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;

package/dist/lockfile/load-nodes.js

@@ -0,0 +1,101 @@
+import { error } from '@vltpkg/error-cause';
+import { 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);
+    const nodeCount = entries.length;
+    // Batch process registry spec parsing (only for large graphs)
+    // Only used for non-trivial graphs
+    const registryVersionCache = nodeCount > 50 ? new Map() : null;
+    for (const [id, lockfileNode] of entries) {
+        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
+        if (graph.nodes.has(id))
+            continue;
+        const [type, filepath, maybeExtra, lastExtra] = splitDepID(id);
+        const extra = type === 'registry' || type === 'git' ? lastExtra : maybeExtra;
+        const registrySpec = maybeExtra;
+        // The reference node is a node that matches the same id from the
+        // current iterating node in the provided `actual` graph, this allows
+        // for hydrating missing manifest, integrity, and resolved values
+        // that may be missing from the lockfile
+        const referenceNode = actual?.nodes.get(id);
+        const mani = manifest ?? referenceNode?.manifest;
+        // Throw if manifest is missing and the option is enabled
+        if (!mani && throwOnMissingManifest) {
+            throw error(`Missing manifest for node ${id} and no reference node found.`);
+        }
+        // Optimize registry version extraction with caching for large graphs
+        let version;
+        if (type === 'registry' &&
+            registrySpec &&
+            registrySpec.indexOf('@') > 0) {
+            if (registryVersionCache) {
+                const seenVersion = registryVersionCache.get(registrySpec);
+                /* c8 ignore start */
+                if (seenVersion) {
+                    version = seenVersion;
+                }
+                else {
+                    version = registrySpec.split('@').slice(-1)[0] || undefined;
+                    /* c8 ignore stop */
+                    if (version) {
+                        registryVersionCache.set(registrySpec, version);
+                    }
+                }
+            }
+            else {
+                version = registrySpec.split('@').slice(-1)[0] || undefined;
+            }
+        }
+        // if the lockfile has manifest data then it should just use that
+        // otherwise tries to infer name / version value from the lockfile node
+        const node = mani ?
+            graph.addNode(id, mani)
+            : graph.addNode(id, undefined, undefined, name ?? undefined, version);
+        if (extra) {
+            const { modifier, peerSetHash } = splitExtra(extra);
+            if (modifier) {
+                node.modifier = modifier;
+            }
+            if (peerSetHash) {
+                node.peerSetHash = peerSetHash;
+            }
+        }
+        const { dev, optional } = getBooleanFlagsFromNum(flags);
+        node.options = options;
+        node.dev = dev;
+        node.optional = optional;
+        node.integrity = integrity ?? referenceNode?.integrity;
+        node.resolved =
+            type === 'remote' ? filepath : ((resolved ?? referenceNode?.resolved));
+        node.projectRoot = graph.projectRoot;
+        if (!node.resolved)
+            node.setResolved();
+        if (location) {
+            node.location = location;
+        }
+        else {
+            // set the location to file dependencies based on the id value
+            if (type === 'file') {
+                node.location = filepath;
+            }
+        }
+        if (mani && rawManifest) {
+            node.setConfusedManifest(mani, rawManifest);
+        }
+        // Set platform data if provided
+        if (platform) {
+            node.platform = platform;
+        }
+        // optionally set bin data if provided
+        if (bins) {
+            node.bins = bins;
+        }
+        // Set build state if provided
+        if (buildState !== undefined && buildState !== null) {
+            node.buildState = getBuildStateFromNum(buildState);
+        }
+    }
+};

package/dist/lockfile/load.d.ts

@@ -0,0 +1,45 @@
+import { PackageJson } from '@vltpkg/package-json';
+import { Monorepo } from '@vltpkg/workspaces';
+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 { GraphModifier } from '../modifiers.ts';
+export type LoadOptions = SpecOptions & {
+    /**
+     * An optional {@link Graph} object to hydrate extra data from.
+     */
+    actual?: Graph;
+    /**
+     * The project root dirname.
+     */
+    projectRoot: string;
+    /**
+     * The project root manifest.
+     */
+    mainManifest: NormalizedManifest;
+    /**
+     * The graph modifiers helper object.
+     */
+    modifiers?: GraphModifier;
+    /**
+     * A {@link Monorepo} object, for managing workspaces
+     */
+    monorepo?: Monorepo;
+    /**
+     * A {@link PackageJson} object, for sharing manifest caches
+     */
+    packageJson?: PackageJson;
+    /**
+     * A {@link PathScurry} object, for use in globs
+     */
+    scurry?: PathScurry;
+    /**
+     * Whether to throw an error if a manifest is missing when loading nodes.
+     */
+    throwOnMissingManifest?: boolean;
+};
+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

@@ -0,0 +1,84 @@
+import { error } from '@vltpkg/error-cause';
+import { PackageJson } from '@vltpkg/package-json';
+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'));
+};
+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 = {}, 'scope-registries': scopeRegistries, registry, registries, 'git-hosts': gitHosts, 'git-host-archives': gitHostArchives,
+    /* c8 ignore next */
+     } = lockfileData.options ?? {};
+    // Optimize options merging - only create new objects when needed
+    const mergedOptions = {
+        ...options,
+        catalog,
+        catalogs,
+        'scope-registries': scopeRegistries ?
+            { ...options['scope-registries'], ...scopeRegistries }
+            : options['scope-registries'],
+        registry: registry ?? options.registry,
+        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,
+    });
+    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/lockfile/save.d.ts

@@ -0,0 +1,30 @@
+import type { SpecOptions } from '@vltpkg/spec';
+import type { Graph } from '../graph.ts';
+import type { LockfileData } from './types.ts';
+import type { GraphModifier } from '../modifiers.ts';
+export type SaveOptions = SpecOptions & {
+    /**
+     * The graph to be stored in the lockfile.
+     */
+    graph: Graph;
+    /**
+     * The graph modifiers helper object.
+     */
+    modifiers?: GraphModifier;
+    /**
+     * Should it save manifest data in the lockfile?
+     */
+    saveManifests?: boolean;
+    /**
+     * Should it save build state data in the lockfile?
+     */
+    saveBuildData?: boolean;
+    /**
+     * Should it throw an error if a manifest is missing?
+     */
+    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 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;

package/dist/lockfile/save.js

@@ -0,0 +1,174 @@
+import { expandNormalizedManifestSymbols, isRecordStringString, } from '@vltpkg/types';
+import { defaultGitHostArchives, defaultGitHosts, defaultJsrRegistries, defaultRegistries, defaultRegistry, defaultScopeRegistries, } from '@vltpkg/spec';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { getFlagNumFromNode, getBuildStateFromNode, LOCKFILE_VERSION, } from "./types.js";
+import { error } from '@vltpkg/error-cause';
+const formatNodes = (nodes, saveManifests, saveBuildData, registry, throwOnMissingManifest) => {
+    // we do not store importers in the lockfile, though we do store
+    // their edges. when we load, we always read workspaces/main fresh.
+    const arr = [...nodes].filter(node => !node.importer);
+    // nodes are sorted in order to have a deterministic result
+    const orderedNodes = arr.sort((a, b) => a.id.localeCompare(b.id, 'en'));
+    const res = {};
+    for (const node of orderedNodes) {
+        const customRegistry = node.resolved && registry && !node.resolved.startsWith(registry);
+        const resolved = customRegistry ? node.resolved : undefined;
+        // if it's in a location other than the default, stash that
+        const location = node.id.startsWith('file') || node.inVltStore() ?
+            undefined
+            : node.location;
+        const flags = getFlagNumFromNode(node);
+        const lockfileNode = [flags, node.name];
+        if (node.integrity) {
+            lockfileNode[2] = node.integrity;
+        }
+        // skip resolved for remote nodes since
+        // these are already part of the dep id
+        if (resolved && !node.id.startsWith('remote')) {
+            lockfileNode[3] = resolved;
+        }
+        if (location) {
+            lockfileNode[4] = location;
+        }
+        if (saveManifests && node.manifest) {
+            lockfileNode[5] = expandNormalizedManifestSymbols(node.manifest);
+            if (node.confused && node.rawManifest) {
+                lockfileNode[6] = expandNormalizedManifestSymbols(node.rawManifest);
+            }
+        }
+        // Throw an error if a manifest is missing and the option is enabled
+        if (throwOnMissingManifest && !node.manifest) {
+            throw error(`Missing manifest for node ${node.id}.`);
+        }
+        // Always save platform data for optional dependencies if available
+        if (node.optional && node.platform) {
+            lockfileNode[7] = node.platform;
+        }
+        // Save bin data if available
+        if (node.bins && Object.keys(node.bins).length) {
+            lockfileNode[8] = node.bins;
+        }
+        // Save build state data if requested
+        if (saveBuildData) {
+            const buildState = getBuildStateFromNode(node);
+            if (buildState !== undefined) {
+                lockfileNode[9] = buildState;
+            }
+        }
+        res[node.id] = lockfileNode;
+    }
+    return res;
+};
+const formatEdges = (edges) => Object.fromEntries([...edges]
+    .sort((a, b) => 
+/* c8 ignore start - nondeterminstic and annoying to test */
+// sort importers to the top, then alphabetically by
+// id, type, target
+Number(b.from.importer) - Number(a.from.importer) ||
+    a.from.id.localeCompare(b.from.id, 'en') ||
+    a.type.localeCompare(b.type, 'en') ||
+    (a.to?.id ?? '').localeCompare(b.to?.id ?? ''))
+    .map((edge) => [
+    `${edge.from.id} ${edge.spec.name}`,
+    `${edge.type} ${edge.spec.bareSpec || '*'} ${edge.to?.id ?? 'MISSING'}`,
+]));
+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;
+};
+export const lockfileData = ({ graph, catalog, catalogs, 'git-hosts': gitHosts, 'git-host-archives': gitHostArchives, modifiers, registry, registries, saveManifests, saveBuildData, 'scope-registries': scopeRegistries, 'jsr-registries': jsrRegistries, throwOnMissingManifest, }) => {
+    const cleanGitHosts = isRecordStringString(gitHosts) ?
+        removeDefaultItems(defaultGitHosts, gitHosts)
+        : undefined;
+    const cleanGitHostArchives = isRecordStringString(gitHostArchives) ?
+        removeDefaultItems(defaultGitHostArchives, gitHostArchives)
+        : undefined;
+    const cleanModifiers = modifiers && isRecordStringString(modifiers.config) ?
+        modifiers.config
+        : undefined;
+    const cleanRegistries = isRecordStringString(registries) ?
+        removeDefaultItems(defaultRegistries, registries)
+        : undefined;
+    const cleanScopeRegistries = isRecordStringString(scopeRegistries) ?
+        removeDefaultItems(defaultScopeRegistries, scopeRegistries)
+        : undefined;
+    const cleanJsrRegistries = isRecordStringString(jsrRegistries) ?
+        removeDefaultItems(defaultJsrRegistries, jsrRegistries)
+        : undefined;
+    const hasItems = (clean) => clean && Object.keys(clean).length;
+    return {
+        lockfileVersion: LOCKFILE_VERSION,
+        options: {
+            ...(hasItems(cleanModifiers) ?
+                { modifiers: cleanModifiers }
+                : {}),
+            ...(hasItems(catalog) ? { catalog } : {}),
+            ...(hasItems(catalogs) ? { catalogs } : {}),
+            ...(hasItems(cleanScopeRegistries) ?
+                { 'scope-registries': cleanScopeRegistries }
+                : undefined),
+            ...(hasItems(cleanJsrRegistries) ?
+                { 'jsr-registries': cleanJsrRegistries }
+                : undefined),
+            ...(registry !== undefined && registry !== defaultRegistry ?
+                { registry }
+                : undefined),
+            ...(hasItems(cleanRegistries) ?
+                { registries: cleanRegistries }
+                : undefined),
+            ...(hasItems(cleanGitHosts) ?
+                { 'git-hosts': cleanGitHosts }
+                : undefined),
+            ...(hasItems(cleanGitHostArchives) ?
+                { 'git-host-archives': cleanGitHostArchives }
+                : undefined),
+        },
+        nodes: formatNodes(graph.nodes.values(), saveManifests, saveBuildData, registry, throwOnMissingManifest),
+        edges: formatEdges(graph.edges),
+    };
+};
+// renders each node / edge as a single line entry
+const extraFormat = (jsonString) => {
+    const str = `${jsonString}\n`;
+    const [init, ...parts] = str.split('  "nodes": {');
+    const res = [init];
+    for (const part of parts) {
+        res.push(part.replaceAll('\n      ', '').replaceAll('\n    ]', ']'));
+    }
+    return res.join('  "nodes": {');
+};
+export const saveData = (data, fileName, saveManifests = false) => {
+    const json = JSON.stringify(data, null, 2);
+    const content = saveManifests ? json : extraFormat(json);
+    writeFileSync(fileName, content);
+};
+export const save = (options) => {
+    const { graph } = options;
+    const data = lockfileData({ ...options, saveManifests: false });
+    const fileName = resolve(graph.projectRoot, 'vlt-lock.json');
+    saveData(data, fileName, false);
+};
+export const saveHidden = (options) => {
+    const { graph } = options;
+    let data;
+    try {
+        data = lockfileData({
+            ...options,
+            saveManifests: true,
+            saveBuildData: true,
+            throwOnMissingManifest: true,
+        });
+    }
+    catch { }
+    if (!data)
+        return;
+    const fileName = resolve(graph.projectRoot, 'node_modules/.vlt-lock.json');
+    mkdirSync(dirname(fileName), { recursive: true });
+    saveData(data, fileName, true);
+};

package/dist/lockfile/types.d.ts

@@ -0,0 +1,95 @@
+import type { DepID } from '@vltpkg/dep-id';
+import type { Spec, SpecOptions } from '@vltpkg/spec';
+import type { Integrity, NormalizedManifest, DependencyTypeShort } from '@vltpkg/types';
+/**
+ * Platform requirements for a lockfile node
+ */
+export type LockfilePlatform = {
+    engines?: Record<string, string>;
+    os?: string[] | string;
+    cpu?: string[] | string;
+    libc?: string[] | string;
+};
+/**
+ * This is the main type definition for the contents of the
+ * `vlt-lock.json` file.
+ *
+ * The nodes and edges information from the lockfile are used to reconstruct
+ * a {@link Graph} representing a previous install.
+ */
+export type LockfileData = {
+    lockfileVersion: number;
+    options: SpecOptions & {
+        modifiers?: Record<string, string> | undefined;
+    };
+    nodes: Record<DepID, LockfileNode>;
+    edges: LockfileEdges;
+};
+/**
+ * Current lockfile format version.
+ * Only lockfiles with matching version are considered valid.
+ * Bump when making breaking format changes.
+ */
+export declare const LOCKFILE_VERSION = 1;
+export declare const getFlagNumFromNode: (node: {
+    optional?: boolean;
+    dev?: boolean;
+}) => 1 | 0 | 2 | 3;
+export declare const getBooleanFlagsFromNum: (flags: LockfileNodeFlags) => {
+    dev: boolean;
+    optional: boolean;
+};
+export declare const LockfileNodeFlagNone = 0;
+export declare const LockfileNodeFlagOptional = 1;
+export declare const LockfileNodeFlagDev = 2;
+export declare const LockfileNodeFlagDevOptional = 3;
+/**
+ * Bit flags indicating whether a node is optional and/or dev.
+ */
+export type LockfileNodeFlags = 0 | 1 | 2 | 3;
+/**
+ * Build state constants for lockfile nodes
+ */
+export declare const BuildStateNone: undefined;
+export declare const BuildStateNeeded = 1;
+export declare const BuildStateBuilt = 2;
+export declare const BuildStateFailed = 3;
+/**
+ * Build state for a node - tracks whether it needs building, has been built, or failed
+ */
+export type LockfileBuildState = undefined | 1 | 2 | 3;
+export declare const getBuildStateFromNode: (node: {
+    buildState?: "none" | "needed" | "built" | "failed";
+}) => LockfileBuildState;
+export declare const getBuildStateFromNum: (state: LockfileBuildState) => "none" | "needed" | "built" | "failed";
+/**
+ * Lockfile representation of a node from the install graph.
+ */
+export type LockfileNode = [
+    flags: LockfileNodeFlags,
+    name?: string | null,
+    integrity?: Integrity | null,
+    resolved?: string | null,
+    location?: string | null,
+    manifest?: NormalizedManifest | null,
+    rawManifest?: NormalizedManifest | null,
+    platform?: LockfilePlatform | null,
+    bins?: Record<string, string> | null,
+    buildState?: LockfileBuildState | null
+];
+/**
+ * Lockfile edges are stored as a record object where the key
+ * is `${from.id} ${spec.name}` and the value is
+ * `${type} ${spec.bareSpec} ${to.id | 'MISSING'}`
+ *
+ * Storing them in a record like this means that we are guaranteed to
+ * never end up with duplicates, and a standard `JSON.stringify()`
+ * will nicely print them out one line per edge.
+ */
+export type LockfileEdges = {
+    [key: LockfileEdgeKey]: LockfileEdgeValue;
+};
+/** `${from} ${dep name}` */
+export type LockfileEdgeKey = `${DepID} ${string}`;
+/** `${type} ${spec} ${to}` */
+export type LockfileEdgeValue = `${DependencyTypeShort} ${Spec['bareSpec']} ${DepID | 'MISSING'}`;