@pnpm/lockfile.fs 1100.1.11 → 1100.1.12

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @pnpm/lockfile-file
 
+## 1100.1.12
+
+### Patch Changes
+
+- Fixed `pnpm install` failing with `ERR_PNPM_LOCKFILE_IS_SYMLINK` when `pnpm-lock.yaml` is a symlink, as build sandboxes such as Bazel and Nix stage it [#13073](https://github.com/pnpm/pnpm/issues/13073). Reading a lockfile through a symlink is allowed again, and an install that leaves the lockfile unchanged no longer rewrites it, so `--frozen-lockfile` no longer needs to write at all. Writing a *changed* lockfile through a symlink is still refused, as that would redirect the write onto the symlink's target.
+
+- Prevent broken-lockfile errors from including snippets of the lockfile's contents.
+
 ## 1100.1.11
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/lockfile.fs",
-  "version": "1100.1.11",
+  "version": "1100.1.12",
   "description": "Read/write pnpm-lock.yaml files",
   "keywords": [
     "pnpm",
@@ -52,7 +52,7 @@
   },
   "devDependencies": {
     "@jest/globals": "30.4.1",
-    "@pnpm/lockfile.fs": "1100.1.11",
+    "@pnpm/lockfile.fs": "1100.1.12",
     "@pnpm/logger": "1100.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/normalize-path": "^3.0.2",

package/lib/envLockfile.d.ts

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

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

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

package/lib/errors/LockfileBreakingChangeError.js

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

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

package/lib/errors/index.js

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

package/lib/existsWantedLockfile.d.ts

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

package/lib/existsWantedLockfile.js

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

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

package/lib/getLockfileImporterId.js

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

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

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

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

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

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

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

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

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

package/lib/lockfileName.js

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

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

package/lib/logger.js

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

package/lib/read.d.ts

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

package/lib/read.js

@@ -1,186 +0,0 @@
-import fs, { promises as fsp } from 'node:fs';
-import path from 'node:path';
-import util from 'node:util';
-import { LOCKFILE_VERSION, WANTED_LOCKFILE, } from '@pnpm/constants';
-import { PnpmError } from '@pnpm/error';
-import { mergeLockfileChanges } from '@pnpm/lockfile.merger';
-import { comverToSemver } from 'comver-to-semver';
-import yaml from 'js-yaml';
-import semver from 'semver';
-import stripBom from 'strip-bom';
-import { LockfileBreakingChangeError } from './errors/index.js';
-import { getGitBranchLockfileNames } from './gitBranchLockfile.js';
-import { autofixMergeConflicts, isDiff } from './gitMergeFile.js';
-import { convertToLockfileFile, convertToLockfileObject } from './lockfileFormatConverters.js';
-import { getWantedLockfileName } from './lockfileName.js';
-import { lockfileLogger as logger } from './logger.js';
-import { extractMainDocument } from './yamlDocuments.js';
-export async function readCurrentLockfile(pnpmInternalDir, opts) {
-    const lockfilePath = path.join(pnpmInternalDir, 'lock.yaml');
-    return (await _read(lockfilePath, pnpmInternalDir, opts)).lockfile;
-}
-export async function readWantedLockfileAndAutofixConflicts(pkgPath, opts) {
-    return _readWantedLockfile(pkgPath, {
-        ...opts,
-        autofixMergeConflicts: true,
-    });
-}
-export async function readWantedLockfile(pkgPath, opts) {
-    return (await _readWantedLockfile(pkgPath, opts)).lockfile;
-}
-/**
- * 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 async function readWantedLockfileFile(pkgPath, opts) {
-    return (await _readWantedLockfile(pkgPath, opts)).lockfileFile;
-}
-export function wantedLockfileHasMergeConflictsSync(pkgPath, lockfileName = WANTED_LOCKFILE) {
-    try {
-        const lockfileRawContent = stripBom(fs.readFileSync(path.join(pkgPath, lockfileName), 'utf8'));
-        return isDiff(extractMainDocument(lockfileRawContent));
-    }
-    catch (err) {
-        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
-            return false;
-        }
-        throw err;
-    }
-}
-async function _read(lockfilePath, prefix, // only for logging
-opts) {
-    let lockfileRawContent;
-    try {
-        lockfileRawContent = stripBom(await fsp.readFile(lockfilePath, 'utf8'));
-    }
-    catch (err) {
-        if (!(util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT')) {
-            throw err;
-        }
-        return {
-            lockfile: null,
-            lockfileFile: null,
-            hadConflicts: false,
-        };
-    }
-    // Skip the env lockfile document if present (first document in combined format)
-    lockfileRawContent = extractMainDocument(lockfileRawContent);
-    if (!lockfileRawContent.trim()) {
-        return {
-            lockfile: null,
-            lockfileFile: null,
-            hadConflicts: false,
-        };
-    }
-    let lockfile;
-    let lockfileFile;
-    let hadConflicts;
-    try {
-        lockfileFile = yaml.load(lockfileRawContent);
-        lockfile = convertToLockfileObject(lockfileFile);
-        hadConflicts = false;
-    }
-    catch (err) {
-        if (!opts.autofixMergeConflicts || !isDiff(lockfileRawContent)) {
-            throw new PnpmError('BROKEN_LOCKFILE', `The lockfile at "${lockfilePath}" is broken: ${err.message}`);
-        }
-        hadConflicts = true;
-        lockfile = autofixMergeConflicts(lockfileRawContent);
-        lockfileFile = convertToLockfileFile(lockfile);
-        logger.info({
-            message: `Merge conflict detected in ${WANTED_LOCKFILE} and successfully merged`,
-            prefix,
-        });
-    }
-    if (lockfile) {
-        const lockfileSemver = comverToSemver((lockfile.lockfileVersion ?? 0).toString());
-        if (!opts.wantedVersions ||
-            opts.wantedVersions.length === 0 ||
-            opts.wantedVersions.some((wantedVersion) => {
-                if (semver.major(lockfileSemver) !== semver.major(comverToSemver(wantedVersion)))
-                    return false;
-                if (lockfile.lockfileVersion !== '6.1' && semver.gt(lockfileSemver, comverToSemver(wantedVersion))) {
-                    logger.warn({
-                        message: `Your ${WANTED_LOCKFILE} was generated by a newer version of pnpm. ` +
-                            `It is a compatible version but it might get downgraded to version ${wantedVersion}`,
-                        prefix,
-                    });
-                }
-                return true;
-            })) {
-            return { lockfile, lockfileFile, hadConflicts };
-        }
-    }
-    if (opts.ignoreIncompatible) {
-        logger.warn({
-            message: `Ignoring not compatible lockfile at ${lockfilePath}`,
-            prefix,
-        });
-        return { lockfile: null, lockfileFile: null, hadConflicts: false };
-    }
-    throw new LockfileBreakingChangeError(lockfilePath);
-}
-export function createLockfileObject(importerIds, opts) {
-    const importers = {};
-    for (const importerId of importerIds) {
-        importers[importerId] = {
-            dependencies: {},
-            specifiers: {},
-        };
-    }
-    return {
-        importers,
-        lockfileVersion: opts.lockfileVersion || LOCKFILE_VERSION,
-        settings: {
-            autoInstallPeers: opts.autoInstallPeers,
-            excludeLinksFromLockfile: opts.excludeLinksFromLockfile,
-            peersSuffixMaxLength: opts.peersSuffixMaxLength,
-        },
-    };
-}
-async function _readWantedLockfile(pkgPath, opts) {
-    const lockfileNames = [WANTED_LOCKFILE];
-    if (opts.useGitBranchLockfile) {
-        const gitBranchLockfileName = await getWantedLockfileName(opts);
-        if (gitBranchLockfileName !== WANTED_LOCKFILE) {
-            lockfileNames.unshift(gitBranchLockfileName);
-        }
-    }
-    let result = { lockfile: null, lockfileFile: null, hadConflicts: false };
-    /* eslint-disable no-await-in-loop */
-    for (const lockfileName of lockfileNames) {
-        result = await _read(path.join(pkgPath, lockfileName), pkgPath, { ...opts, autofixMergeConflicts: true });
-        if (result.lockfile) {
-            if (opts.mergeGitBranchLockfiles) {
-                result.lockfile = await _mergeGitBranchLockfiles(result.lockfile, pkgPath, pkgPath, opts);
-                result.lockfileFile = result.lockfile ? convertToLockfileFile(result.lockfile) : null;
-            }
-            break;
-        }
-    }
-    /* eslint-enable no-await-in-loop */
-    return result;
-}
-async function _mergeGitBranchLockfiles(lockfile, lockfileDir, prefix, opts) {
-    if (!lockfile) {
-        return lockfile;
-    }
-    const gitBranchLockfiles = (await _readGitBranchLockfiles(lockfileDir, prefix, opts)).map(({ lockfile }) => lockfile);
-    let mergedLockfile = lockfile;
-    for (const gitBranchLockfile of gitBranchLockfiles) {
-        if (!gitBranchLockfile) {
-            continue;
-        }
-        mergedLockfile = mergeLockfileChanges(mergedLockfile, gitBranchLockfile);
-    }
-    return mergedLockfile;
-}
-async function _readGitBranchLockfiles(lockfileDir, prefix, opts) {
-    const files = await getGitBranchLockfileNames(lockfileDir);
-    return Promise.all(files.map((file) => _read(path.join(lockfileDir, file), prefix, opts)));
-}
-//# sourceMappingURL=read.js.map

package/lib/sortLockfileKeys.d.ts

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

package/lib/sortLockfileKeys.js

@@ -1,78 +0,0 @@
-import { sortDeepKeys, sortDirectKeys, sortKeysByPriority } from '@pnpm/object.key-sorting';
-const ORDERED_KEYS = {
-    resolution: 1,
-    id: 2,
-    name: 3,
-    version: 4,
-    engines: 5,
-    cpu: 6,
-    os: 7,
-    libc: 8,
-    deprecated: 9,
-    hasBin: 10,
-    prepare: 11,
-    requiresBuild: 12,
-    bundleDependencies: 13,
-    peerDependencies: 14,
-    peerDependenciesMeta: 15,
-    dependencies: 16,
-    optionalDependencies: 17,
-    transitivePeerDependencies: 18,
-    dev: 19,
-    optional: 20,
-};
-const ROOT_KEYS = [
-    'lockfileVersion',
-    'settings',
-    'catalogs',
-    'overrides',
-    'packageExtensionsChecksum',
-    'pnpmfileChecksum',
-    'patchedDependencies',
-    'importers',
-    'packages',
-];
-const ROOT_KEYS_ORDER = Object.fromEntries(ROOT_KEYS.map((key, index) => [key, index]));
-export function sortLockfileKeys(lockfile) {
-    if (lockfile.importers != null) {
-        lockfile.importers = sortDirectKeys(lockfile.importers);
-        for (const [importerId, importer] of Object.entries(lockfile.importers)) {
-            lockfile.importers[importerId] = sortKeysByPriority({
-                priority: ROOT_KEYS_ORDER,
-                deep: true,
-            }, importer);
-        }
-    }
-    if (lockfile.packages != null) {
-        lockfile.packages = sortDirectKeys(lockfile.packages);
-        for (const [pkgId, pkg] of Object.entries(lockfile.packages)) {
-            lockfile.packages[pkgId] = sortKeysByPriority({
-                priority: ORDERED_KEYS,
-                deep: true,
-            }, pkg);
-        }
-    }
-    if (lockfile.snapshots != null) {
-        lockfile.snapshots = sortDirectKeys(lockfile.snapshots);
-        for (const [pkgId, pkg] of Object.entries(lockfile.snapshots)) {
-            lockfile.snapshots[pkgId] = sortKeysByPriority({
-                priority: ORDERED_KEYS,
-                deep: true,
-            }, pkg);
-        }
-    }
-    if ('catalogs' in lockfile && lockfile.catalogs != null) {
-        lockfile.catalogs = sortDirectKeys(lockfile.catalogs);
-        for (const [catalogName, catalog] of Object.entries(lockfile.catalogs)) {
-            lockfile.catalogs[catalogName] = sortDeepKeys(catalog);
-        }
-    }
-    if ('time' in lockfile && lockfile.time != null) {
-        lockfile.time = sortDirectKeys(lockfile.time);
-    }
-    if ('patchedDependencies' in lockfile && lockfile.patchedDependencies != null) {
-        lockfile.patchedDependencies = sortDirectKeys(lockfile.patchedDependencies);
-    }
-    return sortKeysByPriority({ priority: ROOT_KEYS_ORDER }, lockfile);
-}
-//# sourceMappingURL=sortLockfileKeys.js.map

package/lib/write.d.ts

@@ -1,39 +0,0 @@
-import type { LockfileFile, LockfileObject } from '@pnpm/lockfile.types';
-export declare function lockfileYamlDump(obj: object): string;
-/**
- * Returns the canonical post-write lockfile — structurally identical
- * to what `readWantedLockfile` would parse back. Lets callers like
- * the verification cache hash the as-saved form without re-reading.
- */
-export declare function writeWantedLockfile(pkgPath: string, wantedLockfile: LockfileObject, opts?: {
-    useGitBranchLockfile?: boolean;
-    mergeGitBranchLockfiles?: boolean;
-    /** Pre-resolved filename; skips the `getWantedLockfileName` (and
-     *  its `getCurrentBranch`) call when supplied. */
-    lockfileName?: string;
-}): Promise<LockfileObject>;
-export declare function writeCurrentLockfile(virtualStoreDir: string, currentLockfile: LockfileObject): Promise<LockfileObject | undefined>;
-export declare function writeLockfileFile(lockfilePath: string, wantedLockfile: LockfileFile): Promise<void>;
-export declare function isEmptyLockfile(lockfile: LockfileObject): boolean;
-export interface WriteLockfilesResult {
-    /**
-     * The canonical "as-saved" wanted lockfile — the inverse converter
-     * applied to the same object that was serialized to YAML. Hashing
-     * this is equivalent to hashing the lockfile the next install will
-     * load from disk (modulo undefined values that YAML drops, which any
-     * sensible canonicalization-then-hash routine should strip).
-     */
-    wantedLockfile: LockfileObject;
-    /** Same as above for the current lockfile, or undefined when it was skipped because empty. */
-    currentLockfile: LockfileObject | undefined;
-}
-export declare function writeLockfiles(opts: {
-    wantedLockfile: LockfileObject;
-    wantedLockfileDir: string;
-    currentLockfile: LockfileObject;
-    currentLockfileDir: string;
-    useGitBranchLockfile?: boolean;
-    mergeGitBranchLockfiles?: boolean;
-    /** See {@link writeWantedLockfile}'s `lockfileName` option. */
-    wantedLockfileName?: string;
-}): Promise<WriteLockfilesResult>;

package/lib/write.js

@@ -1,155 +0,0 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { WANTED_LOCKFILE } from '@pnpm/constants';
-import { rimraf } from '@zkochan/rimraf';
-import yaml from 'js-yaml';
-import { isEmpty } from 'ramda';
-import writeFileAtomic from 'write-file-atomic';
-import { convertToLockfileFile, convertToLockfileObject } from './lockfileFormatConverters.js';
-import { getWantedLockfileName } from './lockfileName.js';
-import { lockfileLogger as logger } from './logger.js';
-import { sortLockfileKeys } from './sortLockfileKeys.js';
-import { streamReadFirstYamlDocument, YAML_DOCUMENT_SEPARATOR, YAML_DOCUMENT_START } from './yamlDocuments.js';
-const LOCKFILE_YAML_FORMAT = {
-    blankLines: true,
-    lineWidth: -1,
-    noCompatMode: true,
-    noRefs: true,
-    sortKeys: false,
-};
-export function lockfileYamlDump(obj) {
-    return yaml.dump(obj, LOCKFILE_YAML_FORMAT);
-}
-/**
- * Returns the canonical post-write lockfile — structurally identical
- * to what `readWantedLockfile` would parse back. Lets callers like
- * the verification cache hash the as-saved form without re-reading.
- */
-export async function writeWantedLockfile(pkgPath, wantedLockfile, opts) {
-    const wantedLockfileName = opts?.lockfileName ?? await getWantedLockfileName(opts);
-    return writeLockfile(wantedLockfileName, pkgPath, wantedLockfile);
-}
-export async function writeCurrentLockfile(virtualStoreDir, currentLockfile) {
-    // empty lockfile is not saved
-    if (isEmptyLockfile(currentLockfile)) {
-        await rimraf(path.join(virtualStoreDir, 'lock.yaml'));
-        return undefined;
-    }
-    await fs.mkdir(virtualStoreDir, { recursive: true });
-    return writeLockfile('lock.yaml', virtualStoreDir, currentLockfile);
-}
-async function writeLockfile(lockfileFilename, pkgPath, wantedLockfile) {
-    const lockfilePath = path.join(pkgPath, lockfileFilename);
-    const lockfileToStringify = convertToLockfileFile(wantedLockfile);
-    const yamlDoc = yamlStringify(lockfileToStringify);
-    if (lockfileFilename === WANTED_LOCKFILE) {
-        // Re-read the env document from the existing lockfile to preserve it.
-        // Ideally the env document would be captured during the initial lockfile read
-        // and passed through to the write functions, but that would require threading it
-        // through 25+ call sites. Re-reading is cheap since the file is likely still
-        // in the OS page cache and streaming stops at the first separator.
-        const envDoc = await streamReadFirstYamlDocument(lockfilePath);
-        const envPrefix = envDoc != null ? `${YAML_DOCUMENT_START}${envDoc}${YAML_DOCUMENT_SEPARATOR}` : '';
-        await writeFileAtomic(lockfilePath, `${envPrefix}${yamlDoc}`);
-    }
-    else {
-        await writeFileAtomic(lockfilePath, yamlDoc);
-    }
-    // YAML drops undefined on serialize, so the in-memory LockfileFile
-    // can carry fields (like an unset settings.dedupePeers) that won't
-    // survive a round-trip; strip them to mirror what the next reader
-    // will parse back.
-    return convertToLockfileObject(stripUndefinedDeep(lockfileToStringify));
-}
-function stripUndefinedDeep(value) {
-    if (value === null || typeof value !== 'object')
-        return value;
-    if (Array.isArray(value))
-        return value.map(stripUndefinedDeep);
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-        if (v === undefined)
-            continue;
-        out[k] = stripUndefinedDeep(v);
-    }
-    return out;
-}
-export function writeLockfileFile(lockfilePath, wantedLockfile) {
-    const yamlDoc = yamlStringify(wantedLockfile);
-    return writeFileAtomic(lockfilePath, yamlDoc);
-}
-function yamlStringify(lockfile) {
-    const sortedLockfile = sortLockfileKeys(lockfile);
-    return lockfileYamlDump(sortedLockfile);
-}
-export function isEmptyLockfile(lockfile) {
-    return Object.values(lockfile.importers).every((importer) => isEmpty(importer.specifiers ?? {}) && isEmpty(importer.dependencies ?? {}));
-}
-export async function writeLockfiles(opts) {
-    const wantedLockfileName = opts.wantedLockfileName ?? await getWantedLockfileName(opts);
-    const wantedLockfilePath = path.join(opts.wantedLockfileDir, wantedLockfileName);
-    const currentLockfilePath = path.join(opts.currentLockfileDir, 'lock.yaml');
-    const wantedLockfileToStringify = convertToLockfileFile(opts.wantedLockfile);
-    const yamlDoc = yamlStringify(wantedLockfileToStringify);
-    // Preserve the env lockfile document at the top of pnpm-lock.yaml
-    let envPrefix = '';
-    if (wantedLockfileName === WANTED_LOCKFILE) {
-        const envDoc = await streamReadFirstYamlDocument(wantedLockfilePath);
-        if (envDoc != null) {
-            envPrefix = `${YAML_DOCUMENT_START}${envDoc}${YAML_DOCUMENT_SEPARATOR}`;
-        }
-    }
-    const wantedYamlDoc = `${envPrefix}${yamlDoc}`;
-    // in most cases the `pnpm-lock.yaml` and `node_modules/.pnpm-lock.yaml` are equal
-    // in those cases the YAML document can be stringified only once for both files
-    // which is more efficient
-    if (opts.wantedLockfile === opts.currentLockfile) {
-        await Promise.all([
-            writeFileAtomic(wantedLockfilePath, wantedYamlDoc),
-            (async () => {
-                if (isEmptyLockfile(opts.wantedLockfile)) {
-                    await rimraf(currentLockfilePath);
-                }
-                else {
-                    await fs.mkdir(path.dirname(currentLockfilePath), { recursive: true });
-                    // Current lockfile (node_modules/.pnpm/lock.yaml) does not include the env document
-                    await writeFileAtomic(currentLockfilePath, yamlDoc);
-                }
-            })(),
-        ]);
-        // Both files share the same source object; strip once and reuse.
-        const normalized = convertToLockfileObject(stripUndefinedDeep(wantedLockfileToStringify));
-        return {
-            wantedLockfile: normalized,
-            currentLockfile: isEmptyLockfile(opts.wantedLockfile) ? undefined : normalized,
-        };
-    }
-    logger.debug({
-        message: `\`${WANTED_LOCKFILE}\` differs from \`${path.relative(opts.wantedLockfileDir, currentLockfilePath)}\``,
-        prefix: opts.wantedLockfileDir,
-    });
-    const currentLockfileToStringify = convertToLockfileFile(opts.currentLockfile);
-    const currentYamlDoc = yamlStringify(currentLockfileToStringify);
-    // Filtered-current callers (deps-restorer) can pass an empty
-    // current against a non-empty wanted; key off the current.
-    const currentIsEmpty = isEmptyLockfile(opts.currentLockfile);
-    await Promise.all([
-        writeFileAtomic(wantedLockfilePath, wantedYamlDoc),
-        (async () => {
-            if (currentIsEmpty) {
-                await rimraf(currentLockfilePath);
-            }
-            else {
-                await fs.mkdir(path.dirname(currentLockfilePath), { recursive: true });
-                await writeFileAtomic(currentLockfilePath, currentYamlDoc);
-            }
-        })(),
-    ]);
-    return {
-        wantedLockfile: convertToLockfileObject(stripUndefinedDeep(wantedLockfileToStringify)),
-        currentLockfile: currentIsEmpty
-            ? undefined
-            : convertToLockfileObject(stripUndefinedDeep(currentLockfileToStringify)),
-    };
-}
-//# sourceMappingURL=write.js.map

