@pnpm/releasing.exportable-manifest 1100.3.4 → 1100.3.6

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @pnpm/exportable-manifest
 
+## 1100.3.6
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/workspace.project-manifest-reader@1100.1.2
+
+## 1100.3.5
+
+### Patch Changes
+
+- `pnpm publish` now includes bare `README` files and README files with Markdown extensions such as `readme.markdown` in registry metadata [#12704](https://github.com/pnpm/pnpm/issues/12704).
+
 ## 1100.3.4
 
 ### Patch Changes

package/lib/index.d.ts

@@ -1,12 +1,11 @@
 import type { Catalogs } from '@pnpm/catalogs.types';
 import type { Hooks } from '@pnpm/hooks.pnpmfile';
 import type { ProjectManifest } from '@pnpm/types';
+import { getReadmeRank, isPreferredReadme, type ReadmeCandidate, type ReadmeRank, readReadmeFile } from './readme.js';
 import { type ExportedManifest } from './transform/index.js';
+import { type WorkspacePackageContainer, type WorkspacePackageLookup } from './workspaceLookup.js';
 export { type ExportedManifest };
-export type WorkspacePackageLookup = Array<{
-    manifest: ProjectManifest;
-    rootDir?: string;
-}> | Map<string, unknown> | Record<string, unknown> | ((depName: string) => ProjectManifest | undefined);
+export { getReadmeRank, isPreferredReadme, type ReadmeCandidate, type ReadmeRank, readReadmeFile, type WorkspacePackageContainer, type WorkspacePackageLookup, };
 export interface MakePublishManifestOptions {
     catalogs: Catalogs;
     hooks?: Hooks;
@@ -16,7 +15,6 @@ export interface MakePublishManifestOptions {
     workspacePackages?: WorkspacePackageLookup;
 }
 export declare function createExportableManifest(dir: string, originalManifest: ProjectManifest, opts: MakePublishManifestOptions): Promise<ExportedManifest>;
-export declare function readReadmeFile(projectDir: string): Promise<string | undefined>;
 export type PublishDependencyConverter = (depName: string, depSpec: string, context: PublishDependencyConverterContext) => Promise<string> | string;
 export interface PublishDependencyConverterContext {
     dir: string;

package/lib/index.js

@@ -1,14 +1,16 @@
-import fs from 'node:fs';
 import path from 'node:path';
 import { resolveFromCatalog } from '@pnpm/catalogs.resolver';
-import { isError, PnpmError } from '@pnpm/error';
-import { parseJsrSpecifier } from '@pnpm/resolving.jsr-specifier-parser';
+import { PnpmError } from '@pnpm/error';
 import { tryReadProjectManifest } from '@pnpm/workspace.project-manifest-reader';
 import { WorkspaceSpec } from '@pnpm/workspace.spec-parser';
 import { clone, omit } from 'ramda';
+import { replaceJsrProtocol } from './jsrProtocol.js';
 import { overridePublishConfig } from './overridePublishConfig.js';
+import { getReadmeRank, isPreferredReadme, readReadmeFile, } from './readme.js';
 import { transform } from './transform/index.js';
+import { buildWorkspaceManifestGetter, } from './workspaceLookup.js';
 export {};
+export { getReadmeRank, isPreferredReadme, readReadmeFile, };
 const PREPUBLISH_SCRIPTS = [
     'prepublishOnly',
     'prepack',
@@ -18,24 +20,44 @@ const PREPUBLISH_SCRIPTS = [
     'postpublish',
 ];
 export async function createExportableManifest(dir, originalManifest, opts) {
-    let publishManifest;
-    if (opts.skipManifestObfuscation) {
-        publishManifest = omit(['pnpm'], clone(originalManifest));
-    }
-    else {
-        publishManifest = omit(['scripts', 'packageManager', 'pnpm'], originalManifest);
-        if (originalManifest.scripts != null) {
-            publishManifest.scripts = omit(PREPUBLISH_SCRIPTS, originalManifest.scripts);
+    const publishManifest = initPublishManifest(originalManifest, opts.skipManifestObfuscation);
+    const getWorkspaceManifest = buildWorkspaceManifestGetter(opts.workspacePackages);
+    await convertManifestDependencies({
+        catalogs: opts.catalogs,
+        dir,
+        getWorkspaceManifest,
+        modulesDir: opts.modulesDir,
+        originalManifest,
+        publishManifest,
+    });
+    overridePublishConfig(publishManifest);
+    if (publishManifest.readme == null && opts.embedReadme) {
+        const readme = await readReadmeFile(dir);
+        if (readme != null) {
+            publishManifest.readme = readme;
         }
     }
-    const catalogResolver = resolveFromCatalog.bind(null, opts.catalogs);
-    const replaceCatalogProtocol = resolveCatalogProtocol.bind(null, catalogResolver);
-    const getWorkspaceManifest = buildWorkspaceManifestGetter(opts.workspacePackages);
+    const finalManifest = await applyPublishHooks(publishManifest, dir, opts.hooks?.beforePacking);
+    return transform(finalManifest);
+}
+function initPublishManifest(originalManifest, skipObfuscation) {
+    if (skipObfuscation) {
+        return omit(['pnpm'], clone(originalManifest));
+    }
+    const publishManifest = omit(['scripts', 'packageManager', 'pnpm'], originalManifest);
+    if (originalManifest.scripts != null) {
+        publishManifest.scripts = omit(PREPUBLISH_SCRIPTS, originalManifest.scripts);
+    }
+    return publishManifest;
+}
+async function convertManifestDependencies(params) {
+    const { catalogs, dir, getWorkspaceManifest, modulesDir, originalManifest, publishManifest } = params;
+    const replaceCatalogProtocol = resolveCatalogProtocol.bind(null, resolveFromCatalog.bind(null, catalogs));
     const convertDependencyForPublish = combineConverters(replaceCatalogProtocol, replaceWorkspaceProtocol, replaceJsrProtocol);
     await Promise.all(['dependencies', 'devDependencies', 'optionalDependencies'].map(async (depsField) => {
         const deps = await makePublishDependencies(dir, originalManifest[depsField], {
-            modulesDir: opts?.modulesDir,
             convertDependencyForPublish,
+            modulesDir,
             workspacePackages: getWorkspaceManifest,
         });
         if (deps != null) {
@@ -46,56 +68,25 @@ export async function createExportableManifest(dir, originalManifest, opts) {
     if (peerDependencies) {
         const convertPeersForPublish = combineConverters(replaceCatalogProtocol, replaceWorkspaceProtocolPeerDependency, replaceJsrProtocol);
         publishManifest.peerDependencies = await makePublishDependencies(dir, peerDependencies, {
-            modulesDir: opts?.modulesDir,
             convertDependencyForPublish: convertPeersForPublish,
+            modulesDir,
             workspacePackages: getWorkspaceManifest,
         });
     }
-    overridePublishConfig(publishManifest);
-    if (publishManifest.readme == null && opts?.embedReadme) {
-        const readme = await readReadmeFile(dir);
-        if (readme != null) {
-            publishManifest.readme = readme;
-        }
-    }
-    for (const hook of opts?.hooks?.beforePacking ?? []) {
-        // eslint-disable-next-line no-await-in-loop
-        publishManifest = await hook(publishManifest, dir) ?? publishManifest;
-    }
-    return transform(publishManifest);
 }
-// `O_NOFOLLOW` makes the open itself refuse a symlink at the final path component, closing the
-// TOCTOU window between the `readdir` type check and the read: a symlink swapped in for README.md
-// after the check can't redirect the read outside the project and leak its target into the
-// published manifest. Windows lacks the flag (and requires privileges to create symlinks), so it
-// falls back to a plain read.
-const README_READ_FLAGS = fs.constants.O_RDONLY | (process.platform === 'win32' ? 0 : fs.constants.O_NOFOLLOW);
-export async function readReadmeFile(projectDir) {
-    const entries = await fs.promises.readdir(projectDir, { withFileTypes: true });
-    // Only embed a regular README.md file — a symlink is skipped (see README_READ_FLAGS).
-    const readmeEntry = entries.find((entry) => entry.isFile() && /^readme\.md$/i.test(entry.name));
-    if (readmeEntry == null)
-        return undefined;
-    let handle;
-    try {
-        handle = await fs.promises.open(path.join(projectDir, readmeEntry.name), README_READ_FLAGS);
-        return await handle.readFile('utf8');
-    }
-    catch (err) {
-        // ELOOP: the entry is a symlink after all (a concurrent swap) — skip it, as the isFile() check intended.
-        if (isError(err) && 'code' in err && err.code === 'ELOOP')
-            return undefined;
-        throw err;
-    }
-    finally {
-        await handle?.close();
+async function applyPublishHooks(manifest, dir, hooks) {
+    let result = manifest;
+    for (const hook of hooks ?? []) {
+        // eslint-disable-next-line no-await-in-loop -- each hook receives the manifest returned by the previous one
+        result = await hook(result, dir) ?? result;
     }
+    return result;
 }
 function combineConverters(...converters) {
     return async (depName, depSpec, context) => {
         let bareSpecifier = depSpec;
         for (const converter of converters) {
-            // eslint-disable-next-line no-await-in-loop
+            // eslint-disable-next-line no-await-in-loop -- each converter receives the specifier returned by the previous one
             bareSpecifier = await converter(depName, bareSpecifier, context);
         }
         return bareSpecifier;
@@ -107,60 +98,6 @@ async function makePublishDependencies(dir, dependencies, { modulesDir, convertD
     const publishDependencies = await Promise.all(Object.entries(dependencies).map(async ([depName, depSpec]) => [depName, await convertDependencyForPublish(depName, depSpec, { dir, modulesDir, workspacePackages })]));
     return Object.fromEntries(publishDependencies);
 }
-function extractManifest(val) {
-    if (!val || typeof val !== 'object')
-        return undefined;
-    if ('manifest' in val && val.manifest && typeof val.manifest === 'object') {
-        return val.manifest;
-    }
-    if ('package' in val && val.package && typeof val.package === 'object' && 'manifest' in val.package && val.package.manifest && typeof val.package.manifest === 'object') {
-        return val.package.manifest;
-    }
-    if ('name' in val && typeof val.name === 'string') {
-        return val;
-    }
-    return undefined;
-}
-function buildWorkspaceManifestGetter(workspacePackages) {
-    if (!workspacePackages)
-        return undefined;
-    if (typeof workspacePackages === 'function') {
-        return workspacePackages;
-    }
-    const byName = new Map();
-    const addManifest = (val) => {
-        const manifest = extractManifest(val);
-        if (!manifest?.name)
-            return;
-        const existing = byName.get(manifest.name);
-        if (!existing || (!existing.version && manifest.version)) {
-            byName.set(manifest.name, manifest);
-        }
-    };
-    if (Array.isArray(workspacePackages)) {
-        for (const pkg of workspacePackages) {
-            addManifest(pkg);
-        }
-    }
-    else if (workspacePackages instanceof Map) {
-        for (const val of workspacePackages.values()) {
-            if (val instanceof Map) {
-                for (const subVal of val.values()) {
-                    addManifest(subVal);
-                }
-            }
-            else {
-                addManifest(val);
-            }
-        }
-    }
-    else if (typeof workspacePackages === 'object') {
-        for (const val of Object.values(workspacePackages)) {
-            addManifest(val);
-        }
-    }
-    return (depName) => byName.get(depName);
-}
 async function readAndCheckManifest(depName, dependencyDir, getWorkspaceManifest, targetPkgName) {
     const { manifest: dirManifest } = await tryReadProjectManifest(dependencyDir);
     if (dirManifest?.name && dirManifest?.version) {
@@ -171,6 +108,9 @@ async function readAndCheckManifest(depName, dependencyDir, getWorkspaceManifest
     if (workspaceManifest?.name && workspaceManifest?.version) {
         return workspaceManifest;
     }
+    return handleMissingOrInvalidManifest(depName, dirManifest ?? undefined, workspaceManifest);
+}
+function handleMissingOrInvalidManifest(depName, dirManifest, workspaceManifest) {
     const found = dirManifest?.name || dirManifest?.version
         ? dirManifest
         : workspaceManifest?.name || workspaceManifest?.version
@@ -195,36 +135,39 @@ function resolveCatalogProtocol(catalogResolver, alias, bareSpecifier) {
         case 'misconfiguration': throw result.error;
     }
 }
-async function replaceWorkspaceProtocol(depName, depSpec, { dir, modulesDir, workspacePackages }) {
+async function replaceWorkspaceProtocol(depName, depSpec, context) {
     if (!depSpec.startsWith('workspace:')) {
         return depSpec;
     }
     // Dependencies with bare "*", "^", "~" versions, or no version (workspace:)
     const versionAliasSpecParts = /^workspace:(?:(.+)@)?([\^~*])?$/.exec(depSpec);
     if (versionAliasSpecParts != null) {
-        modulesDir = modulesDir ?? path.join(dir, 'node_modules');
-        const targetPkgName = versionAliasSpecParts[1];
-        const manifest = await readAndCheckManifest(depName, path.join(modulesDir, depName), workspacePackages, targetPkgName);
-        const specifierSuffix = versionAliasSpecParts[2];
-        const semverRangeToken = specifierSuffix === '^' || specifierSuffix === '~' ? specifierSuffix : '';
-        if (depName !== manifest.name) {
-            return `npm:${manifest.name}@${semverRangeToken}${manifest.version}`;
-        }
-        return `${semverRangeToken}${manifest.version}`;
+        return resolveVersionAliasWorkspaceSpec(depName, versionAliasSpecParts, context);
     }
     if (depSpec.startsWith('workspace:./') || depSpec.startsWith('workspace:../')) {
-        const manifest = await readAndCheckManifest(depName, path.join(dir, depSpec.slice(10)), workspacePackages);
-        if (manifest.name === depName)
-            return `${manifest.version}`;
-        return `npm:${manifest.name}@${manifest.version}`;
-    }
-    depSpec = depSpec.slice(10);
-    if (depSpec.includes('@')) {
-        return `npm:${depSpec}`;
+        return resolveRelativeWorkspaceSpec(depName, depSpec.slice(10), context);
     }
-    return depSpec;
+    const spec = depSpec.slice(10);
+    return spec.includes('@') ? `npm:${spec}` : spec;
+}
+async function resolveVersionAliasWorkspaceSpec(depName, parts, context) {
+    const modulesDir = context.modulesDir ?? path.join(context.dir, 'node_modules');
+    const targetPkgName = parts[1];
+    const manifest = await readAndCheckManifest(depName, path.join(modulesDir, depName), context.workspacePackages, targetPkgName);
+    const specifierSuffix = parts[2];
+    const semverRangeToken = specifierSuffix === '^' || specifierSuffix === '~' ? specifierSuffix : '';
+    if (depName !== manifest.name) {
+        return `npm:${manifest.name}@${semverRangeToken}${manifest.version}`;
+    }
+    return `${semverRangeToken}${manifest.version}`;
 }
-async function replaceWorkspaceProtocolPeerDependency(depName, depSpec, { dir, modulesDir, workspacePackages }) {
+async function resolveRelativeWorkspaceSpec(depName, relPath, context) {
+    const manifest = await readAndCheckManifest(depName, path.join(context.dir, relPath), context.workspacePackages);
+    if (manifest.name === depName)
+        return `${manifest.version}`;
+    return `npm:${manifest.name}@${manifest.version}`;
+}
+async function replaceWorkspaceProtocolPeerDependency(depName, depSpec, context) {
     if (!depSpec.includes('workspace:')) {
         return depSpec;
     }
@@ -236,35 +179,23 @@ async function replaceWorkspaceProtocolPeerDependency(depName, depSpec, { dir, m
         return `npm:${workspaceSpec.alias}@${version}`;
     }
     if (workspaceSpec?.version.startsWith('./') || workspaceSpec?.version.startsWith('../')) {
-        return replaceWorkspaceProtocol(depName, depSpec, { dir, modulesDir, workspacePackages });
+        return replaceWorkspaceProtocol(depName, depSpec, context);
     }
-    // Dependencies with bare "*", "^", "~",">=",">","<=", "<", version
-    const workspaceSemverRegex = /workspace:([\^~*]|>=|>|<=|<)?((\d+|[xX*])(\.(\d+|[xX*])){0,2})?/;
-    const versionAliasSpecParts = workspaceSemverRegex.exec(depSpec);
-    if (versionAliasSpecParts != null) {
-        const [, semverRangGroup = '', version] = versionAliasSpecParts;
-        if (version) {
-            return depSpec.replace('workspace:', '');
-        }
-        modulesDir = modulesDir ?? path.join(dir, 'node_modules');
-        const manifest = await readAndCheckManifest(depName, path.join(modulesDir, depName), workspacePackages);
-        const semverRangeToken = semverRangGroup !== '*' ? semverRangGroup : '';
-        return depSpec.replace(workspaceSemverRegex, `${semverRangeToken}${manifest.version}`);
-    }
-    return depSpec.replace('workspace:', '');
+    return resolvePeerWorkspaceSemver(depName, depSpec, context);
 }
-async function replaceJsrProtocol(depName, depSpec) {
-    const spec = parseJsrSpecifier(depSpec, depName);
-    if (spec == null) {
-        return depSpec;
-    }
-    return createNpmAliasedSpecifier(spec.npmPkgName, spec.versionSelector);
-}
-function createNpmAliasedSpecifier(npmPkgName, versionSelector) {
-    const npmPkgSpecifier = `npm:${npmPkgName}`;
-    if (!versionSelector) {
-        return npmPkgSpecifier;
-    }
-    return `${npmPkgSpecifier}@${versionSelector}`;
+const WORKSPACE_SEMVER_REGEX = /workspace:([\^~*]|>=|>|<=|<)?((\d+|[xX*])(\.(\d+|[xX*])){0,2})?/;
+async function resolvePeerWorkspaceSemver(depName, depSpec, context) {
+    const versionAliasSpecParts = WORKSPACE_SEMVER_REGEX.exec(depSpec);
+    if (versionAliasSpecParts == null) {
+        return depSpec.replace('workspace:', '');
+    }
+    const [, semverRangeGroup = '', version] = versionAliasSpecParts;
+    if (version) {
+        return depSpec.replace('workspace:', '');
+    }
+    const modulesDir = context.modulesDir ?? path.join(context.dir, 'node_modules');
+    const manifest = await readAndCheckManifest(depName, path.join(modulesDir, depName), context.workspacePackages);
+    const semverRangeToken = semverRangeGroup !== '*' ? semverRangeGroup : '';
+    return depSpec.replace(WORKSPACE_SEMVER_REGEX, `${semverRangeToken}${manifest.version}`);
 }
 //# sourceMappingURL=index.js.map

package/lib/jsrProtocol.d.ts

@@ -0,0 +1 @@
+export declare function replaceJsrProtocol(depName: string, depSpec: string): Promise<string>;

package/lib/jsrProtocol.js

@@ -0,0 +1,16 @@
+import { parseJsrSpecifier } from '@pnpm/resolving.jsr-specifier-parser';
+export async function replaceJsrProtocol(depName, depSpec) {
+    const spec = parseJsrSpecifier(depSpec, depName);
+    if (spec == null) {
+        return depSpec;
+    }
+    return createNpmAliasedSpecifier(spec.npmPkgName, spec.versionSelector);
+}
+function createNpmAliasedSpecifier(npmPkgName, versionSelector) {
+    const npmPkgSpecifier = `npm:${npmPkgName}`;
+    if (!versionSelector) {
+        return npmPkgSpecifier;
+    }
+    return `${npmPkgSpecifier}@${versionSelector}`;
+}
+//# sourceMappingURL=jsrProtocol.js.map

package/lib/overridePublishConfig.js

@@ -33,11 +33,11 @@ export function overridePublishConfig(publishManifest) {
     if (!publishManifest.publishConfig)
         return;
     const publishConfig = { ...publishManifest.publishConfig };
+    const manifestFields = publishManifest;
     for (const key in publishConfig) {
         if (!PUBLISH_CONFIG_WHITELIST.has(key))
             continue;
-        const value = publishConfig[key];
-        publishManifest[key] = value; // eslint-disable-line @typescript-eslint/no-explicit-any
+        manifestFields[key] = publishConfig[key];
         delete publishConfig[key];
     }
     if (isEmpty(publishConfig)) {

package/lib/readme.d.ts

@@ -0,0 +1,25 @@
+declare const README_RANK: {
+    readonly bare: 1;
+    readonly markdown: 2;
+    readonly readmeMd: 3;
+};
+export interface ReadmeCandidate {
+    fileName: string;
+    rank: ReadmeRank;
+}
+/** How npm ranks a package-root file as the package's README. A higher rank wins. */
+export type ReadmeRank = typeof README_RANK[keyof typeof README_RANK];
+/**
+ * Rank a filename as a README candidate, or return `undefined` if npm would not use it as the
+ * package's README. npm matches the bare `README` case-sensitively and accepts `README.*` whose
+ * extension matches `/.m?a?r?k?d?o?w?n?$/i`.
+ */
+export declare function getReadmeRank(fileName: string): ReadmeRank | undefined;
+/**
+ * Whether README `candidate` should replace the `current` selection. A higher rank wins. Equal
+ * ranks keep the lower filename, so the choice does not depend on directory or archive order, and
+ * an equal filename replaces, so the last duplicate archive entry wins as it would on extraction.
+ */
+export declare function isPreferredReadme(candidate: ReadmeCandidate, current: ReadmeCandidate | undefined): boolean;
+export declare function readReadmeFile(projectDir: string): Promise<string | undefined>;
+export {};

package/lib/readme.js

@@ -0,0 +1,70 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isError } from '@pnpm/error';
+const README_RANK = {
+    bare: 1,
+    markdown: 2,
+    readmeMd: 3,
+};
+/**
+ * Rank a filename as a README candidate, or return `undefined` if npm would not use it as the
+ * package's README. npm matches the bare `README` case-sensitively and accepts `README.*` whose
+ * extension matches `/.m?a?r?k?d?o?w?n?$/i`.
+ */
+export function getReadmeRank(fileName) {
+    if (/^readme\.md$/i.test(fileName))
+        return README_RANK.readmeMd;
+    if (fileName === 'README')
+        return README_RANK.bare;
+    if (/^readme\./i.test(fileName) && /\.m?a?r?k?d?o?w?n?$/i.test(fileName))
+        return README_RANK.markdown;
+    return undefined;
+}
+/**
+ * Whether README `candidate` should replace the `current` selection. A higher rank wins. Equal
+ * ranks keep the lower filename, so the choice does not depend on directory or archive order, and
+ * an equal filename replaces, so the last duplicate archive entry wins as it would on extraction.
+ */
+export function isPreferredReadme(candidate, current) {
+    if (current == null || candidate.rank > current.rank)
+        return true;
+    return candidate.rank === current.rank && candidate.fileName <= current.fileName;
+}
+// `O_NOFOLLOW` makes the open itself refuse a symlink at the final path component, closing the
+// TOCTOU window between the `readdir` type check and the read: a symlink swapped in for the
+// selected README after the check can't redirect the read outside the project and leak its target
+// into the published manifest. Windows lacks the flag (and requires privileges to create symlinks),
+// so it falls back to a plain read.
+const README_READ_FLAGS = fs.constants.O_RDONLY | (process.platform === 'win32' ? 0 : fs.constants.O_NOFOLLOW);
+export async function readReadmeFile(projectDir) {
+    const entries = await fs.promises.readdir(projectDir, { withFileTypes: true });
+    let readme;
+    for (const entry of entries) {
+        const rank = getReadmeRank(entry.name);
+        if (rank == null || !entry.isFile())
+            continue;
+        const candidate = { fileName: entry.name, rank };
+        if (isPreferredReadme(candidate, readme))
+            readme = candidate;
+    }
+    if (readme == null)
+        return undefined;
+    return readReadmeContent(projectDir, readme.fileName);
+}
+async function readReadmeContent(projectDir, fileName) {
+    let handle;
+    try {
+        handle = await fs.promises.open(path.join(projectDir, fileName), README_READ_FLAGS);
+        return await handle.readFile('utf8');
+    }
+    catch (err) {
+        // ELOOP: the entry is a symlink after all (a concurrent swap) — skip it, as the isFile() check intended.
+        if (isError(err) && 'code' in err && err.code === 'ELOOP')
+            return undefined;
+        throw err;
+    }
+    finally {
+        await handle?.close();
+    }
+}
+//# sourceMappingURL=readme.js.map

package/lib/transform/bin.d.ts

@@ -6,7 +6,6 @@ type Output<Manifest extends Input> = Omit<Manifest, 'bin'> & Pick<ExportedManif
 export declare function transformBin<Manifest extends Input>(manifest: Manifest): Output<Manifest>;
 /**
  * The property `"bin"` of a `package.json` could be either an object or a string.
- * This function normalizes either forms into an object.
  */
 export declare function normalizeBinObject(pkgName: string, bin: string | Record<string, string>): Record<string, string>;
 export declare class InvalidScopedPackageNameError extends PnpmError {

package/lib/transform/bin.js

@@ -10,7 +10,6 @@ export function transformBin(manifest) {
 }
 /**
  * The property `"bin"` of a `package.json` could be either an object or a string.
- * This function normalizes either forms into an object.
  */
 export function normalizeBinObject(pkgName, bin) {
     if (typeof bin === 'object')

package/lib/workspaceLookup.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectManifest } from '@pnpm/types';
+export type WorkspacePackageContainer = Array<{
+    manifest: ProjectManifest;
+    rootDir?: string;
+}> | Map<string, unknown> | Record<string, unknown>;
+export type WorkspacePackageLookup = WorkspacePackageContainer | ((depName: string) => ProjectManifest | undefined);
+export declare function buildWorkspaceManifestGetter(workspacePackages?: WorkspacePackageLookup): ((depName: string) => ProjectManifest | undefined) | undefined;

package/lib/workspaceLookup.js

@@ -0,0 +1,59 @@
+export function buildWorkspaceManifestGetter(workspacePackages) {
+    if (!workspacePackages)
+        return undefined;
+    if (typeof workspacePackages === 'function') {
+        return workspacePackages;
+    }
+    const byName = new Map();
+    collectWorkspaceManifests(workspacePackages, byName);
+    return (depName) => byName.get(depName);
+}
+function collectWorkspaceManifests(workspacePackages, byName) {
+    const add = (val) => addManifestEntry(val, byName);
+    if (Array.isArray(workspacePackages)) {
+        for (const pkg of workspacePackages)
+            add(pkg);
+        return;
+    }
+    if (workspacePackages instanceof Map) {
+        collectFromMap(workspacePackages, add);
+        return;
+    }
+    for (const val of Object.values(workspacePackages))
+        add(val);
+}
+function collectFromMap(map, add) {
+    for (const val of map.values()) {
+        if (val instanceof Map) {
+            for (const subVal of val.values())
+                add(subVal);
+        }
+        else {
+            add(val);
+        }
+    }
+}
+function addManifestEntry(val, byName) {
+    const manifest = extractManifest(val);
+    if (!manifest?.name)
+        return;
+    const existing = byName.get(manifest.name);
+    if (!existing || (!existing.version && manifest.version)) {
+        byName.set(manifest.name, manifest);
+    }
+}
+function extractManifest(val) {
+    if (!val || typeof val !== 'object')
+        return undefined;
+    if ('manifest' in val && val.manifest && typeof val.manifest === 'object') {
+        return val.manifest;
+    }
+    if ('package' in val && val.package && typeof val.package === 'object' && 'manifest' in val.package && val.package.manifest && typeof val.package.manifest === 'object') {
+        return val.package.manifest;
+    }
+    if ('name' in val && typeof val.name === 'string') {
+        return val;
+    }
+    return undefined;
+}
+//# sourceMappingURL=workspaceLookup.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/releasing.exportable-manifest",
-  "version": "1100.3.4",
+  "version": "1100.3.6",
   "description": "Creates an exportable manifest",
   "keywords": [
     "pnpm",
@@ -33,7 +33,7 @@
     "@pnpm/error": "1100.2.1",
     "@pnpm/resolving.jsr-specifier-parser": "1100.0.9",
     "@pnpm/types": "1102.1.1",
-    "@pnpm/workspace.project-manifest-reader": "1100.1.1",
+    "@pnpm/workspace.project-manifest-reader": "1100.1.2",
     "@pnpm/workspace.spec-parser": "1100.0.1",
     "ramda": "npm:@pnpm/ramda@0.28.1"
   },
@@ -41,9 +41,9 @@
     "@jest/globals": "30.4.1",
     "@pnpm/catalogs.config": "1100.0.9",
     "@pnpm/catalogs.types": "1100.0.1",
-    "@pnpm/hooks.pnpmfile": "1100.0.34",
-    "@pnpm/prepare": "1100.0.33",
-    "@pnpm/releasing.exportable-manifest": "1100.3.4",
+    "@pnpm/hooks.pnpmfile": "1100.0.35",
+    "@pnpm/prepare": "1100.0.35",
+    "@pnpm/releasing.exportable-manifest": "1100.3.6",
     "@types/cross-spawn": "^6.0.6",
     "@types/ramda": "0.32.0",
     "cross-spawn": "^7.0.6",