@pnpm/lockfile.fs 1100.1.13 → 1100.1.15

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @pnpm/lockfile-file
 
+## 1100.1.15
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/deps.path@1100.0.12
+  - @pnpm/lockfile.merger@1100.0.17
+  - @pnpm/lockfile.types@1100.0.17
+  - @pnpm/lockfile.utils@1100.1.6
+  - @pnpm/types@1101.7.0
+
+## 1100.1.14
+
+### Patch Changes
+
+- Republished every package: the tarballs published by the v11.13.1 through v11.16.0 releases were missing most of their compiled files due to a packing bug [#13164](https://github.com/pnpm/pnpm/issues/13164).
+
+- Updated dependencies:
+  - @pnpm/constants@1100.0.1
+  - @pnpm/deps.path@1100.0.11
+  - @pnpm/error@1100.1.0
+  - @pnpm/lockfile.merger@1100.0.16
+  - @pnpm/lockfile.types@1100.0.16
+  - @pnpm/lockfile.utils@1100.1.5
+  - @pnpm/network.git-utils@1100.0.3
+  - @pnpm/object.key-sorting@1100.0.2
+  - @pnpm/types@1101.6.0
+
 ## 1100.1.13
 
 ### Patch Changes

package/lib/envLockfile.d.ts

@@ -0,0 +1,4 @@
+import type { EnvLockfile } from '@pnpm/lockfile.types';
+export declare function createEnvLockfile(): EnvLockfile;
+export declare function readEnvLockfile(rootDir: string): Promise<EnvLockfile | null>;
+export declare function writeEnvLockfile(rootDir: string, lockfile: EnvLockfile): Promise<void>;

package/lib/envLockfile.js

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import { LOCKFILE_VERSION, WANTED_LOCKFILE } from '@pnpm/constants';
+import yaml from 'js-yaml';
+import writeFileAtomic from 'write-file-atomic';
+import { sortLockfileKeys } from './sortLockfileKeys.js';
+import { lockfileYamlDump } from './write.js';
+import { extractMainDocument, readLockfileToStringNoFollow, streamReadFirstYamlDocument } from './yamlDocuments.js';
+export function createEnvLockfile() {
+    return {
+        lockfileVersion: LOCKFILE_VERSION,
+        importers: {
+            '.': {
+                configDependencies: {},
+            },
+        },
+        packages: {},
+        snapshots: {},
+    };
+}
+export async function readEnvLockfile(rootDir) {
+    const lockfilePath = path.join(rootDir, WANTED_LOCKFILE);
+    const rawContent = await streamReadFirstYamlDocument(lockfilePath);
+    if (rawContent == null) {
+        return null;
+    }
+    const parsed = yaml.load(rawContent);
+    if (parsed == null || typeof parsed !== 'object') {
+        return null;
+    }
+    const lockfile = parsed;
+    if (typeof lockfile.lockfileVersion !== 'string') {
+        return null;
+    }
+    if (lockfile.importers == null || typeof lockfile.importers !== 'object') {
+        return null;
+    }
+    if (lockfile.packages == null || typeof lockfile.packages !== 'object') {
+        return null;
+    }
+    if (lockfile.snapshots == null || typeof lockfile.snapshots !== 'object') {
+        return null;
+    }
+    const envLockfile = parsed;
+    if (!envLockfile.importers['.']) {
+        envLockfile.importers['.'] = { configDependencies: {} };
+    }
+    else if (!envLockfile.importers['.'].configDependencies) {
+        envLockfile.importers['.'].configDependencies = {};
+    }
+    return envLockfile;
+}
+export async function writeEnvLockfile(rootDir, lockfile) {
+    const lockfilePath = path.join(rootDir, WANTED_LOCKFILE);
+    const sorted = sortLockfileKeys(lockfile);
+    const envYaml = lockfileYamlDump(sorted);
+    const existing = await readLockfileToStringNoFollow(lockfilePath);
+    const mainDoc = existing == null ? '' : extractMainDocument(existing);
+    const combined = `---\n${envYaml}\n---\n${mainDoc}`;
+    return writeFileAtomic(lockfilePath, combined);
+}
+//# sourceMappingURL=envLockfile.js.map

package/lib/errors/LockfileBreakingChangeError.d.ts

@@ -0,0 +1,5 @@
+import { PnpmError } from '@pnpm/error';
+export declare class LockfileBreakingChangeError extends PnpmError {
+    filename: string;
+    constructor(filename: string);
+}

package/lib/errors/LockfileBreakingChangeError.js

@@ -0,0 +1,9 @@
+import { PnpmError } from '@pnpm/error';
+export class LockfileBreakingChangeError extends PnpmError {
+    filename;
+    constructor(filename) {
+        super('LOCKFILE_BREAKING_CHANGE', `Lockfile ${filename} not compatible with current pnpm`);
+        this.filename = filename;
+    }
+}
+//# sourceMappingURL=LockfileBreakingChangeError.js.map

package/lib/errors/index.d.ts

@@ -0,0 +1 @@
+export { LockfileBreakingChangeError } from './LockfileBreakingChangeError.js';

package/lib/errors/index.js

@@ -0,0 +1,2 @@
+export { LockfileBreakingChangeError } from './LockfileBreakingChangeError.js';
+//# sourceMappingURL=index.js.map

package/lib/existsWantedLockfile.d.ts

@@ -0,0 +1,6 @@
+interface ExistsNonEmptyWantedLockfileOptions {
+    useGitBranchLockfile?: boolean;
+    mergeGitBranchLockfiles?: boolean;
+}
+export declare function existsNonEmptyWantedLockfile(pkgPath: string, opts?: ExistsNonEmptyWantedLockfileOptions): Promise<boolean>;
+export {};

package/lib/existsWantedLockfile.js

@@ -0,0 +1,23 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getWantedLockfileName } from './lockfileName.js';
+export async function existsNonEmptyWantedLockfile(pkgPath, opts = {
+    useGitBranchLockfile: false,
+    mergeGitBranchLockfiles: false,
+}) {
+    const wantedLockfile = await getWantedLockfileName(opts);
+    return new Promise((resolve, reject) => {
+        fs.access(path.join(pkgPath, wantedLockfile), (err) => {
+            if (err == null) {
+                resolve(true);
+                return;
+            }
+            if (err.code === 'ENOENT') {
+                resolve(false);
+                return;
+            }
+            reject(err);
+        });
+    });
+}
+//# sourceMappingURL=existsWantedLockfile.js.map