package/lib/yamlDocuments.d.ts

@@ -1,17 +0,0 @@
-export declare const YAML_DOCUMENT_SEPARATOR = "\n---\n";
-export declare const YAML_DOCUMENT_START = "---\n";
-/**
- * Reads the first YAML document from a multi-document YAML file using streaming.
- * The file must start with "---\n" to indicate it contains an env lockfile document.
- * Stops reading as soon as the second document separator is found.
- * Returns null if the file doesn't exist or doesn't start with "---\n".
- */
-export declare function streamReadFirstYamlDocument(filePath: string, readBufferSize?: number): Promise<string | null>;
-export declare function readLockfileToStringNoFollow(filePath: string): Promise<string | null>;
-/**
- * Extracts the main lockfile content (second YAML document) from a combined string.
- * If the file starts with "---\n", returns the content after the separator.
- * If there is no separator, returns empty string (file is env-only).
- * Otherwise returns the entire content (no env document present).
- */
-export declare function extractMainDocument(content: string): string;

package/lib/yamlDocuments.js

@@ -1,138 +0,0 @@
-import { constants } from 'node:fs';
-import { lstat, open } from 'node:fs/promises';
-import { StringDecoder } from 'node:string_decoder';
-import util from 'node:util';
-import { PnpmError } from '@pnpm/error';
-import stripBom from 'strip-bom';
-export const YAML_DOCUMENT_SEPARATOR = '\n---\n';
-export const YAML_DOCUMENT_START = '---\n';
-const READ_BUFFER_SIZE = 64 * 1024;
-const LOCKFILE_READ_FLAGS = constants.O_RDONLY | (process.platform === 'win32' ? 0 : constants.O_NOFOLLOW);
-/**
- * Reads the first YAML document from a multi-document YAML file using streaming.
- * The file must start with "---\n" to indicate it contains an env lockfile document.
- * Stops reading as soon as the second document separator is found.
- * Returns null if the file doesn't exist or doesn't start with "---\n".
- */
-export async function streamReadFirstYamlDocument(filePath, readBufferSize = READ_BUFFER_SIZE) {
-    let fileHandle;
-    let buffer = '';
-    let firstChunk = true;
-    try {
-        fileHandle = await openLockfileNoFollow(filePath);
-        const decoder = new StringDecoder('utf8');
-        const readBuffer = Buffer.allocUnsafe(normalizeReadBufferSize(readBufferSize));
-        let position = 0;
-        while (true) {
-            const { bytesRead } = await fileHandle.read(readBuffer, 0, readBuffer.length, position); // eslint-disable-line no-await-in-loop
-            if (bytesRead === 0)
-                break;
-            position += bytesRead;
-            let chunk = decoder.write(readBuffer.subarray(0, bytesRead));
-            if (firstChunk && chunk.length > 0) {
-                // Strip BOM from the first chunk. Safe because the decoder uses utf8,
-                // so the 3-byte BOM is decoded into a single \uFEFF character.
-                chunk = stripBom(chunk);
-                firstChunk = false;
-            }
-            buffer += chunk;
-            // Normalize CRLF (Windows) to LF so document separator detection works.
-            buffer = buffer.replace(/\r\n/g, '\n');
-            if (canRejectDocumentStart(buffer)) {
-                return null;
-            }
-            const sep = buffer.indexOf(YAML_DOCUMENT_SEPARATOR, YAML_DOCUMENT_START.length);
-            if (sep !== -1) {
-                return buffer.slice(YAML_DOCUMENT_START.length, sep);
-            }
-        }
-        const remainder = decoder.end();
-        if (remainder.length > 0) {
-            buffer += firstChunk ? stripBom(remainder) : remainder;
-            buffer = buffer.replace(/\r\n/g, '\n');
-        }
-        return null;
-    }
-    catch (err) {
-        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
-            return null;
-        }
-        throw err;
-    }
-    finally {
-        await fileHandle?.close().catch(() => { });
-    }
-}
-export async function readLockfileToStringNoFollow(filePath) {
-    let fileHandle;
-    try {
-        fileHandle = await openLockfileNoFollow(filePath);
-        return await fileHandle.readFile('utf8');
-    }
-    catch (err) {
-        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
-            return null;
-        }
-        throw err;
-    }
-    finally {
-        await fileHandle?.close().catch(() => { });
-    }
-}
-async function openLockfileNoFollow(filePath) {
-    await ensureLockfileIsNotSymlink(filePath);
-    try {
-        return await open(filePath, LOCKFILE_READ_FLAGS);
-    }
-    catch (err) {
-        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ELOOP') {
-            throw symlinkedLockfileError(filePath);
-        }
-        throw err;
-    }
-}
-async function ensureLockfileIsNotSymlink(filePath) {
-    let stat;
-    try {
-        stat = await lstat(filePath);
-    }
-    catch (err) {
-        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
-            return;
-        }
-        throw err;
-    }
-    if (stat.isSymbolicLink()) {
-        throw symlinkedLockfileError(filePath);
-    }
-}
-function symlinkedLockfileError(filePath) {
-    return new PnpmError('LOCKFILE_IS_SYMLINK', `Refusing to read or write symlinked lockfile at ${filePath}`);
-}
-function canRejectDocumentStart(buffer) {
-    if (buffer.length < YAML_DOCUMENT_START.length)
-        return false;
-    if (buffer === '---\r')
-        return false;
-    return !buffer.startsWith(YAML_DOCUMENT_START);
-}
-function normalizeReadBufferSize(readBufferSize) {
-    const size = Number.isFinite(readBufferSize) ? Math.floor(readBufferSize) : READ_BUFFER_SIZE;
-    return size > 0 ? size : READ_BUFFER_SIZE;
-}
-/**
- * Extracts the main lockfile content (second YAML document) from a combined string.
- * If the file starts with "---\n", returns the content after the separator.
- * If there is no separator, returns empty string (file is env-only).
- * Otherwise returns the entire content (no env document present).
- */
-export function extractMainDocument(content) {
-    content = content.replace(/\r\n/g, '\n');
-    if (!content.startsWith(YAML_DOCUMENT_START))
-        return content;
-    const sep = content.indexOf(YAML_DOCUMENT_SEPARATOR, YAML_DOCUMENT_START.length);
-    if (sep === -1)
-        return '';
-    return content.slice(sep + YAML_DOCUMENT_SEPARATOR.length);
-}
-//# sourceMappingURL=yamlDocuments.js.map