isolate-package 1.33.0 → 1.34.0

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

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import type { PackageManifest, PnpmSettings } from "~/lib/types";
+import type { PackageManifest, PnpmSettings } from "#/lib/types";
 import { copyPatches } from "./copy-patches";
 
 /** Mock fs-extra */
@@ -12,33 +12,50 @@ vi.mock("fs-extra", () => ({
 }));
 
 /** Mock the utils */
-vi.mock("~/lib/utils", () => ({
+vi.mock("#/lib/utils", () => ({
   filterPatchedDependencies: vi.fn(),
   getIsolateRelativeLogPath: vi.fn((p: string) => p),
+  getPackageName: vi.fn((spec: string) => {
+    if (spec.startsWith("@")) {
+      const parts = spec.split("@");
+      return `@${parts[1] ?? ""}`;
+    }
+    return spec.split("@")[0] ?? "";
+  }),
   getRootRelativeLogPath: vi.fn((p: string) => p),
   isRushWorkspace: vi.fn(() => false),
   readTypedJson: vi.fn(),
+  readTypedJsonSync: vi.fn(),
   readTypedYamlSync: vi.fn(),
 }));
 
 /** Mock the package manager */
-vi.mock("~/lib/package-manager", () => ({
+vi.mock("#/lib/package-manager", () => ({
   usePackageManager: vi.fn(() => ({ name: "pnpm", majorVersion: 9 })),
 }));
 
 /** Mock the pnpm lockfile readers */
 vi.mock("pnpm_lockfile_file_v8", () => ({
   readWantedLockfile: vi.fn(() => Promise.resolve(null)),
+  getLockfileImporterId: vi.fn(
+    (root: string, dir: string) => dir.replace(`${root}/`, "") || ".",
+  ),
 }));
 
 vi.mock("pnpm_lockfile_file_v9", () => ({
   readWantedLockfile: vi.fn(() => Promise.resolve(null)),
+  getLockfileImporterId: vi.fn(
+    (root: string, dir: string) => dir.replace(`${root}/`, "") || ".",
+  ),
 }));
 
 const fs = vi.mocked((await import("fs-extra")).default);
 const { filterPatchedDependencies, readTypedJson, readTypedYamlSync } =
-  vi.mocked(await import("~/lib/utils"));
-const { usePackageManager } = vi.mocked(await import("~/lib/package-manager"));
+  vi.mocked(await import("#/lib/utils"));
+const { usePackageManager } = vi.mocked(await import("#/lib/package-manager"));
+const { readWantedLockfile: readWantedLockfile_v9 } = vi.mocked(
+  await import("pnpm_lockfile_file_v9"),
+);
 
 describe("copyPatches", () => {
   beforeEach(() => {
@@ -49,14 +66,6 @@ describe("copyPatches", () => {
     vi.restoreAllMocks();
   });
 
-  const mockJsonSettings = (settings: PnpmSettings | undefined) => {
-    readTypedJson.mockResolvedValue({
-      name: "root",
-      version: "1.0.0",
-      pnpm: settings,
-    });
-  };
-
   it("should return empty object when workspace root package.json cannot be read", async () => {
     readTypedYamlSync.mockImplementation(() => {
       throw new Error("File not found");
@@ -65,6 +74,8 @@ describe("copyPatches", () => {
 
     const result = await copyPatches({
       workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/packages/test",
+      internalDepPackageNames: [],
       targetPackageManifest: { name: "test", version: "1.0.0" },
       isolateDir: "/workspace/isolate",
       packagesRegistry: {},
@@ -126,6 +137,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: { name: "test", version: "1.0.0" },
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -146,6 +159,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: { name: "test", version: "1.0.0" },
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -176,6 +191,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -214,6 +231,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -256,6 +275,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -287,6 +308,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -321,6 +344,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -364,6 +389,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -409,6 +436,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -456,6 +485,8 @@ describe("copyPatches", () => {
 
     const result = await copyPatches({
       workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/packages/test",
+      internalDepPackageNames: [],
       targetPackageManifest: targetManifest,
       isolateDir: "/workspace/isolate",
       packagesRegistry: {},
@@ -509,6 +540,8 @@ describe("copyPatches", () => {
 
     const result = await copyPatches({
       workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/packages/test",
+      internalDepPackageNames: [],
       targetPackageManifest: consumerManifest,
       isolateDir: "/workspace/isolate",
       packagesRegistry: {
@@ -536,4 +569,88 @@ describe("copyPatches", () => {
     expect(reachable!.has("firebase-package")).toBe(true);
     expect(reachable!.has("tslib")).toBe(true);
   });
+
+  it("should pick up deep external-to-external transitives from the pnpm lockfile (regression: issue #167 follow-up)", async () => {
+    /**
+     * Target depends on `@react-pdf/renderer` (external). The patched
+     * `@react-pdf/render` is only a transitive of `@react-pdf/renderer`. The
+     * manifest walker can't see it because it can't open external manifests,
+     * so the lockfile walker has to surface it.
+     */
+    const targetManifest: PackageManifest = {
+      name: "consumer",
+      version: "1.0.0",
+      dependencies: { "@react-pdf/renderer": "^4.0.0" },
+    };
+
+    readTypedYamlSync.mockReturnValue({
+      patchedDependencies: {
+        "@react-pdf/render@4.3.0": "patches/@react-pdf__render@4.3.0.patch",
+      },
+    });
+    readTypedJson.mockResolvedValue({
+      name: "root",
+      version: "1.0.0",
+    } as PackageManifest);
+
+    filterPatchedDependencies.mockReturnValue({
+      "@react-pdf/render@4.3.0": "patches/@react-pdf__render@4.3.0.patch",
+    });
+
+    fs.existsSync.mockReturnValue(true);
+
+    usePackageManager.mockReturnValue({
+      name: "pnpm",
+      majorVersion: 9,
+      version: "9.0.0",
+      packageManagerString: "pnpm@9.0.0",
+    });
+
+    /**
+     * Fake v9 lockfile: target importer depends on @react-pdf/renderer, which
+     * has @react-pdf/render as its only resolved dep.
+     */
+    readWantedLockfile_v9.mockResolvedValue({
+      lockfileVersion: "9.0",
+      importers: {
+        "packages/consumer": {
+          specifiers: { "@react-pdf/renderer": "^4.0.0" },
+          dependencies: { "@react-pdf/renderer": "4.0.0" },
+        },
+      },
+      packages: {
+        "@react-pdf/renderer@4.0.0": {
+          resolution: { integrity: "sha512-x" },
+          dependencies: { "@react-pdf/render": "4.3.0" },
+        },
+        "@react-pdf/render@4.3.0": {
+          resolution: { integrity: "sha512-y" },
+        },
+      },
+    } as unknown as Awaited<ReturnType<typeof readWantedLockfile_v9>>);
+
+    const result = await copyPatches({
+      workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/packages/consumer",
+      internalDepPackageNames: [],
+      targetPackageManifest: targetManifest,
+      isolateDir: "/workspace/isolate",
+      packagesRegistry: {},
+      includeDevDependencies: false,
+    });
+
+    expect(result).toEqual({
+      "@react-pdf/render@4.3.0": {
+        path: "patches/@react-pdf__render@4.3.0.patch",
+        hash: "",
+      },
+    });
+
+    const filterCall = filterPatchedDependencies.mock.calls[0]?.[0];
+    expect(filterCall).toBeDefined();
+    const reachable = filterCall!.reachableDependencyNames;
+    expect(reachable).toBeInstanceOf(Set);
+    expect(reachable!.has("@react-pdf/renderer")).toBe(true);
+    expect(reachable!.has("@react-pdf/render")).toBe(true);
+  });
 });

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

@@ -2,39 +2,45 @@ import fs from "fs-extra";
 import path from "node:path";
 import { readWantedLockfile as readWantedLockfile_v8 } from "pnpm_lockfile_file_v8";
 import { readWantedLockfile as readWantedLockfile_v9 } from "pnpm_lockfile_file_v9";
-import { useLogger } from "~/lib/logger";
-import { usePackageManager } from "~/lib/package-manager";
-import { collectReachablePackageNames } from "~/lib/registry";
+import { useLogger } from "#/lib/logger";
+import { usePackageManager } from "#/lib/package-manager";
+import { collectReachablePackageNames } from "#/lib/registry";
 import type {
   PackageManifest,
   PackagesRegistry,
   PatchFile,
   PnpmSettings,
-} from "~/lib/types";
+} from "#/lib/types";
 import {
   filterPatchedDependencies,
   getRootRelativeLogPath,
   isRushWorkspace,
   readTypedJson,
   readTypedYamlSync,
-} from "~/lib/utils";
+} from "#/lib/utils";
+import { collectInstalledNamesFromBunLockfile } from "./collect-installed-names-bun";
+import { collectInstalledNamesFromPnpmLockfile } from "./collect-installed-names-pnpm";
 
 export async function copyPatches({
   workspaceRootDir,
+  targetPackageDir,
   targetPackageManifest,
   packagesRegistry,
+  internalDepPackageNames,
   isolateDir,
   includeDevDependencies,
 }: {
   workspaceRootDir: string;
+  targetPackageDir: string;
   targetPackageManifest: PackageManifest;
   packagesRegistry: PackagesRegistry;
+  internalDepPackageNames: string[];
   isolateDir: string;
   includeDevDependencies: boolean;
 }): Promise<Record<string, PatchFile>> {
   const log = useLogger();
 
-  const { name: packageManagerName } = usePackageManager();
+  const { name: packageManagerName, majorVersion } = usePackageManager();
 
   let patchedDependencies: Record<string, string> | undefined;
 
@@ -44,9 +50,9 @@ export async function copyPatches({
    */
   if (packageManagerName === "pnpm") {
     try {
-      const pnpmSettings = readTypedYamlSync<PnpmSettings>(
+      const pnpmSettings = readTypedYamlSync(
         path.join(workspaceRootDir, "pnpm-workspace.yaml"),
-      );
+      ) as PnpmSettings | undefined;
       patchedDependencies = pnpmSettings?.patchedDependencies;
     } catch (error) {
       log.warn(
@@ -67,9 +73,9 @@ export async function copyPatches({
     }
 
     try {
-      const workspaceRootManifest = await readTypedJson<PackageManifest>(
+      const workspaceRootManifest = (await readTypedJson(
         path.join(workspaceRootDir, "package.json"),
-      );
+      )) as PackageManifest;
       /** PNPM stores patches under pnpm.patchedDependencies, Bun at the top level */
       patchedDependencies =
         workspaceRootManifest?.pnpm?.patchedDependencies ??
@@ -102,6 +108,37 @@ export async function copyPatches({
     includeDevDependencies,
   });
 
+  /**
+   * Manifest-based reachability misses external→external transitives because
+   * external manifests aren't loaded here. Walk the package-manager's
+   * lockfile to also pick up those names, so a patch for a deeply-nested
+   * external dep (e.g. `@react-pdf/render` reached via `@react-pdf/renderer`)
+   * survives isolation.
+   */
+  const lockfileInstalledNames =
+    packageManagerName === "pnpm"
+      ? await collectInstalledNamesFromPnpmLockfile({
+          workspaceRootDir,
+          targetPackageDir,
+          internalDepPackageNames,
+          packagesRegistry,
+          majorVersion,
+          includeDevDependencies,
+        })
+      : packageManagerName === "bun"
+        ? collectInstalledNamesFromBunLockfile({
+            workspaceRootDir,
+            targetPackageDir,
+            internalDepPackageNames,
+            packagesRegistry,
+            includeDevDependencies,
+          })
+        : new Set<string>();
+
+  for (const name of lockfileInstalledNames) {
+    reachableDependencyNames.add(name);
+  }
+
   const filteredPatches = filterPatchedDependencies({
     patchedDependencies,
     targetPackageManifest,

package/src/lib/patches/write-isolate-pnpm-workspace.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { PatchFile } from "~/lib/types";
+import type { PatchFile } from "#/lib/types";
 import { writeIsolatePnpmWorkspace } from "./write-isolate-pnpm-workspace";
 
 vi.mock("fs-extra", () => ({
@@ -8,14 +8,14 @@ vi.mock("fs-extra", () => ({
   },
 }));
 
-vi.mock("~/lib/utils", () => ({
+vi.mock("#/lib/utils", () => ({
   readTypedYamlSync: vi.fn(),
   writeTypedYamlSync: vi.fn(),
 }));
 
 const fs = vi.mocked((await import("fs-extra")).default);
 const { readTypedYamlSync, writeTypedYamlSync } = vi.mocked(
-  await import("~/lib/utils"),
+  await import("#/lib/utils"),
 );
 
 const workspaceRootDir = "/workspace";
@@ -139,6 +139,86 @@ describe("writeIsolatePnpmWorkspace", () => {
     );
   });
 
+  /**
+   * Regression test for issue #189: pnpm 11 expresses the build-script policy
+   * via `allowBuilds` in pnpm-workspace.yaml (and removes the older
+   * `pnpm.onlyBuiltDependencies` / `ignoredBuiltDependencies` fields from
+   * package.json). The verbatim copy must carry that field — along with other
+   * workspace-level settings like `minimumReleaseAge` — into the isolate
+   * output so downstream `pnpm install` honors the same policy.
+   */
+  it("preserves pnpm 11 workspace settings (allowBuilds, minimumReleaseAge) when no patches are involved", () => {
+    readTypedYamlSync.mockReturnValue({
+      packages: ["apps/*", "packages/*"],
+      allowBuilds: {
+        puppeteer: true,
+        esbuild: true,
+      },
+      minimumReleaseAge: 10_080,
+    });
+
+    writeIsolatePnpmWorkspace({
+      workspaceRootDir,
+      isolateDir,
+      copiedPatches: {},
+    });
+
+    /**
+     * With no patchedDependencies in the source yaml, the file is copied
+     * verbatim — preserving `allowBuilds` and any other top-level settings.
+     */
+    expect(writeTypedYamlSync).not.toHaveBeenCalled();
+    expect(fs.copyFileSync).toHaveBeenCalledWith(
+      "/workspace/pnpm-workspace.yaml",
+      "/workspace/isolate/pnpm-workspace.yaml",
+    );
+  });
+
+  /**
+   * When patches are being filtered, the rewrite path must still carry
+   * `allowBuilds` into the output yaml — otherwise pnpm 11's build-script
+   * policy is silently dropped.
+   */
+  it("preserves allowBuilds when rewriting to filter patchedDependencies", () => {
+    readTypedYamlSync.mockReturnValue({
+      packages: ["apps/*", "packages/*"],
+      allowBuilds: {
+        puppeteer: true,
+      },
+      patchedDependencies: {
+        "lodash@4.17.21": "patches/lodash@4.17.21.patch",
+        "axios@1.6.0": "patches/axios@1.6.0.patch",
+      },
+    });
+
+    const copiedPatches: Record<string, PatchFile> = {
+      "lodash@4.17.21": {
+        path: "patches/lodash@4.17.21.patch",
+        hash: "abc",
+      },
+    };
+
+    writeIsolatePnpmWorkspace({
+      workspaceRootDir,
+      isolateDir,
+      copiedPatches,
+    });
+
+    expect(fs.copyFileSync).not.toHaveBeenCalled();
+    expect(writeTypedYamlSync).toHaveBeenCalledWith(
+      "/workspace/isolate/pnpm-workspace.yaml",
+      {
+        packages: ["apps/*", "packages/*"],
+        allowBuilds: {
+          puppeteer: true,
+        },
+        patchedDependencies: {
+          "lodash@4.17.21": "patches/lodash@4.17.21.patch",
+        },
+      },
+    );
+  });
+
   it("copies verbatim when every patch is kept (preserving comments and order)", () => {
     readTypedYamlSync.mockReturnValue({
       packages: ["packages/*"],

package/src/lib/patches/write-isolate-pnpm-workspace.ts

@@ -1,8 +1,8 @@
 import fs from "fs-extra";
 import path from "node:path";
-import { useLogger } from "~/lib/logger";
-import type { PatchFile, PnpmSettings } from "~/lib/types";
-import { readTypedYamlSync, writeTypedYamlSync } from "~/lib/utils";
+import { useLogger } from "#/lib/logger";
+import type { PatchFile, PnpmSettings } from "#/lib/types";
+import { readTypedYamlSync, writeTypedYamlSync } from "#/lib/utils";
 
 /**
  * Copy `pnpm-workspace.yaml` from the workspace root to the isolate directory,
@@ -39,7 +39,7 @@ export function writeIsolatePnpmWorkspace({
   let settings: PnpmSettings | undefined;
 
   try {
-    settings = readTypedYamlSync<PnpmSettings>(sourcePath);
+    settings = readTypedYamlSync(sourcePath) as PnpmSettings | undefined;
   } catch (error) {
     log.warn(
       `Could not read pnpm-workspace.yaml, falling back to verbatim copy: ${error instanceof Error ? error.message : String(error)}`,

package/src/lib/registry/collect-reachable-package-names.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import type { PackageManifest, PackagesRegistry } from "~/lib/types";
+import type { PackageManifest, PackagesRegistry } from "#/lib/types";
 import { collectReachablePackageNames } from "./collect-reachable-package-names";
 
 function entry(manifest: PackageManifest) {

package/src/lib/registry/create-packages-registry.ts

@@ -28,38 +28,41 @@ export async function createPackagesRegistry(
     workspaceRootDir,
   );
 
-  const registry: PackagesRegistry = (
-    await Promise.all(
-      allPackages.map(async (rootRelativeDir) => {
-        const absoluteDir = path.join(workspaceRootDir, rootRelativeDir);
-        const manifestPath = path.join(absoluteDir, "package.json");
+  const entries = await Promise.all(
+    allPackages.map(async (rootRelativeDir) => {
+      const absoluteDir = path.join(workspaceRootDir, rootRelativeDir);
+      const manifestPath = path.join(absoluteDir, "package.json");
 
-        if (!fs.existsSync(manifestPath)) {
-          log.warn(
-            `Ignoring directory ${rootRelativeDir} because it does not contain a package.json file`,
-          );
-          return;
-        } else {
-          log.debug(`Registering package ${rootRelativeDir}`);
+      if (!fs.existsSync(manifestPath)) {
+        log.warn(
+          `Ignoring directory ${rootRelativeDir} because it does not contain a package.json file`,
+        );
+        return null;
+      }
 
-          const manifest = await readTypedJson<PackageManifest>(
-            path.join(absoluteDir, "package.json"),
-          );
+      log.debug(`Registering package ${rootRelativeDir}`);
 
-          return {
-            manifest,
-            rootRelativeDir,
-            absoluteDir,
-          };
-        }
-      }),
-    )
-  ).reduce<PackagesRegistry>((acc, info) => {
-    if (info) {
-      acc[info.manifest.name] = info;
-    }
-    return acc;
-  }, {});
+      const manifest = (await readTypedJson(
+        path.join(absoluteDir, "package.json"),
+      )) as PackageManifest;
+
+      return {
+        manifest,
+        rootRelativeDir,
+        absoluteDir,
+      };
+    }),
+  );
+
+  const registry: PackagesRegistry = entries.reduce<PackagesRegistry>(
+    (acc, info) => {
+      if (info) {
+        acc[info.manifest.name] = info;
+      }
+      return acc;
+    },
+    {},
+  );
 
   return registry;
 }
@@ -73,9 +76,9 @@ function listWorkspacePackages(
   workspaceRootDir: string,
 ) {
   if (isRushWorkspace(workspaceRootDir)) {
-    const rushConfig = readTypedJsonSync<RushConfig>(
+    const rushConfig = readTypedJsonSync(
       path.join(workspaceRootDir, "rush.json"),
-    );
+    ) as RushConfig;
 
     return rushConfig.projects.map(({ projectFolder }) => projectFolder);
   } else {

package/src/lib/registry/helpers/find-packages-globs.ts

@@ -13,16 +13,16 @@ import {
  * monorepo. This configuration is dependent on the package manager used, and I
  * don't know if we're covering all cases yet...
  */
-export function findPackagesGlobs(workspaceRootDir: string) {
+export function findPackagesGlobs(workspaceRootDir: string): string[] {
   const log = useLogger();
 
   const packageManager = usePackageManager();
 
   switch (packageManager.name) {
     case "pnpm": {
-      const workspaceConfig = readTypedYamlSync<{ packages: string[] }>(
+      const workspaceConfig = readTypedYamlSync(
         path.join(workspaceRootDir, "pnpm-workspace.yaml"),
-      );
+      ) as { packages: string[] } | undefined;
 
       if (!workspaceConfig) {
         throw new Error(
@@ -48,9 +48,9 @@ export function findPackagesGlobs(workspaceRootDir: string) {
         "package.json",
       );
 
-      const { workspaces } = readTypedJsonSync<{ workspaces: string[] }>(
-        workspaceRootManifestPath,
-      );
+      const { workspaces } = readTypedJsonSync(workspaceRootManifestPath) as {
+        workspaces: string[];
+      };
 
       if (!workspaces) {
         throw new Error(
@@ -60,21 +60,25 @@ export function findPackagesGlobs(workspaceRootDir: string) {
 
       if (Array.isArray(workspaces)) {
         return workspaces;
-      } else {
-        /**
-         * For Yarn, workspaces could be defined as an object with { packages:
-         * [], nohoist: [] }. See
-         * https://classic.yarnpkg.com/blog/2018/02/15/nohoist/
-         */
-        const workspacesObject = workspaces as { packages?: string[] };
+      }
 
-        assert(
-          workspacesObject.packages,
-          "workspaces.packages must be an array",
-        );
+      /**
+       * For Yarn, workspaces could be defined as an object with { packages: [],
+       * nohoist: [] }. See
+       * https://classic.yarnpkg.com/blog/2018/02/15/nohoist/
+       */
+      const workspacesObject = workspaces as { packages?: string[] };
 
-        return workspacesObject.packages;
-      }
+      assert(
+        Array.isArray(workspacesObject.packages),
+        "workspaces.packages must be an array",
+      );
+
+      return workspacesObject.packages;
     }
+    default:
+      throw new Error(
+        `Unsupported package manager: ${packageManager.name as string}`,
+      );
   }
 }