@pnpm/workspace.project-manifest-reader 1100.1.1 → 1100.1.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @pnpm/read-project-manifest
 
+## 1100.1.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/pkg-manifest.utils@1100.4.8
+
 ## 1100.1.1
 
 ### Patch Changes

package/lib/index.d.ts

@@ -1,5 +1,7 @@
 import type { ProjectManifest } from '@pnpm/types';
-export type WriteProjectManifest = (manifest: ProjectManifest, force?: boolean) => Promise<void>;
+import { readExactProjectManifest, type ReadExactProjectManifestResult, readExactProjectManifestSync, type WriteProjectManifest } from './manifestExactReader.js';
+export type { ReadExactProjectManifestResult, WriteProjectManifest };
+export { readExactProjectManifest, readExactProjectManifestSync };
 export declare function safeReadProjectManifestOnly(projectDir: string): Promise<ProjectManifest | null>;
 export declare function safeReadPublishManifest(projectDir: string): Promise<ProjectManifest | null>;
 /**
@@ -18,10 +20,3 @@ export declare function tryReadProjectManifest(projectDir: string): Promise<{
     manifest: ProjectManifest | null;
     writeProjectManifest: WriteProjectManifest;
 }>;
-interface ReadExactProjectManifestResult {
-    manifest: ProjectManifest;
-    writeProjectManifest: WriteProjectManifest;
-}
-export declare function readExactProjectManifest(manifestPath: string): Promise<ReadExactProjectManifestResult>;
-export declare function readExactProjectManifestSync(manifestPath: string): ReadExactProjectManifestResult;
-export {};

package/lib/index.js

@@ -1,15 +1,11 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { PnpmError } from '@pnpm/error';
-import { convertEnginesRuntimeToDependencies } from '@pnpm/pkg-manifest.utils';
-import { extractComments } from '@pnpm/text.comments-parser';
 import { writeProjectManifest } from '@pnpm/workspace.project-manifest-writer';
-import detectIndent from 'detect-indent';
-import equal from 'fast-deep-equal';
 import isWindows from 'is-windows';
 import pLimit from 'p-limit';
-import { readYamlFile, readYamlFileSync } from 'read-yaml-file';
-import { readJson5File, readJson5FileSync, readJsonFile, readJsonFileSync, } from './readFile.js';
+import { readExactProjectManifest, readExactProjectManifestSync, tryReadProjectManifestFromDir, } from './manifestExactReader.js';
+export { readExactProjectManifest, readExactProjectManifestSync };
 const limitProjectManifestReads = pLimit(4);
 export async function safeReadProjectManifestOnly(projectDir) {
     return limitProjectManifestReads(async () => {
@@ -35,7 +31,7 @@ export async function safeReadParentPublishManifest(publishDir) {
     const normalizedTarget = path.resolve(publishDir);
     let searchDir = path.dirname(normalizedTarget);
     while (true) {
-        // eslint-disable-next-line no-await-in-loop
+        // eslint-disable-next-line no-await-in-loop -- the search climbs one ancestor at a time and stops at the first match
         const parentManifest = await safeReadProjectManifestOnly(searchDir);
         if (parentManifest?.publishConfig?.directory &&
             path.resolve(searchDir, parentManifest.publishConfig.directory) === normalizedTarget) {
@@ -59,74 +55,10 @@ export async function readProjectManifestOnly(projectDir) {
     return manifest;
 }
 export async function tryReadProjectManifest(projectDir) {
-    try {
-        const manifestPath = path.join(projectDir, 'package.json');
-        const { data, text } = await readJsonFile(manifestPath);
-        const emptyDependencyFields = findEmptyDependencyFields(data);
-        return {
-            fileName: 'package.json',
-            manifest: convertManifestAfterRead(data),
-            writeProjectManifest: createManifestWriter({
-                ...detectFileFormatting(text),
-                emptyDependencyFields,
-                initialManifest: data,
-                manifestPath,
-            }),
-        };
-    }
-    catch (err) { // eslint-disable-line
-        if (err.code !== 'ENOENT')
-            throw err;
-    }
-    try {
-        const manifestPath = path.join(projectDir, 'package.json5');
-        const { data, text } = await readJson5File(manifestPath);
-        const emptyDependencyFields = findEmptyDependencyFields(data);
-        return {
-            fileName: 'package.json5',
-            manifest: convertManifestAfterRead(data),
-            writeProjectManifest: createManifestWriter({
-                ...detectFileFormattingAndComments(text),
-                emptyDependencyFields,
-                initialManifest: data,
-                manifestPath,
-            }),
-        };
-    }
-    catch (err) { // eslint-disable-line
-        if (err.code !== 'ENOENT')
-            throw err;
-    }
-    try {
-        const manifestPath = path.join(projectDir, 'package.yaml');
-        const manifest = await readPackageYaml(manifestPath);
-        const emptyDependencyFields = findEmptyDependencyFields(manifest);
-        return {
-            fileName: 'package.yaml',
-            manifest: convertManifestAfterRead(manifest),
-            writeProjectManifest: createManifestWriter({ emptyDependencyFields, initialManifest: manifest, manifestPath }),
-        };
-    }
-    catch (err) { // eslint-disable-line
-        if (err.code !== 'ENOENT')
-            throw err;
-    }
-    if (isWindows()) {
-        // ENOTDIR isn't used on Windows, but pnpm expects it.
-        let s;
-        try {
-            s = await fs.stat(projectDir);
-        }
-        catch (err) { // eslint-disable-line
-            // Ignore
-        }
-        if ((s != null) && !s.isDirectory()) {
-            const err = new Error(`"${projectDir}" is not a directory`);
-            // @ts-expect-error
-            err['code'] = 'ENOTDIR';
-            throw err;
-        }
-    }
+    const found = await tryReadProjectManifestFromDir(projectDir);
+    if (found)
+        return found;
+    await assertDirectoryExistsOnWindows(projectDir);
     const filePath = path.join(projectDir, 'package.json');
     return {
         fileName: 'package.json',
@@ -134,297 +66,19 @@ export async function tryReadProjectManifest(projectDir) {
         writeProjectManifest: async (manifest) => writeProjectManifest(filePath, manifest),
     };
 }
-function detectFileFormattingAndComments(text) {
-    const { comments, text: newText, hasFinalNewline } = extractComments(text);
-    return {
-        comments,
-        crlf: text.includes('\r\n'),
-        indent: detectIndent(newText).indent,
-        insertFinalNewline: hasFinalNewline,
-    };
-}
-function detectFileFormatting(text) {
-    return {
-        crlf: text.includes('\r\n'),
-        indent: detectIndent(text).indent,
-        insertFinalNewline: text.endsWith('\n'),
-    };
-}
-export async function readExactProjectManifest(manifestPath) {
-    const base = path.basename(manifestPath).toLowerCase();
-    switch (base) {
-        case 'package.json': {
-            const { data, text } = await readJsonFile(manifestPath);
-            const emptyDependencyFields = findEmptyDependencyFields(data);
-            return {
-                manifest: convertManifestAfterRead(data),
-                writeProjectManifest: createManifestWriter({
-                    ...detectFileFormatting(text),
-                    emptyDependencyFields,
-                    initialManifest: data,
-                    manifestPath,
-                }),
-            };
-        }
-        case 'package.json5': {
-            const { data, text } = await readJson5File(manifestPath);
-            const emptyDependencyFields = findEmptyDependencyFields(data);
-            return {
-                manifest: convertManifestAfterRead(data),
-                writeProjectManifest: createManifestWriter({
-                    ...detectFileFormattingAndComments(text),
-                    emptyDependencyFields,
-                    initialManifest: data,
-                    manifestPath,
-                }),
-            };
-        }
-        case 'package.yaml': {
-            const manifest = await readPackageYaml(manifestPath);
-            const emptyDependencyFields = findEmptyDependencyFields(manifest);
-            return {
-                manifest: convertManifestAfterRead(manifest),
-                writeProjectManifest: createManifestWriter({ emptyDependencyFields, initialManifest: manifest, manifestPath }),
-            };
-        }
-    }
-    throw new Error(`Not supported manifest name "${base}"`);
-}
-export function readExactProjectManifestSync(manifestPath) {
-    const base = path.basename(manifestPath).toLowerCase();
-    switch (base) {
-        case 'package.json': {
-            const { data, text } = readJsonFileSync(manifestPath);
-            const emptyDependencyFields = findEmptyDependencyFields(data);
-            return {
-                manifest: convertManifestAfterRead(data),
-                writeProjectManifest: createManifestWriter({
-                    ...detectFileFormatting(text),
-                    emptyDependencyFields,
-                    initialManifest: data,
-                    manifestPath,
-                }),
-            };
-        }
-        case 'package.json5': {
-            const { data, text } = readJson5FileSync(manifestPath);
-            const emptyDependencyFields = findEmptyDependencyFields(data);
-            return {
-                manifest: convertManifestAfterRead(data),
-                writeProjectManifest: createManifestWriter({
-                    ...detectFileFormattingAndComments(text),
-                    emptyDependencyFields,
-                    initialManifest: data,
-                    manifestPath,
-                }),
-            };
-        }
-        case 'package.yaml': {
-            const manifest = readPackageYamlSync(manifestPath);
-            const emptyDependencyFields = findEmptyDependencyFields(manifest);
-            return {
-                manifest: convertManifestAfterRead(manifest),
-                writeProjectManifest: createManifestWriter({ emptyDependencyFields, initialManifest: manifest, manifestPath }),
-            };
-        }
-    }
-    throw new Error(`Not supported manifest name "${base}"`);
-}
-async function readPackageYaml(filePath) {
-    try {
-        return await readYamlFile(filePath);
-    }
-    catch (err) { // eslint-disable-line
-        if (err.name !== 'YAMLException')
-            throw err;
-        err.message = `${err.message}\nin ${filePath}`;
-        err.code = 'ERR_PNPM_YAML_PARSE';
-        throw err;
-    }
-}
-function readPackageYamlSync(filePath) {
+async function assertDirectoryExistsOnWindows(projectDir) {
+    if (!isWindows())
+        return;
+    // ENOTDIR isn't used on Windows, but pnpm expects it.
+    let projectDirStats;
     try {
-        return readYamlFileSync(filePath);
+        projectDirStats = await fs.stat(projectDir);
     }
     catch (err) { // eslint-disable-line
-        if (err.name !== 'YAMLException')
-            throw err;
-        err.message = `${err.message}\nin ${filePath}`;
-        err.code = 'ERR_PNPM_YAML_PARSE';
-        throw err;
-    }
-}
-function createManifestWriter(opts) {
-    let emptyDependencyFields = opts.emptyDependencyFields ?? findEmptyDependencyFields(opts.initialManifest);
-    let initialManifest = normalize(opts.initialManifest, emptyDependencyFields);
-    return async (updatedManifest, force) => {
-        updatedManifest = convertManifestBeforeWrite(normalize(updatedManifest, emptyDependencyFields));
-        if (force === true || !equal(initialManifest, updatedManifest)) {
-            await writeProjectManifest(opts.manifestPath, updatedManifest, {
-                comments: opts.comments,
-                crlf: opts.crlf,
-                indent: opts.indent,
-                insertFinalNewline: opts.insertFinalNewline,
-            });
-            emptyDependencyFields = findEmptyDependencyFields(updatedManifest);
-            initialManifest = normalize(updatedManifest, emptyDependencyFields);
-            return Promise.resolve(undefined);
-        }
-        return Promise.resolve(undefined);
-    };
-}
-function convertManifestAfterRead(manifest) {
-    const cloned = cloneManifestForRuntimeConversion(manifest);
-    convertEnginesRuntimeToDependencies(cloned, 'devEngines', 'devDependencies');
-    convertEnginesRuntimeToDependencies(cloned, 'engines', 'dependencies');
-    return cloned;
-}
-function convertManifestBeforeWrite(manifest) {
-    const cloned = cloneManifestForRuntimeConversion(manifest);
-    convertDependenciesToEnginesRuntime(cloned, 'devDependencies', 'devEngines');
-    convertDependenciesToEnginesRuntime(cloned, 'dependencies', 'engines');
-    return cloned;
-}
-function cloneManifestForRuntimeConversion(manifest) {
-    const cloned = { ...manifest };
-    if (manifest.dependencies != null && typeof manifest.dependencies === 'object' && !Array.isArray(manifest.dependencies)) {
-        cloned.dependencies = { ...manifest.dependencies };
+        // Ignore
     }
-    if (manifest.devDependencies != null && typeof manifest.devDependencies === 'object' && !Array.isArray(manifest.devDependencies)) {
-        cloned.devDependencies = { ...manifest.devDependencies };
-    }
-    if (manifest.engines != null && typeof manifest.engines === 'object' && !Array.isArray(manifest.engines)) {
-        cloned.engines = { ...manifest.engines };
-    }
-    if (manifest.devEngines != null && typeof manifest.devEngines === 'object' && !Array.isArray(manifest.devEngines)) {
-        cloned.devEngines = { ...manifest.devEngines };
-    }
-    return cloned;
-}
-function convertDependenciesToEnginesRuntime(manifest, dependenciesFieldName, enginesFieldName) {
-    const dependencies = readDependenciesField(manifest, dependenciesFieldName);
-    for (const runtimeName of ['node', 'deno', 'bun']) {
-        const dep = dependencies?.[runtimeName];
-        if (dependencies != null && typeof dep === 'string' && dep.startsWith('runtime:')) {
-            const version = dep.slice('runtime:'.length).trim();
-            manifest[enginesFieldName] ??= {};
-            const runtimeEntry = {
-                name: runtimeName,
-                version,
-                onFail: 'download',
-            };
-            const enginesField = manifest[enginesFieldName];
-            if (!enginesField.runtime) {
-                enginesField.runtime = runtimeEntry;
-            }
-            else if (Array.isArray(enginesField.runtime)) {
-                const existing = enginesField.runtime.find(({ name }) => name === runtimeName);
-                if (existing) {
-                    Object.assign(existing, runtimeEntry);
-                }
-                else {
-                    enginesField.runtime.push(runtimeEntry);
-                }
-            }
-            else if (enginesField.runtime.name === runtimeName) {
-                Object.assign(enginesField.runtime, runtimeEntry);
-            }
-            else {
-                enginesField.runtime = [
-                    enginesField.runtime,
-                    runtimeEntry,
-                ];
-            }
-            delete dependencies[runtimeName];
-        }
-        else if (dep === undefined) {
-            removeManagedRuntimeEntry(manifest[enginesFieldName], runtimeName);
-        }
-    }
-}
-function readDependenciesField(manifest, dependenciesFieldName) {
-    const dependencies = manifest[dependenciesFieldName];
-    if (dependencies === undefined)
-        return undefined;
-    if (dependencies === null || typeof dependencies !== 'object' || Array.isArray(dependencies)) {
-        throw new PnpmError('INVALID_DEPENDENCIES_FIELD', `The "${dependenciesFieldName}" field must be an object.`);
-    }
-    return dependencies;
-}
-function removeManagedRuntimeEntry(enginesField, runtimeName) {
-    if (!enginesField?.runtime)
-        return;
-    if (Array.isArray(enginesField.runtime)) {
-        const runtimes = enginesField.runtime.filter((runtime) => !isManagedRuntimeEntry(runtime, runtimeName));
-        if (runtimes.length === 0) {
-            delete enginesField.runtime;
-        }
-        else {
-            enginesField.runtime = runtimes;
-        }
-    }
-    else if (isManagedRuntimeEntry(enginesField.runtime, runtimeName)) {
-        delete enginesField.runtime;
-    }
-}
-function isManagedRuntimeEntry(runtime, runtimeName) {
-    return runtime.name === runtimeName &&
-        runtime.onFail === 'download' &&
-        typeof runtime.version === 'string';
-}
-const dependencyKeys = new Set([
-    'dependencies',
-    'devDependencies',
-    'optionalDependencies',
-    'peerDependencies',
-]);
-/**
- * The dependency fields the manifest declares as empty objects. A write
- * keeps these in place; it only drops a field that pnpm itself emptied.
- */
-function findEmptyDependencyFields(manifest) {
-    const fields = new Set();
-    for (const key of dependencyKeys) {
-        if (isEmptyDependencyObject(manifest[key])) {
-            fields.add(key);
-        }
-    }
-    return fields;
-}
-function isEmptyDependencyObject(value) {
-    return typeof value === 'object' &&
-        value !== null &&
-        !Array.isArray(value) &&
-        Object.keys(value).length === 0;
-}
-function normalize(manifest, keepEmptyDependencyFields) {
-    const result = {};
-    for (const key in manifest) {
-        if (Object.hasOwn(manifest, key)) {
-            const value = manifest[key];
-            if (typeof value !== 'object' ||
-                value === null ||
-                !dependencyKeys.has(key) ||
-                Array.isArray(value)) {
-                result[key] = structuredClone(value);
-            }
-            else {
-                const keys = Object.keys(value);
-                if (keys.length !== 0) {
-                    keys.sort();
-                    const sortedValue = {};
-                    for (const k of keys) {
-                        // @ts-expect-error this is fine
-                        sortedValue[k] = value[k];
-                    }
-                    result[key] = sortedValue;
-                }
-                else if (keepEmptyDependencyFields.has(key)) {
-                    result[key] = {};
-                }
-            }
-        }
+    if ((projectDirStats != null) && !projectDirStats.isDirectory()) {
+        throw Object.assign(new Error(`"${projectDir}" is not a directory`), { code: 'ENOTDIR' });
     }
-    return result;
 }
 //# sourceMappingURL=index.js.map

package/lib/manifestExactReader.d.ts

@@ -0,0 +1,24 @@
+import { type CommentSpecifier } from '@pnpm/text.comments-parser';
+import type { ProjectManifest } from '@pnpm/types';
+export type WriteProjectManifest = (manifest: ProjectManifest, force?: boolean) => Promise<void>;
+export interface ReadExactProjectManifestResult {
+    manifest: ProjectManifest;
+    writeProjectManifest: WriteProjectManifest;
+}
+export declare function readExactProjectManifest(manifestPath: string): Promise<ReadExactProjectManifestResult>;
+export declare function readExactProjectManifestSync(manifestPath: string): ReadExactProjectManifestResult;
+export declare function tryReadProjectManifestFromDir(projectDir: string): Promise<{
+    fileName: string;
+    manifest: ProjectManifest;
+    writeProjectManifest: WriteProjectManifest;
+} | undefined>;
+export declare function createManifestWriter(opts: {
+    initialManifest: ProjectManifest;
+    emptyDependencyFields?: ReadonlySet<string>;
+    comments?: CommentSpecifier[];
+    crlf?: boolean;
+    indent?: string | number | undefined;
+    insertFinalNewline?: boolean;
+    manifestPath: string;
+}): WriteProjectManifest;
+export declare function findEmptyDependencyFields(manifest: ProjectManifest): Set<string>;

package/lib/manifestExactReader.js

@@ -0,0 +1,224 @@
+import path from 'node:path';
+import { extractComments } from '@pnpm/text.comments-parser';
+import { writeProjectManifest } from '@pnpm/workspace.project-manifest-writer';
+import detectIndent from 'detect-indent';
+import equal from 'fast-deep-equal';
+import { readYamlFile, readYamlFileSync } from 'read-yaml-file';
+import { convertManifestAfterRead, convertManifestBeforeWrite } from './manifestRuntime.js';
+import { readJson5File, readJson5FileSync, readJsonFile, readJsonFileSync, } from './readFile.js';
+export async function readExactProjectManifest(manifestPath) {
+    const base = path.basename(manifestPath).toLowerCase();
+    switch (base) {
+        case 'package.json':
+            return readExactPackageJson(manifestPath);
+        case 'package.json5':
+            return readExactPackageJson5(manifestPath);
+        case 'package.yaml':
+            return readExactPackageYaml(manifestPath);
+    }
+    throw new Error(`Not supported manifest name "${base}"`);
+}
+export function readExactProjectManifestSync(manifestPath) {
+    const base = path.basename(manifestPath).toLowerCase();
+    switch (base) {
+        case 'package.json':
+            return readExactPackageJsonSync(manifestPath);
+        case 'package.json5':
+            return readExactPackageJson5Sync(manifestPath);
+        case 'package.yaml':
+            return readExactPackageYamlSync(manifestPath);
+    }
+    throw new Error(`Not supported manifest name "${base}"`);
+}
+export async function tryReadProjectManifestFromDir(projectDir) {
+    const jsonResult = await tryReadPackageJson(projectDir);
+    if (jsonResult)
+        return jsonResult;
+    const json5Result = await tryReadPackageJson5(projectDir);
+    if (json5Result)
+        return json5Result;
+    return tryReadPackageYaml(projectDir);
+}
+async function tryReadPackageJson(projectDir) {
+    try {
+        const manifestPath = path.join(projectDir, 'package.json');
+        const result = await readExactPackageJson(manifestPath);
+        return { fileName: 'package.json', ...result };
+    }
+    catch (err) { // eslint-disable-line
+        if (err.code !== 'ENOENT')
+            throw err;
+        return undefined;
+    }
+}
+async function tryReadPackageJson5(projectDir) {
+    try {
+        const manifestPath = path.join(projectDir, 'package.json5');
+        const result = await readExactPackageJson5(manifestPath);
+        return { fileName: 'package.json5', ...result };
+    }
+    catch (err) { // eslint-disable-line
+        if (err.code !== 'ENOENT')
+            throw err;
+        return undefined;
+    }
+}
+async function tryReadPackageYaml(projectDir) {
+    try {
+        const manifestPath = path.join(projectDir, 'package.yaml');
+        const result = await readExactPackageYaml(manifestPath);
+        return { fileName: 'package.yaml', ...result };
+    }
+    catch (err) { // eslint-disable-line
+        if (err.code !== 'ENOENT')
+            throw err;
+        return undefined;
+    }
+}
+async function readExactPackageJson(manifestPath) {
+    const { data, text } = await readJsonFile(manifestPath);
+    return createManifestResult(data, manifestPath, detectFileFormatting(text));
+}
+function readExactPackageJsonSync(manifestPath) {
+    const { data, text } = readJsonFileSync(manifestPath);
+    return createManifestResult(data, manifestPath, detectFileFormatting(text));
+}
+async function readExactPackageJson5(manifestPath) {
+    const { data, text } = await readJson5File(manifestPath);
+    return createManifestResult(data, manifestPath, detectFileFormattingAndComments(text));
+}
+function readExactPackageJson5Sync(manifestPath) {
+    const { data, text } = readJson5FileSync(manifestPath);
+    return createManifestResult(data, manifestPath, detectFileFormattingAndComments(text));
+}
+async function readExactPackageYaml(manifestPath) {
+    const manifest = await readPackageYaml(manifestPath);
+    return createManifestResult(manifest, manifestPath);
+}
+function readExactPackageYamlSync(manifestPath) {
+    const manifest = readPackageYamlSync(manifestPath);
+    return createManifestResult(manifest, manifestPath);
+}
+function createManifestResult(data, manifestPath, formatting) {
+    const emptyDependencyFields = findEmptyDependencyFields(data);
+    return {
+        manifest: convertManifestAfterRead(data),
+        writeProjectManifest: createManifestWriter({
+            ...formatting,
+            emptyDependencyFields,
+            initialManifest: data,
+            manifestPath,
+        }),
+    };
+}
+function detectFileFormatting(text) {
+    return {
+        crlf: text.includes('\r\n'),
+        indent: detectIndent(text).indent,
+        insertFinalNewline: text.endsWith('\n'),
+    };
+}
+function detectFileFormattingAndComments(text) {
+    const { comments, text: newText, hasFinalNewline } = extractComments(text);
+    return {
+        comments,
+        crlf: text.includes('\r\n'),
+        indent: detectIndent(newText).indent,
+        insertFinalNewline: hasFinalNewline,
+    };
+}
+async function readPackageYaml(filePath) {
+    try {
+        return await readYamlFile(filePath);
+    }
+    catch (err) { // eslint-disable-line
+        if (err.name !== 'YAMLException')
+            throw err;
+        err.message = `${err.message}\nin ${filePath}`;
+        err.code = 'ERR_PNPM_YAML_PARSE';
+        throw err;
+    }
+}
+function readPackageYamlSync(filePath) {
+    try {
+        return readYamlFileSync(filePath);
+    }
+    catch (err) { // eslint-disable-line
+        if (err.name !== 'YAMLException')
+            throw err;
+        err.message = `${err.message}\nin ${filePath}`;
+        err.code = 'ERR_PNPM_YAML_PARSE';
+        throw err;
+    }
+}
+export function createManifestWriter(opts) {
+    let emptyDependencyFields = opts.emptyDependencyFields ?? findEmptyDependencyFields(opts.initialManifest);
+    let initialManifest = normalize(opts.initialManifest, emptyDependencyFields);
+    return async (updatedManifest, force) => {
+        updatedManifest = convertManifestBeforeWrite(normalize(updatedManifest, emptyDependencyFields));
+        if (force === true || !equal(initialManifest, updatedManifest)) {
+            await writeProjectManifest(opts.manifestPath, updatedManifest, {
+                comments: opts.comments,
+                crlf: opts.crlf,
+                indent: opts.indent,
+                insertFinalNewline: opts.insertFinalNewline,
+            });
+            emptyDependencyFields = findEmptyDependencyFields(updatedManifest);
+            initialManifest = normalize(updatedManifest, emptyDependencyFields);
+        }
+    };
+}
+const DEPENDENCY_KEYS = new Set([
+    'dependencies',
+    'devDependencies',
+    'optionalDependencies',
+    'peerDependencies',
+]);
+export function findEmptyDependencyFields(manifest) {
+    const fields = new Set();
+    for (const key of DEPENDENCY_KEYS) {
+        if (isEmptyDependencyObject(manifest[key])) {
+            fields.add(key);
+        }
+    }
+    return fields;
+}
+function isEmptyDependencyObject(value) {
+    return typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.keys(value).length === 0;
+}
+function normalize(manifest, keepEmptyDependencyFields) {
+    const result = {};
+    for (const key of Object.keys(manifest)) {
+        const value = manifest[key];
+        if (isDependencyObject(value, key)) {
+            const keys = Object.keys(value);
+            if (keys.length !== 0) {
+                result[key] = sortObjectKeys(value, keys.sort());
+            }
+            else if (keepEmptyDependencyFields.has(key)) {
+                result[key] = {};
+            }
+        }
+        else {
+            result[key] = structuredClone(value);
+        }
+    }
+    return result;
+}
+function isDependencyObject(value, key) {
+    return typeof value === 'object' &&
+        value !== null &&
+        DEPENDENCY_KEYS.has(key) &&
+        !Array.isArray(value);
+}
+function sortObjectKeys(source, sortedKeys) {
+    const sorted = {};
+    for (const fieldName of sortedKeys) {
+        sorted[fieldName] = source[fieldName];
+    }
+    return sorted;
+}
+//# sourceMappingURL=manifestExactReader.js.map

package/lib/manifestRuntime.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectManifest } from '@pnpm/types';
+export declare function convertManifestAfterRead(manifest: ProjectManifest): ProjectManifest;
+export declare function convertManifestBeforeWrite(manifest: ProjectManifest): ProjectManifest;