package/lib/getLockfileImporterId.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectId } from '@pnpm/types';
+export declare function getLockfileImporterId(lockfileDir: string, prefix: string): ProjectId;

package/lib/getLockfileImporterId.js

@@ -0,0 +1,6 @@
+import path from 'node:path';
+import normalize from 'normalize-path';
+export function getLockfileImporterId(lockfileDir, prefix) {
+    return (normalize(path.relative(lockfileDir, prefix)) || '.');
+}
+//# sourceMappingURL=getLockfileImporterId.js.map

package/lib/gitBranchLockfile.d.ts

@@ -0,0 +1,3 @@
+export declare function getGitBranchLockfileNames(lockfileDir: string): Promise<string[]>;
+export declare function getGitBranchLockfileNamesSync(lockfileDir: string): string[];
+export declare function cleanGitBranchLockfiles(lockfileDir: string): Promise<void>;

package/lib/gitBranchLockfile.js

@@ -0,0 +1,22 @@
+import fs, { promises as fsp } from 'node:fs';
+import path from 'node:path';
+// Branch lockfiles are written as `pnpm-lock.<branch>.yaml` with literal
+// dots and a non-empty branch segment. Escaping the dots keeps unrelated
+// files out of the matches that feed scanning and `cleanGitBranchLockfiles`.
+const GIT_BRANCH_LOCKFILE_NAME = /^pnpm-lock\..+\.yaml$/;
+export async function getGitBranchLockfileNames(lockfileDir) {
+    const files = await fsp.readdir(lockfileDir);
+    return files.filter(file => GIT_BRANCH_LOCKFILE_NAME.test(file));
+}
+export function getGitBranchLockfileNamesSync(lockfileDir) {
+    const files = fs.readdirSync(lockfileDir);
+    return files.filter(file => GIT_BRANCH_LOCKFILE_NAME.test(file));
+}
+export async function cleanGitBranchLockfiles(lockfileDir) {
+    const gitBranchLockfiles = await getGitBranchLockfileNames(lockfileDir);
+    await Promise.all(gitBranchLockfiles.map(async (file) => {
+        const filepath = path.join(lockfileDir, file);
+        await fsp.unlink(filepath);
+    }));
+}
+//# sourceMappingURL=gitBranchLockfile.js.map

