@pnpm/lockfile.fs 1001.1.32 → 1100.0.0

package/lib/read.js

@@ -1,49 +1,41 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readCurrentLockfile = readCurrentLockfile;
-exports.readWantedLockfileAndAutofixConflicts = readWantedLockfileAndAutofixConflicts;
-exports.readWantedLockfile = readWantedLockfile;
-exports.createLockfileObject = createLockfileObject;
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const util_1 = __importDefault(require("util"));
-const constants_1 = require("@pnpm/constants");
-const error_1 = require("@pnpm/error");
-const lockfile_merger_1 = require("@pnpm/lockfile.merger");
-const comver_to_semver_1 = __importDefault(require("comver-to-semver"));
-const js_yaml_1 = __importDefault(require("js-yaml"));
-const semver_1 = __importDefault(require("semver"));
-const strip_bom_1 = __importDefault(require("strip-bom"));
-const index_js_1 = require("./errors/index.js");
-const gitMergeFile_js_1 = require("./gitMergeFile.js");
-const logger_js_1 = require("./logger.js");
-const lockfileName_js_1 = require("./lockfileName.js");
-const gitBranchLockfile_js_1 = require("./gitBranchLockfile.js");
-const lockfileFormatConverters_js_1 = require("./lockfileFormatConverters.js");
-async function readCurrentLockfile(pnpmInternalDir, opts) {
-    const lockfilePath = path_1.default.join(pnpmInternalDir, 'lock.yaml');
+import { promises as fs } 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 { 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;
 }
-async function readWantedLockfileAndAutofixConflicts(pkgPath, opts) {
+export async function readWantedLockfileAndAutofixConflicts(pkgPath, opts) {
     return _readWantedLockfile(pkgPath, {
         ...opts,
         autofixMergeConflicts: true,
     });
 }
-async function readWantedLockfile(pkgPath, opts) {
+export async function readWantedLockfile(pkgPath, opts) {
     return (await _readWantedLockfile(pkgPath, opts)).lockfile;
 }
 async function _read(lockfilePath, prefix, // only for logging
 opts) {
     let lockfileRawContent;
     try {
-        lockfileRawContent = (0, strip_bom_1.default)(await fs_1.promises.readFile(lockfilePath, 'utf8'));
+        lockfileRawContent = stripBom(await fs.readFile(lockfilePath, 'utf8'));
     }
     catch (err) {
-        if (!(util_1.default.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT')) {
+        if (!(util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT')) {
             throw err;
         }
         return {
@@ -51,36 +43,41 @@ opts) {
             hadConflicts: false,
         };
     }
-    // Skip the first YAML document if the file contains two documents (v11 format).
-    // The first document is the env lockfile; the second is the actual lockfile.
+    // Skip the env lockfile document if present (first document in combined format)
     lockfileRawContent = extractMainDocument(lockfileRawContent);
+    if (!lockfileRawContent.trim()) {
+        return {
+            lockfile: null,
+            hadConflicts: false,
+        };
+    }
     let lockfile;
     let hadConflicts;
     try {
-        lockfile = (0, lockfileFormatConverters_js_1.convertToLockfileObject)(js_yaml_1.default.load(lockfileRawContent)); // eslint-disable-line
+        lockfile = convertToLockfileObject(yaml.load(lockfileRawContent)); // eslint-disable-line
         hadConflicts = false;
     }
     catch (err) {
-        if (!opts.autofixMergeConflicts || !(0, gitMergeFile_js_1.isDiff)(lockfileRawContent)) {
-            throw new error_1.PnpmError('BROKEN_LOCKFILE', `The lockfile at "${lockfilePath}" is broken: ${err.message}`);
+        if (!opts.autofixMergeConflicts || !isDiff(lockfileRawContent)) {
+            throw new PnpmError('BROKEN_LOCKFILE', `The lockfile at "${lockfilePath}" is broken: ${err.message}`);
         }
         hadConflicts = true;
-        lockfile = (0, gitMergeFile_js_1.autofixMergeConflicts)(lockfileRawContent);
-        logger_js_1.lockfileLogger.info({
-            message: `Merge conflict detected in ${constants_1.WANTED_LOCKFILE} and successfully merged`,
+        lockfile = autofixMergeConflicts(lockfileRawContent);
+        logger.info({
+            message: `Merge conflict detected in ${WANTED_LOCKFILE} and successfully merged`,
             prefix,
         });
     }
     if (lockfile) {
-        const lockfileSemver = (0, comver_to_semver_1.default)((lockfile.lockfileVersion ?? 0).toString());
+        const lockfileSemver = comverToSemver((lockfile.lockfileVersion ?? 0).toString());
         if (!opts.wantedVersions ||
             opts.wantedVersions.length === 0 ||
             opts.wantedVersions.some((wantedVersion) => {
-                if (semver_1.default.major(lockfileSemver) !== semver_1.default.major((0, comver_to_semver_1.default)(wantedVersion)))
+                if (semver.major(lockfileSemver) !== semver.major(comverToSemver(wantedVersion)))
                     return false;
-                if (lockfile.lockfileVersion !== '6.1' && semver_1.default.gt(lockfileSemver, (0, comver_to_semver_1.default)(wantedVersion))) {
-                    logger_js_1.lockfileLogger.warn({
-                        message: `Your ${constants_1.WANTED_LOCKFILE} was generated by a newer version of pnpm. ` +
+                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,
                     });
@@ -91,15 +88,15 @@ opts) {
         }
     }
     if (opts.ignoreIncompatible) {
-        logger_js_1.lockfileLogger.warn({
+        logger.warn({
             message: `Ignoring not compatible lockfile at ${lockfilePath}`,
             prefix,
         });
         return { lockfile: null, hadConflicts: false };
     }
-    throw new index_js_1.LockfileBreakingChangeError(lockfilePath);
+    throw new LockfileBreakingChangeError(lockfilePath);
 }
-function createLockfileObject(importerIds, opts) {
+export function createLockfileObject(importerIds, opts) {
     const importers = {};
     for (const importerId of importerIds) {
         importers[importerId] = {
@@ -109,7 +106,7 @@ function createLockfileObject(importerIds, opts) {
     }
     return {
         importers,
-        lockfileVersion: opts.lockfileVersion || constants_1.LOCKFILE_VERSION,
+        lockfileVersion: opts.lockfileVersion || LOCKFILE_VERSION,
         settings: {
             autoInstallPeers: opts.autoInstallPeers,
             excludeLinksFromLockfile: opts.excludeLinksFromLockfile,
@@ -118,17 +115,17 @@ function createLockfileObject(importerIds, opts) {
     };
 }
 async function _readWantedLockfile(pkgPath, opts) {
-    const lockfileNames = [constants_1.WANTED_LOCKFILE];
+    const lockfileNames = [WANTED_LOCKFILE];
     if (opts.useGitBranchLockfile) {
-        const gitBranchLockfileName = await (0, lockfileName_js_1.getWantedLockfileName)(opts);
-        if (gitBranchLockfileName !== constants_1.WANTED_LOCKFILE) {
+        const gitBranchLockfileName = await getWantedLockfileName(opts);
+        if (gitBranchLockfileName !== WANTED_LOCKFILE) {
             lockfileNames.unshift(gitBranchLockfileName);
         }
     }
     let result = { lockfile: null, hadConflicts: false };
     /* eslint-disable no-await-in-loop */
     for (const lockfileName of lockfileNames) {
-        result = await _read(path_1.default.join(pkgPath, lockfileName), pkgPath, { ...opts, autofixMergeConflicts: true });
+        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);
@@ -149,20 +146,12 @@ async function _mergeGitBranchLockfiles(lockfile, lockfileDir, prefix, opts) {
         if (!gitBranchLockfile) {
             continue;
         }
-        mergedLockfile = (0, lockfile_merger_1.mergeLockfileChanges)(mergedLockfile, gitBranchLockfile);
+        mergedLockfile = mergeLockfileChanges(mergedLockfile, gitBranchLockfile);
     }
     return mergedLockfile;
 }
 async function _readGitBranchLockfiles(lockfileDir, prefix, opts) {
-    const files = await (0, gitBranchLockfile_js_1.getGitBranchLockfileNames)(lockfileDir);
-    return Promise.all(files.map((file) => _read(path_1.default.join(lockfileDir, file), prefix, opts)));
-}
-function extractMainDocument(content) {
-    if (!content.startsWith('---\n'))
-        return content;
-    const sep = content.indexOf('\n---\n', '---\n'.length);
-    if (sep === -1)
-        return content;
-    return content.slice(sep + '\n---\n'.length);
+    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,2 +1,3 @@
-import { type LockfileFile } from '@pnpm/lockfile.types';
+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,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortLockfileKeys = sortLockfileKeys;
-const object_key_sorting_1 = require("@pnpm/object.key-sorting");
+import { sortDeepKeys, sortDirectKeys, sortKeysByPriority } from '@pnpm/object.key-sorting';
 const ORDERED_KEYS = {
     resolution: 1,
     id: 2,
@@ -36,45 +33,46 @@ const ROOT_KEYS = [
     'packages',
 ];
 const ROOT_KEYS_ORDER = Object.fromEntries(ROOT_KEYS.map((key, index) => [key, index]));
-function sortLockfileKeys(lockfile) {
+export function sortLockfileKeys(lockfile) {
     if (lockfile.importers != null) {
-        lockfile.importers = (0, object_key_sorting_1.sortDirectKeys)(lockfile.importers);
+        lockfile.importers = sortDirectKeys(lockfile.importers);
         for (const [importerId, importer] of Object.entries(lockfile.importers)) {
-            lockfile.importers[importerId] = (0, object_key_sorting_1.sortKeysByPriority)({
+            lockfile.importers[importerId] = sortKeysByPriority({
                 priority: ROOT_KEYS_ORDER,
                 deep: true,
             }, importer);
         }
     }
     if (lockfile.packages != null) {
-        lockfile.packages = (0, object_key_sorting_1.sortDirectKeys)(lockfile.packages);
+        lockfile.packages = sortDirectKeys(lockfile.packages);
         for (const [pkgId, pkg] of Object.entries(lockfile.packages)) {
-            lockfile.packages[pkgId] = (0, object_key_sorting_1.sortKeysByPriority)({
+            lockfile.packages[pkgId] = sortKeysByPriority({
                 priority: ORDERED_KEYS,
                 deep: true,
             }, pkg);
         }
     }
     if (lockfile.snapshots != null) {
-        lockfile.snapshots = (0, object_key_sorting_1.sortDirectKeys)(lockfile.snapshots);
+        lockfile.snapshots = sortDirectKeys(lockfile.snapshots);
         for (const [pkgId, pkg] of Object.entries(lockfile.snapshots)) {
-            lockfile.snapshots[pkgId] = (0, object_key_sorting_1.sortKeysByPriority)({
+            lockfile.snapshots[pkgId] = sortKeysByPriority({
                 priority: ORDERED_KEYS,
                 deep: true,
             }, pkg);
         }
     }
-    if (lockfile.catalogs != null) {
-        lockfile.catalogs = (0, object_key_sorting_1.sortDirectKeys)(lockfile.catalogs);
+    if ('catalogs' in lockfile && lockfile.catalogs != null) {
+        lockfile.catalogs = sortDirectKeys(lockfile.catalogs);
         for (const [catalogName, catalog] of Object.entries(lockfile.catalogs)) {
-            lockfile.catalogs[catalogName] = (0, object_key_sorting_1.sortDeepKeys)(catalog);
+            lockfile.catalogs[catalogName] = sortDeepKeys(catalog);
         }
     }
-    for (const key of ['time', 'patchedDependencies']) {
-        if (!lockfile[key])
-            continue;
-        lockfile[key] = (0, object_key_sorting_1.sortDirectKeys)(lockfile[key]); // eslint-disable-line @typescript-eslint/no-explicit-any
+    if ('time' in lockfile && lockfile.time != null) {
+        lockfile.time = sortDirectKeys(lockfile.time);
     }
-    return (0, object_key_sorting_1.sortKeysByPriority)({ priority: ROOT_KEYS_ORDER }, lockfile);
+    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,4 +1,5 @@
-import { type LockfileObject, type LockfileFile } from '@pnpm/lockfile.types';
+import type { LockfileFile, LockfileObject } from '@pnpm/lockfile.types';
+export declare function lockfileYamlDump(obj: object): string;
 export declare function writeWantedLockfile(pkgPath: string, wantedLockfile: LockfileObject, opts?: {
     useGitBranchLockfile?: boolean;
     mergeGitBranchLockfiles?: boolean;

package/lib/write.js

@@ -1,105 +1,113 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeWantedLockfile = writeWantedLockfile;
-exports.writeCurrentLockfile = writeCurrentLockfile;
-exports.writeLockfileFile = writeLockfileFile;
-exports.isEmptyLockfile = isEmptyLockfile;
-exports.writeLockfiles = writeLockfiles;
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const constants_1 = require("@pnpm/constants");
-const rimraf_1 = __importDefault(require("@zkochan/rimraf"));
-const js_yaml_1 = __importDefault(require("js-yaml"));
-const isEmpty_1 = __importDefault(require("ramda/src/isEmpty"));
-const write_file_atomic_1 = __importDefault(require("write-file-atomic"));
-const logger_js_1 = require("./logger.js");
-const sortLockfileKeys_js_1 = require("./sortLockfileKeys.js");
-const lockfileName_js_1 = require("./lockfileName.js");
-const lockfileFormatConverters_js_1 = require("./lockfileFormatConverters.js");
-async function writeFileAtomic(filename, data) {
-    return new Promise((resolve, reject) => {
-        (0, write_file_atomic_1.default)(filename, data, {}, (err) => {
-            (err != null) ? reject(err) : resolve();
-        });
-    });
-}
+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 } 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, // This is setting line width to never wrap
+    lineWidth: -1,
     noCompatMode: true,
     noRefs: true,
     sortKeys: false,
 };
-async function writeWantedLockfile(pkgPath, wantedLockfile, opts) {
-    const wantedLockfileName = await (0, lockfileName_js_1.getWantedLockfileName)(opts);
+export function lockfileYamlDump(obj) {
+    return yaml.dump(obj, LOCKFILE_YAML_FORMAT);
+}
+export async function writeWantedLockfile(pkgPath, wantedLockfile, opts) {
+    const wantedLockfileName = await getWantedLockfileName(opts);
     return writeLockfile(wantedLockfileName, pkgPath, wantedLockfile);
 }
-async function writeCurrentLockfile(virtualStoreDir, currentLockfile) {
+export async function writeCurrentLockfile(virtualStoreDir, currentLockfile) {
     // empty lockfile is not saved
     if (isEmptyLockfile(currentLockfile)) {
-        await (0, rimraf_1.default)(path_1.default.join(virtualStoreDir, 'lock.yaml'));
+        await rimraf(path.join(virtualStoreDir, 'lock.yaml'));
         return;
     }
-    await fs_1.promises.mkdir(virtualStoreDir, { recursive: true });
+    await fs.mkdir(virtualStoreDir, { recursive: true });
     return writeLockfile('lock.yaml', virtualStoreDir, currentLockfile);
 }
 async function writeLockfile(lockfileFilename, pkgPath, wantedLockfile) {
-    const lockfilePath = path_1.default.join(pkgPath, lockfileFilename);
-    const lockfileToStringify = (0, lockfileFormatConverters_js_1.convertToLockfileFile)(wantedLockfile);
-    return writeLockfileFile(lockfilePath, lockfileToStringify);
+    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}` : '';
+        return writeFileAtomic(lockfilePath, `${envPrefix}${yamlDoc}`);
+    }
+    return writeFileAtomic(lockfilePath, yamlDoc);
 }
-function writeLockfileFile(lockfilePath, wantedLockfile) {
+export function writeLockfileFile(lockfilePath, wantedLockfile) {
     const yamlDoc = yamlStringify(wantedLockfile);
     return writeFileAtomic(lockfilePath, yamlDoc);
 }
 function yamlStringify(lockfile) {
-    const sortedLockfile = (0, sortLockfileKeys_js_1.sortLockfileKeys)(lockfile);
-    return js_yaml_1.default.dump(sortedLockfile, LOCKFILE_YAML_FORMAT);
+    const sortedLockfile = sortLockfileKeys(lockfile);
+    return lockfileYamlDump(sortedLockfile);
 }
-function isEmptyLockfile(lockfile) {
-    return Object.values(lockfile.importers).every((importer) => (0, isEmpty_1.default)(importer.specifiers ?? {}) && (0, isEmpty_1.default)(importer.dependencies ?? {}));
+export function isEmptyLockfile(lockfile) {
+    return Object.values(lockfile.importers).every((importer) => isEmpty(importer.specifiers ?? {}) && isEmpty(importer.dependencies ?? {}));
 }
-async function writeLockfiles(opts) {
-    const wantedLockfileName = await (0, lockfileName_js_1.getWantedLockfileName)(opts);
-    const wantedLockfilePath = path_1.default.join(opts.wantedLockfileDir, wantedLockfileName);
-    const currentLockfilePath = path_1.default.join(opts.currentLockfileDir, 'lock.yaml');
-    const wantedLockfileToStringify = (0, lockfileFormatConverters_js_1.convertToLockfileFile)(opts.wantedLockfile);
+export async function writeLockfiles(opts) {
+    const 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, yamlDoc),
+            writeFileAtomic(wantedLockfilePath, wantedYamlDoc),
             (async () => {
                 if (isEmptyLockfile(opts.wantedLockfile)) {
-                    await (0, rimraf_1.default)(currentLockfilePath);
+                    await rimraf(currentLockfilePath);
                 }
                 else {
-                    await fs_1.promises.mkdir(path_1.default.dirname(currentLockfilePath), { recursive: true });
+                    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);
                 }
             })(),
         ]);
         return;
     }
-    logger_js_1.lockfileLogger.debug({
-        message: `\`${constants_1.WANTED_LOCKFILE}\` differs from \`${path_1.default.relative(opts.wantedLockfileDir, currentLockfilePath)}\``,
+    logger.debug({
+        message: `\`${WANTED_LOCKFILE}\` differs from \`${path.relative(opts.wantedLockfileDir, currentLockfilePath)}\``,
         prefix: opts.wantedLockfileDir,
     });
-    const currentLockfileToStringify = (0, lockfileFormatConverters_js_1.convertToLockfileFile)(opts.currentLockfile);
+    const currentLockfileToStringify = convertToLockfileFile(opts.currentLockfile);
     const currentYamlDoc = yamlStringify(currentLockfileToStringify);
     await Promise.all([
-        writeFileAtomic(wantedLockfilePath, yamlDoc),
+        writeFileAtomic(wantedLockfilePath, wantedYamlDoc),
         (async () => {
             if (isEmptyLockfile(opts.wantedLockfile)) {
-                await (0, rimraf_1.default)(currentLockfilePath);
+                await rimraf(currentLockfilePath);
             }
             else {
-                await fs_1.promises.mkdir(path_1.default.dirname(currentLockfilePath), { recursive: true });
+                await fs.mkdir(path.dirname(currentLockfilePath), { recursive: true });
                 await writeFileAtomic(currentLockfilePath, currentYamlDoc);
             }
         })(),

package/lib/yamlDocuments.d.ts

@@ -0,0 +1,16 @@
+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): 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

@@ -0,0 +1,70 @@
+import { createReadStream } from 'node:fs';
+import util from 'node:util';
+import stripBom from 'strip-bom';
+export const YAML_DOCUMENT_SEPARATOR = '\n---\n';
+export 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 async function streamReadFirstYamlDocument(filePath) {
+    const stream = createReadStream(filePath, { encoding: 'utf8' });
+    const chunks = stream[Symbol.asyncIterator]();
+    let buffer = '';
+    try {
+        // Phase 1: verify the file starts with "---\n"
+        for (let chunk = await chunks.next(); !chunk.done; chunk = await chunks.next()) { // eslint-disable-line no-await-in-loop
+            if (buffer.length === 0) {
+                // Strip BOM from the first chunk. Safe because the stream uses utf8 encoding,
+                // so the 3-byte BOM is decoded into a single \uFEFF character in the first chunk.
+                buffer = stripBom(chunk.value);
+            }
+            else {
+                buffer += chunk.value;
+            }
+            if (buffer.length >= YAML_DOCUMENT_START.length)
+                break;
+        }
+        if (!buffer.startsWith(YAML_DOCUMENT_START)) {
+            stream.destroy();
+            return null;
+        }
+        // Phase 2: find the second "---" separator
+        while (true) {
+            const sep = buffer.indexOf(YAML_DOCUMENT_SEPARATOR, YAML_DOCUMENT_START.length);
+            if (sep !== -1) {
+                stream.destroy();
+                return buffer.slice(YAML_DOCUMENT_START.length, sep);
+            }
+            const chunk = await chunks.next(); // eslint-disable-line no-await-in-loop
+            if (chunk.done)
+                break;
+            buffer += chunk.value;
+        }
+    }
+    catch (err) {
+        if (util.types.isNativeError(err) && 'code' in err && err.code === 'ENOENT') {
+            return null;
+        }
+        throw err;
+    }
+    stream.destroy();
+    return 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 function extractMainDocument(content) {
+    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