package/lib/manifestRuntime.js

@@ -0,0 +1,107 @@
+import { PnpmError } from '@pnpm/error';
+import { convertEnginesRuntimeToDependencies } from '@pnpm/pkg-manifest.utils';
+export function convertManifestAfterRead(manifest) {
+    const cloned = cloneManifestForRuntimeConversion(manifest);
+    convertEnginesRuntimeToDependencies(cloned, 'devEngines', 'devDependencies');
+    convertEnginesRuntimeToDependencies(cloned, 'engines', 'dependencies');
+    return cloned;
+}
+export function convertManifestBeforeWrite(manifest) {
+    const cloned = cloneManifestForRuntimeConversion(manifest);
+    convertDependenciesToEnginesRuntime(cloned, 'devDependencies', 'devEngines');
+    convertDependenciesToEnginesRuntime(cloned, 'dependencies', 'engines');
+    return cloned;
+}
+function cloneManifestForRuntimeConversion(manifest) {
+    const cloned = { ...manifest };
+    if (manifest.dependencies != null && typeof manifest.dependencies === 'object' && !Array.isArray(manifest.dependencies)) {
+        cloned.dependencies = { ...manifest.dependencies };
+    }
+    if (manifest.devDependencies != null && typeof manifest.devDependencies === 'object' && !Array.isArray(manifest.devDependencies)) {
+        cloned.devDependencies = { ...manifest.devDependencies };
+    }
+    if (manifest.engines != null && typeof manifest.engines === 'object' && !Array.isArray(manifest.engines)) {
+        cloned.engines = { ...manifest.engines };
+    }
+    if (manifest.devEngines != null && typeof manifest.devEngines === 'object' && !Array.isArray(manifest.devEngines)) {
+        cloned.devEngines = { ...manifest.devEngines };
+    }
+    return cloned;
+}
+function convertDependenciesToEnginesRuntime(manifest, dependenciesFieldName, enginesFieldName) {
+    const dependencies = readDependenciesField(manifest, dependenciesFieldName);
+    for (const runtimeName of ['node', 'deno', 'bun']) {
+        applyRuntimeConversion(manifest, enginesFieldName, dependencies, runtimeName);
+    }
+}
+function applyRuntimeConversion(manifest, enginesFieldName, dependencies, runtimeName) {
+    const dep = dependencies?.[runtimeName];
+    if (dependencies != null && typeof dep === 'string' && dep.startsWith('runtime:')) {
+        setManagedRuntimeEntry(manifest, enginesFieldName, runtimeName, dep.slice('runtime:'.length).trim());
+        delete dependencies[runtimeName];
+    }
+    else if (dep === undefined) {
+        removeManagedRuntimeEntry(manifest[enginesFieldName], runtimeName);
+    }
+}
+function setManagedRuntimeEntry(manifest, enginesFieldName, runtimeName, version) {
+    manifest[enginesFieldName] ??= {};
+    const runtimeEntry = {
+        name: runtimeName,
+        version,
+        onFail: 'download',
+    };
+    const enginesField = manifest[enginesFieldName];
+    if (!enginesField.runtime) {
+        enginesField.runtime = runtimeEntry;
+    }
+    else if (Array.isArray(enginesField.runtime)) {
+        updateRuntimeInList(enginesField.runtime, runtimeEntry);
+    }
+    else if (enginesField.runtime.name === runtimeName) {
+        Object.assign(enginesField.runtime, runtimeEntry);
+    }
+    else {
+        enginesField.runtime = [enginesField.runtime, runtimeEntry];
+    }
+}
+function updateRuntimeInList(runtimes, runtimeEntry) {
+    const existing = runtimes.find(({ name }) => name === runtimeEntry.name);
+    if (existing) {
+        Object.assign(existing, runtimeEntry);
+    }
+    else {
+        runtimes.push(runtimeEntry);
+    }
+}
+function readDependenciesField(manifest, dependenciesFieldName) {
+    const dependencies = manifest[dependenciesFieldName];
+    if (dependencies === undefined)
+        return undefined;
+    if (dependencies === null || typeof dependencies !== 'object' || Array.isArray(dependencies)) {
+        throw new PnpmError('INVALID_DEPENDENCIES_FIELD', `The "${dependenciesFieldName}" field must be an object.`);
+    }
+    return dependencies;
+}
+function removeManagedRuntimeEntry(enginesField, runtimeName) {
+    if (!enginesField?.runtime)
+        return;
+    if (Array.isArray(enginesField.runtime)) {
+        const runtimes = enginesField.runtime.filter((runtime) => !isManagedRuntimeEntry(runtime, runtimeName));
+        if (runtimes.length === 0) {
+            delete enginesField.runtime;
+        }
+        else {
+            enginesField.runtime = runtimes;
+        }
+    }
+    else if (isManagedRuntimeEntry(enginesField.runtime, runtimeName)) {
+        delete enginesField.runtime;
+    }
+}
+function isManagedRuntimeEntry(runtime, runtimeName) {
+    return runtime.name === runtimeName &&
+        runtime.onFail === 'download' &&
+        typeof runtime.version === 'string';
+}
+//# sourceMappingURL=manifestRuntime.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/workspace.project-manifest-reader",
-  "version": "1100.1.1",
+  "version": "1100.1.2",
   "description": "Read a project manifest (called package.json in most cases)",
   "keywords": [
     "pnpm",
@@ -29,7 +29,7 @@
   "dependencies": {
     "@pnpm/error": "1100.2.1",
     "@pnpm/fs.graceful-fs": "1100.2.4",
-    "@pnpm/pkg-manifest.utils": "1100.4.7",
+    "@pnpm/pkg-manifest.utils": "1100.4.8",
     "@pnpm/text.comments-parser": "1100.0.1",
     "@pnpm/types": "1102.1.1",
     "@pnpm/workspace.project-manifest-writer": "1100.0.19",
@@ -48,7 +48,7 @@
   "devDependencies": {
     "@jest/globals": "30.4.1",
     "@pnpm/test-fixtures": "1100.0.1",
-    "@pnpm/workspace.project-manifest-reader": "1100.1.1",
+    "@pnpm/workspace.project-manifest-reader": "1100.1.2",
     "@types/is-windows": "^1.0.2",
     "@types/parse-json": "^7.0.0",
     "tempy": "3.0.0"