package/lib/gitMergeFile.d.ts

@@ -0,0 +1,3 @@
+import type { LockfileObject } from '@pnpm/lockfile.types';
+export declare function autofixMergeConflicts(fileContent: string): LockfileObject;
+export declare function isDiff(fileContent: string): boolean;

package/lib/gitMergeFile.js

@@ -0,0 +1,47 @@
+import { mergeLockfileChanges } from '@pnpm/lockfile.merger';
+import yaml from 'js-yaml';
+import { convertToLockfileObject } from './lockfileFormatConverters.js';
+const MERGE_CONFLICT_PARENT = '|||||||';
+const MERGE_CONFLICT_END = '>>>>>>>';
+const MERGE_CONFLICT_THEIRS = '=======';
+const MERGE_CONFLICT_OURS = '<<<<<<<';
+export function autofixMergeConflicts(fileContent) {
+    const { ours, theirs } = parseMergeFile(fileContent);
+    return mergeLockfileChanges(convertToLockfileObject(yaml.load(ours)), convertToLockfileObject(yaml.load(theirs)));
+}
+function parseMergeFile(fileContent) {
+    const lines = fileContent.split(/[\n\r]+/);
+    let state = 'top';
+    const ours = [];
+    const theirs = [];
+    while (lines.length > 0) {
+        const line = lines.shift();
+        if (line.startsWith(MERGE_CONFLICT_PARENT)) {
+            state = 'parent';
+            continue;
+        }
+        if (line.startsWith(MERGE_CONFLICT_OURS)) {
+            state = 'ours';
+            continue;
+        }
+        if (line === MERGE_CONFLICT_THEIRS) {
+            state = 'theirs';
+            continue;
+        }
+        if (line.startsWith(MERGE_CONFLICT_END)) {
+            state = 'top';
+            continue;
+        }
+        if (state === 'top' || state === 'ours')
+            ours.push(line);
+        if (state === 'top' || state === 'theirs')
+            theirs.push(line);
+    }
+    return { ours: ours.join('\n'), theirs: theirs.join('\n') };
+}
+export function isDiff(fileContent) {
+    return fileContent.includes(MERGE_CONFLICT_OURS) &&
+        fileContent.includes(MERGE_CONFLICT_THEIRS) &&
+        fileContent.includes(MERGE_CONFLICT_END);
+}
+//# sourceMappingURL=gitMergeFile.js.map

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+export { createEnvLockfile, readEnvLockfile, writeEnvLockfile } from './envLockfile.js';
+export { existsNonEmptyWantedLockfile } from './existsWantedLockfile.js';
+export { getLockfileImporterId } from './getLockfileImporterId.js';
+export { cleanGitBranchLockfiles, getGitBranchLockfileNamesSync } from './gitBranchLockfile.js';
+export { convertToLockfileFile, convertToLockfileObject } from './lockfileFormatConverters.js';
+export { getWantedLockfileName } from './lockfileName.js';
+export * from './read.js';
+export { isEmptyLockfile, writeCurrentLockfile, writeLockfileFile, writeLockfiles, type WriteLockfilesResult, writeWantedLockfile, } from './write.js';
+export { extractMainDocument } from './yamlDocuments.js';
+export * from '@pnpm/lockfile.types';

package/lib/lockfileFormatConverters.d.ts

@@ -0,0 +1,3 @@
+import type { LockfileFile, LockfileObject } from '@pnpm/lockfile.types';
+export declare function convertToLockfileFile(lockfile: LockfileObject): LockfileFile;
+export declare function convertToLockfileObject(lockfile: LockfileFile): LockfileObject;

package/lib/lockfileFormatConverters.js

