isolate-package 1.34.0 → 1.35.1

package/dist/isolate-bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { o as loadConfigFromFile, t as isolate, u as filterObjectUndefined } from "./isolate-DI3eUTci.mjs";
+import { o as loadConfigFromFile, t as isolate, u as filterObjectUndefined } from "./isolate-Bni_7Vjj.mjs";
 import { outdent } from "outdent";
 import console from "node:console";
 import meow from "meow";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isolate-package",
-  "version": "1.34.0",
+  "version": "1.35.1",
   "description": "Isolate monorepo packages to form a self-contained deployable unit",
   "keywords": [
     "ci",

package/src/lib/lockfile/helpers/generate-pnpm-lockfile.test.ts

@@ -303,6 +303,87 @@ describe("generatePnpmLockfile", () => {
     expect(writtenLockfile.packageExtensionsChecksum).toBe("abc123");
   });
 
+  it("should restore the catalogs snapshot after pruning (#198)", async () => {
+    const catalogs = {
+      default: {
+        lodash: { specifier: "^4.17.21", version: "4.17.21" },
+      },
+      utils: {
+        ramda: { specifier: "^0.30.0", version: "0.30.0" },
+      },
+    };
+    const lockfile = {
+      ...createMockLockfile(),
+      catalogs,
+    };
+    readWantedLockfile_v9.mockResolvedValue(lockfile as never);
+    getLockfileImporterId_v9.mockReturnValue("apps/my-app");
+
+    /** Simulate prune dropping the catalogs snapshot */
+    pruneLockfile_v9.mockImplementation((lf) => {
+      const result = { ...(lf as unknown as Record<string, unknown>) };
+      delete result.catalogs;
+      return result as never;
+    });
+
+    await generatePnpmLockfile({
+      workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/apps/my-app",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      internalDepPackageNames: ["shared"],
+      packagesRegistry: {
+        shared: {
+          absoluteDir: "/workspace/packages/shared",
+          rootRelativeDir: "packages/shared",
+          manifest: { name: "shared", version: "1.0.0" },
+        },
+      },
+      targetPackageManifest: { name: "my-app", version: "1.0.0" },
+      majorVersion: 9,
+      includeDevDependencies: false,
+    });
+
+    const writeCall = writeWantedLockfile_v9.mock.calls[0]!;
+    const writtenLockfile = writeCall[1] as {
+      catalogs?: Record<string, Record<string, unknown>>;
+    };
+
+    /**
+     * The catalogs snapshot is restored verbatim (like overrides), so it stays
+     * in sync with the importer specifiers and the verbatim pnpm-workspace.yaml
+     * copy.
+     */
+    expect(writtenLockfile.catalogs).toEqual(catalogs);
+  });
+
+  it("should not set catalogs when the source lockfile has none", async () => {
+    const lockfile = createMockLockfile();
+    readWantedLockfile_v9.mockResolvedValue(lockfile as never);
+    getLockfileImporterId_v9.mockReturnValue("apps/my-app");
+    pruneLockfile_v9.mockImplementation((lf) => lf as never);
+
+    await generatePnpmLockfile({
+      workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/apps/my-app",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      internalDepPackageNames: ["shared"],
+      packagesRegistry: {
+        shared: {
+          absoluteDir: "/workspace/packages/shared",
+          rootRelativeDir: "packages/shared",
+          manifest: { name: "shared", version: "1.0.0" },
+        },
+      },
+      targetPackageManifest: { name: "my-app", version: "1.0.0" },
+      majorVersion: 9,
+      includeDevDependencies: false,
+    });
+
+    const writeCall = writeWantedLockfile_v9.mock.calls[0]!;
+    const writtenLockfile = writeCall[1] as { catalogs?: unknown };
+    expect(writtenLockfile.catalogs).toBeUndefined();
+  });
+
   it("should include patchedDependencies in written lockfile", async () => {
     const lockfile = createMockLockfile();
     readWantedLockfile_v9.mockResolvedValue(lockfile as never);

package/src/lib/lockfile/helpers/generate-pnpm-lockfile.ts

@@ -18,6 +18,17 @@ import type { PackageManifest, PackagesRegistry, PatchFile } from "#/lib/types";
 import { getErrorMessage, isRushWorkspace } from "#/lib/utils";
 import { pnpmMapImporter } from "./pnpm-map-importer";
 
+/**
+ * A pnpm catalog snapshot as stored in the lockfile: a map of catalog name
+ * (e.g. "default") to a map of dependency name to its resolved entry. The
+ * pinned `@pnpm/lockfile-file` types predate catalogs, so we model the shape
+ * locally for the cast below.
+ */
+type CatalogSnapshots = Record<
+  string,
+  Record<string, { specifier: string; version: string }>
+>;
+
 export async function generatePnpmLockfile({
   workspaceRootDir,
   targetPackageDir,
@@ -167,6 +178,22 @@ export async function generatePnpmLockfile({
         lockfile.packageExtensionsChecksum;
     }
 
+    /**
+     * Pruning drops the catalogs snapshot, but the isolated importers keep
+     * their "catalog:" specifiers (for pnpm we don't resolve catalog deps in
+     * the manifest, since the output is itself a workspace). Restore it
+     * verbatim — like overrides above — so it stays in sync with the importer
+     * specifiers and the preserved pnpm-workspace.yaml catalog definitions,
+     * which are themselves copied verbatim (see issue #198). pnpm tolerates
+     * catalog entries that no retained importer references, so there is no need
+     * to narrow the snapshot.
+     */
+    const catalogs = (lockfile as { catalogs?: CatalogSnapshots }).catalogs;
+
+    if (catalogs) {
+      (prunedLockfile as { catalogs?: CatalogSnapshots }).catalogs = catalogs;
+    }
+
     /**
      * Use pre-computed patched dependencies with transformed paths. The paths
      * are already adapted by copyPatches to match the isolated directory

package/src/lib/manifest/adapt-target-package-manifest.ts

@@ -41,14 +41,26 @@ export async function adaptTargetPackageManifest({
     ? manifest
     : omit(manifest, ["devDependencies"]);
 
-  /** Resolve catalog dependencies before adapting internal deps */
-  const manifestWithResolvedCatalogs = {
-    ...inputManifest,
-    dependencies: await resolveCatalogDependencies(
-      inputManifest.dependencies,
-      workspaceRootDir,
-    ),
-  };
+  /**
+   * For PNPM (non-forceNpm) the isolated output is itself a pnpm workspace and
+   * the `pnpm-workspace.yaml` with its catalog definitions is preserved, so
+   * "catalog:" specifiers can be kept verbatim — just like "workspace:*". The
+   * lockfile importers also keep their "catalog:" specifiers, so resolving them
+   * here would create a mismatch and break `pnpm install --frozen-lockfile`
+   * (see issue #198). For other package managers (and forceNpm) the catalog is
+   * not available in the output, so we resolve the specifiers to versions.
+   */
+  const isPnpmWorkspaceOutput = packageManager.name === "pnpm" && !forceNpm;
+
+  const preparedManifest = isPnpmWorkspaceOutput
+    ? inputManifest
+    : {
+        ...inputManifest,
+        dependencies: await resolveCatalogDependencies(
+          inputManifest.dependencies,
+          workspaceRootDir,
+        ),
+      };
 
   const adaptedManifest =
     (packageManager.name === "pnpm" || packageManager.name === "bun") &&
@@ -59,13 +71,10 @@ export async function adaptTargetPackageManifest({
          * want to adopt workspace-level fields from the root package.json
          * (pnpm.overrides for PNPM, top-level overrides for Bun).
          */
-        await adoptPnpmFieldsFromRoot(
-          manifestWithResolvedCatalogs,
-          workspaceRootDir,
-        )
+        await adoptPnpmFieldsFromRoot(preparedManifest, workspaceRootDir)
       : /** For other package managers we replace the links to internal dependencies */
         adaptManifestInternalDeps({
-          manifest: manifestWithResolvedCatalogs,
+          manifest: preparedManifest,
           packagesRegistry,
         });
 

package/src/lib/manifest/helpers/adapt-internal-package-manifests.test.ts

@@ -20,6 +20,10 @@ vi.mock("./resolve-catalog-dependencies", () => ({
 
 const { usePackageManager } = vi.mocked(await import("#/lib/package-manager"));
 
+const { resolveCatalogDependencies } = vi.mocked(
+  await import("./resolve-catalog-dependencies"),
+);
+
 const { writeManifest } = vi.mocked(await import("../io"));
 
 const { adaptInternalPackageManifests } =
@@ -178,4 +182,69 @@ describe("adaptInternalPackageManifests", () => {
 
     expect(writtenManifest.devDependencies).toBeUndefined();
   });
+
+  it("should preserve catalog: specifiers for pnpm without resolving them (#198)", async () => {
+    const manifest: PackageManifest = {
+      name: "@repo/shared",
+      version: "1.0.0",
+      dependencies: {
+        "lodash.merge": "catalog:",
+      },
+    };
+
+    const packagesRegistry = createRegistry({
+      "@repo/shared": {
+        rootRelativeDir: "packages/shared",
+        manifest,
+      },
+    });
+
+    await adaptInternalPackageManifests({
+      internalPackageNames: ["@repo/shared"],
+      packagesRegistry,
+      isolateDir: "/output",
+      forceNpm: false,
+      workspaceRootDir: "/workspace",
+    });
+
+    /**
+     * For pnpm the isolated output is itself a workspace with its catalog
+     * definitions preserved, so the specifier is kept verbatim rather than
+     * resolved (which would desync it from the lockfile importers).
+     */
+    expect(resolveCatalogDependencies).not.toHaveBeenCalled();
+
+    const writtenManifest = writeManifest.mock.calls[0]![1];
+    expect(writtenManifest.dependencies).toEqual({
+      "lodash.merge": "catalog:",
+    });
+  });
+
+  it("should resolve catalog dependencies when forceNpm is enabled", async () => {
+    const manifest: PackageManifest = {
+      name: "@repo/shared",
+      version: "1.0.0",
+      dependencies: {
+        "lodash.merge": "catalog:",
+      },
+    };
+
+    const packagesRegistry = createRegistry({
+      "@repo/shared": {
+        rootRelativeDir: "packages/shared",
+        manifest,
+      },
+    });
+
+    await adaptInternalPackageManifests({
+      internalPackageNames: ["@repo/shared"],
+      packagesRegistry,
+      isolateDir: "/output",
+      forceNpm: true,
+      workspaceRootDir: "/workspace",
+    });
+
+    /** With forceNpm the catalog is not available in the output, so resolve. */
+    expect(resolveCatalogDependencies).toHaveBeenCalledOnce();
+  });
 });

package/src/lib/manifest/helpers/adapt-internal-package-manifests.ts

@@ -27,6 +27,15 @@ export async function adaptInternalPackageManifests({
 }) {
   const packageManager = usePackageManager();
 
+  /**
+   * For PNPM (non-forceNpm) the isolated output is itself a pnpm workspace with
+   * its `pnpm-workspace.yaml` catalog definitions preserved, so "catalog:"
+   * specifiers are kept verbatim to stay in sync with the lockfile importers
+   * (see issue #198). For other package managers the catalog is not available
+   * in the output, so we resolve the specifiers to versions.
+   */
+  const isPnpmWorkspaceOutput = packageManager.name === "pnpm" && !forceNpm;
+
   await Promise.all(
     internalPackageNames.map(async (packageName) => {
       const { manifest, rootRelativeDir } = got(packagesRegistry, packageName);
@@ -45,14 +54,15 @@ export async function adaptInternalPackageManifests({
         strippedManifest.scripts = omit(strippedManifest.scripts, ["prepare"]);
       }
 
-      /** Resolve catalog dependencies before adapting internal deps */
-      const manifestWithResolvedCatalogs = {
-        ...strippedManifest,
-        dependencies: await resolveCatalogDependencies(
-          strippedManifest.dependencies,
-          workspaceRootDir,
-        ),
-      };
+      const preparedManifest = isPnpmWorkspaceOutput
+        ? strippedManifest
+        : {
+            ...strippedManifest,
+            dependencies: await resolveCatalogDependencies(
+              strippedManifest.dependencies,
+              workspaceRootDir,
+            ),
+          };
 
       const outputManifest =
         (packageManager.name === "pnpm" || packageManager.name === "bun") &&
@@ -61,10 +71,10 @@ export async function adaptInternalPackageManifests({
              * For PNPM and Bun the output itself is a workspace so we can preserve
              * the specifiers with "workspace:*" in the output manifest.
              */
-            manifestWithResolvedCatalogs
+            preparedManifest
           : /** For other package managers we replace the links to internal dependencies */
             adaptManifestInternalDeps({
-              manifest: manifestWithResolvedCatalogs,
+              manifest: preparedManifest,
               packagesRegistry,
               parentRootRelativeDir: rootRelativeDir,
             });

package/src/lib/patches/copy-patches.test.ts

@@ -653,4 +653,124 @@ describe("copyPatches", () => {
     expect(reachable!.has("@react-pdf/renderer")).toBe(true);
     expect(reachable!.has("@react-pdf/render")).toBe(true);
   });
+
+  it("should read the patch hash from the pnpm 11 string lockfile format (regression: issue #201)", async () => {
+    /**
+     * pnpm 11 simplified the lockfile `patchedDependencies` format from
+     * `Record<string, { path, hash }>` to `Record<string, string>` (selector to
+     * hash). The hash must be read from the bare string, otherwise it ends up
+     * empty and pnpm rejects the isolated install with
+     * ERR_PNPM_LOCKFILE_CONFIG_MISMATCH.
+     */
+    const targetManifest: PackageManifest = {
+      name: "test",
+      version: "1.0.0",
+      dependencies: { lodash: "^4.0.0" },
+    };
+
+    readTypedYamlSync.mockReturnValue({
+      patchedDependencies: {
+        "lodash@4.17.21": "patches/lodash.patch",
+      },
+    });
+    readTypedJson.mockResolvedValue({
+      name: "root",
+      version: "1.0.0",
+    } as PackageManifest);
+
+    filterPatchedDependencies.mockReturnValue({
+      "lodash@4.17.21": "patches/lodash.patch",
+    });
+
+    fs.existsSync.mockReturnValue(true);
+
+    usePackageManager.mockReturnValue({
+      name: "pnpm",
+      majorVersion: 9,
+      version: "9.0.0",
+      packageManagerString: "pnpm@9.0.0",
+    });
+
+    readWantedLockfile_v9.mockResolvedValue({
+      lockfileVersion: "9.0",
+      patchedDependencies: {
+        "lodash@4.17.21": "sha256-abc123",
+      },
+    } as unknown as Awaited<ReturnType<typeof readWantedLockfile_v9>>);
+
+    const result = await copyPatches({
+      workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/packages/test",
+      internalDepPackageNames: [],
+      targetPackageManifest: targetManifest,
+      isolateDir: "/workspace/isolate",
+      packagesRegistry: {},
+      includeDevDependencies: false,
+    });
+
+    expect(result).toEqual({
+      "lodash@4.17.21": {
+        path: "patches/lodash.patch",
+        hash: "sha256-abc123",
+      },
+    });
+  });
+
+  it("should read the patch hash from the pnpm <=10 object lockfile format (regression: issue #201)", async () => {
+    const targetManifest: PackageManifest = {
+      name: "test",
+      version: "1.0.0",
+      dependencies: { lodash: "^4.0.0" },
+    };
+
+    readTypedYamlSync.mockReturnValue({
+      patchedDependencies: {
+        "lodash@4.17.21": "patches/lodash.patch",
+      },
+    });
+    readTypedJson.mockResolvedValue({
+      name: "root",
+      version: "1.0.0",
+    } as PackageManifest);
+
+    filterPatchedDependencies.mockReturnValue({
+      "lodash@4.17.21": "patches/lodash.patch",
+    });
+
+    fs.existsSync.mockReturnValue(true);
+
+    usePackageManager.mockReturnValue({
+      name: "pnpm",
+      majorVersion: 9,
+      version: "9.0.0",
+      packageManagerString: "pnpm@9.0.0",
+    });
+
+    readWantedLockfile_v9.mockResolvedValue({
+      lockfileVersion: "9.0",
+      patchedDependencies: {
+        "lodash@4.17.21": {
+          path: "patches/lodash.patch",
+          hash: "sha256-def456",
+        },
+      },
+    } as unknown as Awaited<ReturnType<typeof readWantedLockfile_v9>>);
+
+    const result = await copyPatches({
+      workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/packages/test",
+      internalDepPackageNames: [],
+      targetPackageManifest: targetManifest,
+      isolateDir: "/workspace/isolate",
+      packagesRegistry: {},
+      includeDevDependencies: false,
+    });
+
+    expect(result).toEqual({
+      "lodash@4.17.21": {
+        path: "patches/lodash.patch",
+        hash: "sha256-def456",
+      },
+    });
+  });
 });

package/src/lib/patches/copy-patches.ts

@@ -177,9 +177,17 @@ export async function copyPatches({
     await fs.copy(sourcePatchPath, targetPatchPath);
     log.debug(`Copied patch for ${packageSpec}: ${patchPath}`);
 
-    /** Get the hash from the original lockfile, or use empty string if not found */
+    /**
+     * Get the hash from the original lockfile, or use empty string if not
+     * found. pnpm 11 simplified the lockfile `patchedDependencies` format from
+     * `Record<string, { path, hash }>` to `Record<string, string>` (selector to
+     * hash), so the entry may be a bare hash string. See issue #201.
+     */
     const originalPatchFile = lockfilePatchedDependencies?.[packageSpec];
-    const hash = originalPatchFile?.hash ?? "";
+    const hash =
+      typeof originalPatchFile === "string"
+        ? originalPatchFile
+        : (originalPatchFile?.hash ?? "");
 
     if (packageManagerName === "pnpm" && !hash) {
       log.warn(`No hash found for patch ${packageSpec} in lockfile`);
@@ -201,10 +209,14 @@ export async function copyPatches({
 /**
  * Read the patchedDependencies from the original lockfile to get the hashes.
  * Since the file content is the same after copying, the hash remains valid.
+ *
+ * The value type is `PatchFile | string` because pnpm 11 simplified the format
+ * to store the bare hash string per selector, while pnpm <=10 stored a
+ * `{ path, hash }` object. See issue #201.
  */
 async function readLockfilePatchedDependencies(
   workspaceRootDir: string,
-): Promise<Record<string, PatchFile> | undefined> {
+): Promise<Record<string, PatchFile | string> | undefined> {
   try {
     const { majorVersion } = usePackageManager();
     const useVersion9 = majorVersion >= 9;