@@ -0,0 +1,227 @@
+import { LOCKFILE_VERSION } from '@pnpm/constants';
+import { parse, refToRelative, removeSuffix } from '@pnpm/deps.path';
+import { isGitHostedTarballUrl } from '@pnpm/lockfile.utils';
+import { DEPENDENCIES_FIELDS } from '@pnpm/types';
+import { isEmpty, map as _mapValues, omit, pick, pickBy } from 'ramda';
+export function convertToLockfileFile(lockfile) {
+    const packages = {};
+    const snapshots = {};
+    for (const [depPath, pkg] of Object.entries(lockfile.packages ?? {})) {
+        snapshots[depPath] = pick([
+            'dependencies',
+            'optionalDependencies',
+            'transitivePeerDependencies',
+            'optional',
+            'id',
+        ], pkg);
+        const pkgId = removeSuffix(depPath);
+        if (!packages[pkgId]) {
+            packages[pkgId] = pick([
+                'bundledDependencies',
+                'cpu',
+                'deprecated',
+                'engines',
+                'hasBin',
+                'libc',
+                'name',
+                'os',
+                'peerDependencies',
+                'peerDependenciesMeta',
+                'resolution',
+                'version',
+            ], pkg);
+        }
+    }
+    const newLockfile = {
+        ...lockfile,
+        snapshots,
+        packages,
+        lockfileVersion: LOCKFILE_VERSION,
+        importers: mapValues(lockfile.importers, convertProjectSnapshotToInlineSpecifiersFormat),
+    };
+    if (newLockfile.settings?.peersSuffixMaxLength === 1000) {
+        newLockfile.settings = omit(['peersSuffixMaxLength'], newLockfile.settings);
+    }
+    if (newLockfile.settings?.injectWorkspacePackages === false) {
+        delete newLockfile.settings.injectWorkspacePackages;
+    }
+    return normalizeLockfile(newLockfile);
+}
+function normalizeLockfile(lockfile) {
+    const lockfileToSave = {
+        ...lockfile,
+        importers: _mapValues((importer) => {
+            const normalizedImporter = {};
+            if (importer.dependenciesMeta != null && !isEmpty(importer.dependenciesMeta)) {
+                normalizedImporter.dependenciesMeta = importer.dependenciesMeta;
+            }
+            for (const depType of DEPENDENCIES_FIELDS) {
+                if (!isEmpty(importer[depType] ?? {})) {
+                    normalizedImporter[depType] = importer[depType];
+                }
+            }
+            if (importer.publishDirectory) {
+                normalizedImporter.publishDirectory = importer.publishDirectory;
+            }
+            return normalizedImporter;
+        }, lockfile.importers ?? {}),
+    };
+    if (isEmpty(lockfileToSave.packages) || (lockfileToSave.packages == null)) {
+        delete lockfileToSave.packages;
+    }
+    if (isEmpty(lockfileToSave.snapshots) || (lockfileToSave.snapshots == null)) {
+        delete lockfileToSave.snapshots;
+    }
+    if (lockfileToSave.time) {
+        lockfileToSave.time = pruneTimeInLockfile(lockfileToSave.time, lockfile.importers ?? {});
+    }
+    if ((lockfileToSave.catalogs != null) && isEmpty(lockfileToSave.catalogs)) {
+        delete lockfileToSave.catalogs;
+    }
+    if ((lockfileToSave.overrides != null) && isEmpty(lockfileToSave.overrides)) {
+        delete lockfileToSave.overrides;
+    }
+    if ((lockfileToSave.patchedDependencies != null) && isEmpty(lockfileToSave.patchedDependencies)) {
+        delete lockfileToSave.patchedDependencies;
+    }
+    if (!lockfileToSave.packageExtensionsChecksum) {
+        delete lockfileToSave.packageExtensionsChecksum;
+    }
+    if (!lockfileToSave.ignoredOptionalDependencies?.length) {
+        delete lockfileToSave.ignoredOptionalDependencies;
+    }
+    if (!lockfileToSave.pnpmfileChecksum) {
+        delete lockfileToSave.pnpmfileChecksum;
+    }
+    return lockfileToSave;
+}
+function pruneTimeInLockfile(time, importers) {
+    const rootDepPaths = new Set();
+    for (const importer of Object.values(importers)) {
+        for (const depType of DEPENDENCIES_FIELDS) {
+            for (const [depName, ref] of Object.entries(importer[depType] ?? {})) {
+                const suffixStart = ref.version.indexOf('(');
+                const refWithoutPeerDepGraphHash = suffixStart === -1 ? ref.version : ref.version.slice(0, suffixStart);
+                const depPath = refToRelative(refWithoutPeerDepGraphHash, depName);
+                if (!depPath)
+                    continue;
+                rootDepPaths.add(depPath);
+            }
+        }
+    }
+    return pickBy((_, depPath) => rootDepPaths.has(depPath), time);
+}
+// Mirrors `isFilename` in `resolving/local-resolver/src/parseBareSpecifier.ts`
+// so the directory-vs-tarball boundary applied at lockfile load time
+// matches the resolver's at resolve time.
+const LOCAL_TARBALL_RE = /\.(?:tgz|tar\.gz|tar)$/i;
+export function convertToLockfileObject(lockfile) {
+    const { importers, ...rest } = lockfile;
+    const packages = {};
+    for (const [depPath, pkg] of Object.entries(lockfile.snapshots ?? {})) {
+        const pkgId = removeSuffix(depPath);
+        const snapshot = Object.assign(pkg, lockfile.packages?.[pkgId]);
+        // Defense-in-depth for pruned lockfiles (older `turbo prune --docker`,
+        // pre vercel/turborepo#12825): a peer-variant injected workspace
+        // snapshot whose base `packages:` entry was dropped now has a null
+        // `resolution`. Reconstruct it from the `file:` depPath — same value
+        // pnpm's writer emits — so every downstream reader sees a complete
+        // snapshot without per-reader guards.
+        if (snapshot.resolution == null) {
+            const ref = parse(depPath).nonSemverVersion;
+            if (ref != null && ref.startsWith('file:') && !LOCAL_TARBALL_RE.test(ref)) {
+                snapshot.resolution = { directory: ref.slice('file:'.length), type: 'directory' };
+            }
+        }
+        packages[depPath] = snapshot;
+        enrichGitHostedFlag(packages[depPath]?.resolution);
+    }
+    return {
+        ...omit(['snapshots'], rest),
+        patchedDependencies: migratePatchedDependencies(rest.patchedDependencies),
+        packages,
+        importers: mapValues(importers ?? {}, revertProjectSnapshot),
+    };
+}
+// Backfill the `gitHosted` flag for tarball resolutions written by older
+// pnpm versions. Doing it once at load time lets every downstream reader
+// rely on the typed field instead of repeating URL prefix matches.
+function enrichGitHostedFlag(resolution) {
+    if (resolution == null)
+        return;
+    if (resolution.type !== undefined)
+        return;
+    if (resolution.gitHosted != null)
+        return;
+    if (resolution.tarball != null && isGitHostedTarballUrl(resolution.tarball)) {
+        resolution.gitHosted = true;
+    }
+}
+function migratePatchedDependencies(patchedDependencies) {
+    if (!patchedDependencies)
+        return undefined;
+    const result = {};
+    for (const [key, value] of Object.entries(patchedDependencies)) {
+        result[key] = typeof value === 'string' ? value : value.hash;
+    }
+    return result;
+}
+function convertProjectSnapshotToInlineSpecifiersFormat(projectSnapshot) {
+    const { specifiers, ...rest } = projectSnapshot;
+    if (specifiers == null)
+        return projectSnapshot;
+    const convertBlock = (block) => block != null
+        ? convertResolvedDependenciesToInlineSpecifiersFormat(block, { specifiers })
+        : block;
+    return {
+        ...rest,
+        dependencies: convertBlock(projectSnapshot.dependencies ?? {}),
+        optionalDependencies: convertBlock(projectSnapshot.optionalDependencies ?? {}),
+        devDependencies: convertBlock(projectSnapshot.devDependencies ?? {}),
+    };
+}
+function convertResolvedDependenciesToInlineSpecifiersFormat(resolvedDependencies, { specifiers }) {
+    return mapValues(resolvedDependencies, (version, depName) => ({
+        specifier: specifiers[depName],
+        version,
+    }));
+}
+function revertProjectSnapshot(from) {
+    const specifiers = {};
+    function moveSpecifiers(from) {
+        const resolvedDependencies = {};
+        for (const [depName, { specifier, version }] of Object.entries(from)) {
+            const existingValue = specifiers[depName];
+            if (existingValue != null && existingValue !== specifier) {
+                throw new Error(`Project snapshot lists the same dependency more than once with conflicting versions: ${depName}`);
+            }
+            specifiers[depName] = specifier;
+            resolvedDependencies[depName] = version;
+        }
+        return resolvedDependencies;
+    }
+    const dependencies = from.dependencies == null
+        ? from.dependencies
+        : moveSpecifiers(from.dependencies);
+    const devDependencies = from.devDependencies == null
+        ? from.devDependencies
+        : moveSpecifiers(from.devDependencies);
+    const optionalDependencies = from.optionalDependencies == null
+        ? from.optionalDependencies
+        : moveSpecifiers(from.optionalDependencies);
+    return {
+        ...from,
+        specifiers,
+        dependencies,
+        devDependencies,
+        optionalDependencies,
+    };
+}
+function mapValues(obj, mapper) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        result[key] = mapper(value, key);
+    }
+    return result;
+}
+//# sourceMappingURL=lockfileFormatConverters.js.map

package/lib/lockfileName.d.ts

@@ -0,0 +1,6 @@
+export interface GetWantedLockfileNameOptions {
+    useGitBranchLockfile?: boolean;
+    mergeGitBranchLockfiles?: boolean;
+    cwd?: string;
+}
+export declare function getWantedLockfileName(opts?: GetWantedLockfileNameOptions): Promise<string>;

package/lib/lockfileName.js

@@ -0,0 +1,19 @@
+import { WANTED_LOCKFILE } from '@pnpm/constants';
+import { getCurrentBranch } from '@pnpm/network.git-utils';
+export async function getWantedLockfileName(opts = {}) {
+    if (opts.useGitBranchLockfile && !opts.mergeGitBranchLockfiles) {
+        const currentBranchName = await getCurrentBranch({ cwd: opts.cwd });
+        if (currentBranchName) {
+            return WANTED_LOCKFILE.replace('.yaml', `.${stringifyBranchName(currentBranchName)}.yaml`);
+        }
+    }
+    return WANTED_LOCKFILE;
+}
+/**
+ * 1. Git branch name may contains slashes, which is not allowed in filenames
+ * 2. Filesystem may be case-insensitive, so we need to convert branch name to lowercase
+ */
+function stringifyBranchName(branchName = '') {
+    return branchName.replace(/[^\w.-]/g, '!').toLowerCase();
+}
+//# sourceMappingURL=lockfileName.js.map

package/lib/logger.d.ts

@@ -0,0 +1 @@
+export declare const lockfileLogger: import("@pnpm/logger").Logger<unknown>;

package/lib/logger.js

@@ -0,0 +1,3 @@
+import { logger } from '@pnpm/logger';
+export const lockfileLogger = logger('lockfile');
+//# sourceMappingURL=logger.js.map

package/lib/read.d.ts

@@ -0,0 +1,42 @@
+import type { LockfileFile, LockfileObject } from '@pnpm/lockfile.types';
+import type { ProjectId } from '@pnpm/types';
+export declare function readCurrentLockfile(pnpmInternalDir: string, opts: {
+    wantedVersions?: string[];
+    ignoreIncompatible: boolean;
+}): Promise<LockfileObject | null>;
+export declare function readWantedLockfileAndAutofixConflicts(pkgPath: string, opts: {
+    wantedVersions?: string[];
+    ignoreIncompatible: boolean;
+    useGitBranchLockfile?: boolean;
+    mergeGitBranchLockfiles?: boolean;
+}): Promise<{
+    lockfile: LockfileObject | null;
+    hadConflicts: boolean;
+}>;
+export declare function readWantedLockfile(pkgPath: string, opts: {
+    wantedVersions?: string[];
+    ignoreIncompatible: boolean;
+    useGitBranchLockfile?: boolean;
+    mergeGitBranchLockfiles?: boolean;
+}): Promise<LockfileObject | null>;
+/**
+ * Read the wanted lockfile in its on-disk shape ({@link LockfileFile}),
+ * skipping the conversion to the in-memory {@link LockfileObject}.
+ *
+ * Use this when the caller needs the exact serialized form — e.g. to
+ * forward the lockfile to a server that speaks the on-disk format —
+ * rather than the in-process representation.
+ */
+export declare function readWantedLockfileFile(pkgPath: string, opts: {
+    wantedVersions?: string[];
+    ignoreIncompatible: boolean;
+    useGitBranchLockfile?: boolean;
+    mergeGitBranchLockfiles?: boolean;
+}): Promise<LockfileFile | null>;
+export declare function wantedLockfileHasMergeConflictsSync(pkgPath: string, lockfileName?: string): boolean;
+export declare function createLockfileObject(importerIds: ProjectId[], opts: {
+    lockfileVersion: string;
+    autoInstallPeers: boolean;
+    excludeLinksFromLockfile: boolean;
+    peersSuffixMaxLength: number;
+}): LockfileObject;