isolate-package 1.12.2 → 1.13.0-0

package/dist/index.mjs

@@ -1,12 +1,13 @@
 // src/isolate.ts
-import fs15 from "fs-extra";
+import fs16 from "fs-extra";
 import assert6 from "node:assert";
-import path17 from "node:path";
+import path19 from "node:path";
+import { unique } from "remeda";
 
 // src/lib/config.ts
-import fs5 from "fs-extra";
+import fs6 from "fs-extra";
 import assert from "node:assert";
-import path2 from "node:path";
+import path3 from "node:path";
 import { isEmpty } from "remeda";
 
 // src/lib/logger.ts
@@ -82,12 +83,12 @@ function toErrorWithMessage(maybeError) {
 }
 
 // src/lib/utils/get-relative-path.ts
-function getRootRelativePath(path18, rootPath) {
-  const strippedPath = path18.replace(rootPath, "");
+function getRootRelativePath(path20, rootPath) {
+  const strippedPath = path20.replace(rootPath, "");
   return strippedPath.startsWith("/") ? `(root)${strippedPath}` : `(root)/${strippedPath}`;
 }
-function getIsolateRelativePath(path18, isolatePath) {
-  const strippedPath = path18.replace(isolatePath, "");
+function getIsolateRelativePath(path20, isolatePath) {
+  const strippedPath = path20.replace(isolatePath, "");
   return strippedPath.startsWith("/") ? `(isolate)${strippedPath}` : `(isolate)/${strippedPath}`;
 }
 
@@ -97,12 +98,19 @@ function inspectValue(value) {
   return inspect(value, false, 16, true);
 }
 
+// src/lib/utils/is-rush-workspace.ts
+import fs from "node:fs";
+import path from "node:path";
+function isRushWorkspace(workspaceRootDir) {
+  return fs.existsSync(path.join(workspaceRootDir, "rush.json"));
+}
+
 // src/lib/utils/json.ts
-import fs from "fs-extra";
+import fs2 from "fs-extra";
 import stripJsonComments from "strip-json-comments";
 function readTypedJsonSync(filePath) {
   try {
-    const rawContent = fs.readFileSync(filePath, "utf-8");
+    const rawContent = fs2.readFileSync(filePath, "utf-8");
     const data = JSON.parse(
       stripJsonComments(rawContent, { trailingCommas: true })
     );
@@ -115,7 +123,7 @@ function readTypedJsonSync(filePath) {
 }
 async function readTypedJson(filePath) {
   try {
-    const rawContent = await fs.readFile(filePath, "utf-8");
+    const rawContent = await fs2.readFile(filePath, "utf-8");
     const data = JSON.parse(
       stripJsonComments(rawContent, { trailingCommas: true })
     );
@@ -129,8 +137,8 @@ async function readTypedJson(filePath) {
 
 // src/lib/utils/pack.ts
 import { exec } from "node:child_process";
-import fs2 from "node:fs";
-import path from "node:path";
+import fs3 from "node:fs";
+import path2 from "node:path";
 async function pack(srcDir, dstDir, usePnpmPack) {
   const execOptions = {
     maxBuffer: 10 * 1024 * 1024
@@ -162,9 +170,9 @@ async function pack(srcDir, dstDir, usePnpmPack) {
       }
     );
   });
-  const fileName = path.basename(stdout.trim());
-  const filePath = path.join(dstDir, fileName);
-  if (!fs2.existsSync(filePath)) {
+  const fileName = path2.basename(stdout.trim());
+  const filePath = path2.join(dstDir, fileName);
+  if (!fs3.existsSync(filePath)) {
     log.error(
       `The response from pack could not be resolved to an existing file: ${filePath}`
     );
@@ -176,21 +184,21 @@ async function pack(srcDir, dstDir, usePnpmPack) {
 }
 
 // src/lib/utils/unpack.ts
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 import tar from "tar-fs";
 import { createGunzip } from "zlib";
 async function unpack(filePath, unpackDir) {
   await new Promise((resolve, reject) => {
-    fs3.createReadStream(filePath).pipe(createGunzip()).pipe(tar.extract(unpackDir)).on("finish", () => resolve()).on("error", (err) => reject(err));
+    fs4.createReadStream(filePath).pipe(createGunzip()).pipe(tar.extract(unpackDir)).on("finish", () => resolve()).on("error", (err) => reject(err));
   });
 }
 
 // src/lib/utils/yaml.ts
-import fs4 from "fs-extra";
+import fs5 from "fs-extra";
 import yaml from "yaml";
 function readTypedYamlSync(filePath) {
   try {
-    const rawContent = fs4.readFileSync(filePath, "utf-8");
+    const rawContent = fs5.readFileSync(filePath, "utf-8");
     const data = yaml.parse(rawContent);
     return data;
   } catch (err) {
@@ -199,6 +207,9 @@ function readTypedYamlSync(filePath) {
     );
   }
 }
+function writeTypedYamlSync(filePath, content) {
+  fs5.writeFileSync(filePath, yaml.stringify(content), "utf-8");
+}
 
 // src/lib/config.ts
 var configDefaults = {
@@ -238,12 +249,12 @@ function resolveConfig() {
   }
   setLogLevel(process.env.DEBUG_ISOLATE_CONFIG ? "debug" : "info");
   const log = useLogger();
-  const configFilePath = path2.join(process.cwd(), CONFIG_FILE_NAME);
+  const configFilePath = path3.join(process.cwd(), CONFIG_FILE_NAME);
   if (_user_defined_config) {
     log.debug(`Using user defined config:`, inspectValue(_user_defined_config));
   } else {
     log.debug(`Attempting to load config from ${configFilePath}`);
-    _user_defined_config = fs5.existsSync(configFilePath) ? readTypedJsonSync(configFilePath) : {};
+    _user_defined_config = fs6.existsSync(configFilePath) ? readTypedJsonSync(configFilePath) : {};
   }
   const foreignKeys = Object.keys(_user_defined_config).filter(
     (key) => !validConfigKeys.includes(key)
@@ -261,10 +272,13 @@ function resolveConfig() {
   return config;
 }
 
+// src/lib/package-manager/index.ts
+import path6 from "node:path";
+
 // src/lib/package-manager/helpers/infer-from-files.ts
-import fs6 from "fs-extra";
+import fs7 from "fs-extra";
 import { execSync } from "node:child_process";
-import path3 from "node:path";
+import path4 from "node:path";
 
 // src/lib/package-manager/names.ts
 var supportedPackageManagerNames = ["pnpm", "yarn", "npm"];
@@ -283,11 +297,11 @@ function getLockfileFileName(name) {
 function inferFromFiles(workspaceRoot) {
   for (const name of supportedPackageManagerNames) {
     const lockfileName = getLockfileFileName(name);
-    if (fs6.existsSync(path3.join(workspaceRoot, lockfileName))) {
+    if (fs7.existsSync(path4.join(workspaceRoot, lockfileName))) {
       return { name, version: getVersion(name) };
     }
   }
-  if (fs6.existsSync(path3.join(workspaceRoot, "npm-shrinkwrap.json"))) {
+  if (fs7.existsSync(path4.join(workspaceRoot, "npm-shrinkwrap.json"))) {
     return { name: "npm", version: getVersion("npm") };
   }
   throw new Error(`Failed to detect package manager`);
@@ -298,13 +312,13 @@ function getVersion(packageManagerName) {
 }
 
 // src/lib/package-manager/helpers/infer-from-manifest.ts
-import fs7 from "fs-extra";
+import fs8 from "fs-extra";
 import assert2 from "node:assert";
-import path4 from "node:path";
+import path5 from "node:path";
 function inferFromManifest(workspaceRoot) {
   const log = useLogger();
   const rootManifest = readTypedJsonSync(
-    path4.join(workspaceRoot, "package.json")
+    path5.join(workspaceRoot, "package.json")
   );
   if (!rootManifest.packageManager) {
     log.debug("No packageManager field found in root manifest");
@@ -317,7 +331,7 @@ function inferFromManifest(workspaceRoot) {
   );
   const lockfileName = getLockfileFileName(name);
   assert2(
-    fs7.existsSync(path4.join(workspaceRoot, lockfileName)),
+    fs8.existsSync(path5.join(workspaceRoot, lockfileName)),
     `Manifest declares ${name} to be the packageManager, but failed to find ${lockfileName} in workspace root`
   );
   return { name, version };
@@ -333,40 +347,46 @@ function usePackageManager() {
   }
   return packageManager;
 }
-function detectPackageManager(workspaceRoot) {
-  packageManager = inferFromManifest(workspaceRoot) ?? inferFromFiles(workspaceRoot);
+function detectPackageManager(workspaceRootDir) {
+  if (isRushWorkspace(workspaceRootDir)) {
+    packageManager = inferFromFiles(
+      path6.join(workspaceRootDir, "common/config/rush")
+    );
+  } else {
+    packageManager = inferFromManifest(workspaceRootDir) ?? inferFromFiles(workspaceRootDir);
+  }
   return packageManager;
 }
 
 // src/lib/lockfile/helpers/generate-npm-lockfile.ts
 import Arborist from "@npmcli/arborist";
-import fs8 from "fs-extra";
-import path5 from "node:path";
+import fs9 from "fs-extra";
+import path7 from "node:path";
 async function generateNpmLockfile({
   workspaceRootDir,
   isolateDir
 }) {
   const log = useLogger();
   log.info("Generating NPM lockfile...");
-  const origRootNodeModulesPath = path5.join(workspaceRootDir, "node_modules");
-  const tempRootNodeModulesPath = path5.join(isolateDir, "node_modules");
+  const origRootNodeModulesPath = path7.join(workspaceRootDir, "node_modules");
+  const tempRootNodeModulesPath = path7.join(isolateDir, "node_modules");
   let hasMovedNodeModules = false;
   let hasError = false;
   try {
-    if (!fs8.existsSync(origRootNodeModulesPath)) {
+    if (!fs9.existsSync(origRootNodeModulesPath)) {
       throw new Error(
         `Failed to find node_modules at ${origRootNodeModulesPath}`
       );
     }
     log.debug(`Temporarily moving node_modules to the isolate output`);
-    await fs8.move(origRootNodeModulesPath, tempRootNodeModulesPath);
+    await fs9.move(origRootNodeModulesPath, tempRootNodeModulesPath);
     hasMovedNodeModules = true;
     const arborist = new Arborist({ path: isolateDir });
     log.debug(`Building tree...`);
     const { meta } = await arborist.buildIdealTree();
     meta?.commit();
-    const lockfilePath = path5.join(isolateDir, "package-lock.json");
-    await fs8.writeFile(lockfilePath, String(meta));
+    const lockfilePath = path7.join(isolateDir, "package-lock.json");
+    await fs9.writeFile(lockfilePath, String(meta));
     log.debug("Created lockfile at", lockfilePath);
   } catch (err) {
     console.error(inspectValue(err));
@@ -375,7 +395,7 @@ async function generateNpmLockfile({
   } finally {
     if (hasMovedNodeModules) {
       log.debug(`Restoring node_modules to the workspace root`);
-      await fs8.move(tempRootNodeModulesPath, origRootNodeModulesPath);
+      await fs9.move(tempRootNodeModulesPath, origRootNodeModulesPath);
     }
   }
   if (hasError) {
@@ -391,7 +411,7 @@ import {
 } from "@pnpm/lockfile-file";
 import { pruneLockfile } from "@pnpm/prune-lockfile";
 import assert3 from "node:assert";
-import path6 from "node:path";
+import path8 from "node:path";
 import { pick } from "remeda";
 
 // src/lib/lockfile/helpers/pnpm-map-importer.ts
@@ -426,9 +446,13 @@ async function generatePnpmLockfile({
   const log = useLogger();
   log.info("Generating PNPM lockfile...");
   try {
-    const lockfile = await readWantedLockfile(workspaceRootDir, {
-      ignoreIncompatible: false
-    });
+    const isRush = isRushWorkspace(workspaceRootDir);
+    const lockfile = await readWantedLockfile(
+      isRush ? path8.join(workspaceRootDir, "common/config/rush") : workspaceRootDir,
+      {
+        ignoreIncompatible: false
+      }
+    );
     assert3(lockfile, `No input lockfile found at ${workspaceRootDir}`);
     const targetImporterId = getLockfileImporterId(
       workspaceRootDir,
@@ -438,6 +462,7 @@ async function generatePnpmLockfile({
       internalDepPackageNames.map((name) => {
         const pkg = packagesRegistry[name];
         assert3(pkg, `Package ${name} not found in packages registry`);
+        console.log("pkg.rootRelativeDir", pkg.rootRelativeDir);
         return [name, pkg.rootRelativeDir];
       })
     );
@@ -450,23 +475,18 @@ async function generatePnpmLockfile({
       ...Object.values(directoryByPackageName)
     ];
     log.debug("Relevant importer ids:", relevantImporterIds);
+    const relevantImporterIdsWithPrefix = relevantImporterIds.map(
+      (x) => isRush ? `../../${x}` : x
+    );
     lockfile.importers = Object.fromEntries(
-      Object.entries(pick(lockfile.importers, relevantImporterIds)).map(
-        ([importerId, importer]) => {
-          if (importerId === targetImporterId) {
-            log.debug("Setting target package importer on root");
-            return [
-              ".",
-              pnpmMapImporter(importer, {
-                includeDevDependencies,
-                includePatchedDependencies,
-                directoryByPackageName
-              })
-            ];
-          }
-          log.debug("Setting internal package importer:", importerId);
+      Object.entries(
+        pick(lockfile.importers, relevantImporterIdsWithPrefix)
+      ).map(([prefixedImporterId, importer]) => {
+        const importerId = isRush ? prefixedImporterId.replace("../../", "") : prefixedImporterId;
+        if (importerId === targetImporterId) {
+          log.debug("Setting target package importer on root");
           return [
-            importerId,
+            ".",
             pnpmMapImporter(importer, {
               includeDevDependencies,
               includePatchedDependencies,
@@ -474,7 +494,16 @@ async function generatePnpmLockfile({
             })
           ];
         }
-      )
+        log.debug("Setting internal package importer:", importerId);
+        return [
+          importerId,
+          pnpmMapImporter(importer, {
+            includeDevDependencies,
+            includePatchedDependencies,
+            directoryByPackageName
+          })
+        ];
+      })
     );
     log.debug("Pruning the lockfile");
     const prunedLockfile = await pruneLockfile(
@@ -492,30 +521,30 @@ async function generatePnpmLockfile({
        */
       patchedDependencies: includePatchedDependencies ? lockfile.patchedDependencies : void 0
     });
-    log.debug("Created lockfile at", path6.join(isolateDir, "pnpm-lock.yaml"));
+    log.debug("Created lockfile at", path8.join(isolateDir, "pnpm-lock.yaml"));
   } catch (err) {
     throw new Error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
   }
 }
 
 // src/lib/lockfile/helpers/generate-yarn-lockfile.ts
-import fs9 from "fs-extra";
+import fs10 from "fs-extra";
 import { execSync as execSync2 } from "node:child_process";
-import path7 from "node:path";
+import path9 from "node:path";
 async function generateYarnLockfile({
   workspaceRootDir,
   isolateDir
 }) {
   const log = useLogger();
   log.info("Generating Yarn lockfile...");
-  const origLockfilePath = path7.join(workspaceRootDir, "yarn.lock");
-  const newLockfilePath = path7.join(isolateDir, "yarn.lock");
-  if (!fs9.existsSync(origLockfilePath)) {
+  const origLockfilePath = path9.join(workspaceRootDir, "yarn.lock");
+  const newLockfilePath = path9.join(isolateDir, "yarn.lock");
+  if (!fs10.existsSync(origLockfilePath)) {
     throw new Error(`Failed to find lockfile at ${origLockfilePath}`);
   }
   log.debug(`Copy original yarn.lock to the isolate output`);
   try {
-    await fs9.copyFile(origLockfilePath, newLockfilePath);
+    await fs10.copyFile(origLockfilePath, newLockfilePath);
     log.debug(`Running local install`);
     execSync2(`yarn install --cwd ${isolateDir}`);
     log.debug("Generated lockfile at", newLockfilePath);
@@ -598,24 +627,24 @@ async function processLockfile({
 import { omit as omit2, pick as pick2 } from "remeda";
 
 // src/lib/manifest/helpers/adapt-internal-package-manifests.ts
-import path10 from "node:path";
+import path12 from "node:path";
 import { omit } from "remeda";
 
 // src/lib/manifest/io.ts
-import fs10 from "fs-extra";
-import path8 from "node:path";
+import fs11 from "fs-extra";
+import path10 from "node:path";
 async function readManifest(packageDir) {
-  return readTypedJson(path8.join(packageDir, "package.json"));
+  return readTypedJson(path10.join(packageDir, "package.json"));
 }
 async function writeManifest(outputDir, manifest) {
-  await fs10.writeFile(
-    path8.join(outputDir, "package.json"),
+  await fs11.writeFile(
+    path10.join(outputDir, "package.json"),
     JSON.stringify(manifest, null, 2)
   );
 }
 
 // src/lib/manifest/helpers/patch-internal-entries.ts
-import path9 from "node:path";
+import path11 from "node:path";
 function patchInternalEntries(dependencies, packagesRegistry, parentRootRelativeDir) {
   const log = useLogger();
   const allWorkspacePackageNames = Object.keys(packagesRegistry);
@@ -623,7 +652,7 @@ function patchInternalEntries(dependencies, packagesRegistry, parentRootRelative
     Object.entries(dependencies).map(([key, value]) => {
       if (allWorkspacePackageNames.includes(key)) {
         const def = packagesRegistry[key];
-        const relativePath = parentRootRelativeDir ? path9.relative(parentRootRelativeDir, `./${def.rootRelativeDir}`) : `./${def.rootRelativeDir}`;
+        const relativePath = parentRootRelativeDir ? path11.relative(parentRootRelativeDir, `./${def.rootRelativeDir}`) : `./${def.rootRelativeDir}`;
         const linkPath = `file:${relativePath}`;
         log.debug(`Linking dependency ${key} to ${linkPath}`);
         return [key, linkPath];
@@ -679,7 +708,7 @@ async function adaptInternalPackageManifests(internalPackageNames, packagesRegis
         })
       );
       await writeManifest(
-        path10.join(isolateDir, rootRelativeDir),
+        path12.join(isolateDir, rootRelativeDir),
         outputManifest
       );
     })
@@ -687,10 +716,13 @@ async function adaptInternalPackageManifests(internalPackageNames, packagesRegis
 }
 
 // src/lib/manifest/helpers/adopt-pnpm-fields-from-root.ts
-import path11 from "path";
+import path13 from "path";
 async function adoptPnpmFieldsFromRoot(targetPackageManifest, workspaceRootDir) {
+  if (isRushWorkspace(workspaceRootDir)) {
+    return targetPackageManifest;
+  }
   const rootPackageManifest = await readTypedJson(
-    path11.join(workspaceRootDir, "package.json")
+    path13.join(workspaceRootDir, "package.json")
   );
   const overrides = rootPackageManifest.pnpm?.overrides;
   if (!overrides) {
@@ -738,23 +770,23 @@ async function adaptTargetPackageManifest({
 }
 
 // src/lib/output/get-build-output-dir.ts
-import fs11 from "fs-extra";
-import path12 from "node:path";
+import fs12 from "fs-extra";
+import path14 from "node:path";
 import outdent from "outdent";
 async function getBuildOutputDir(targetPackageDir) {
   const config = useConfig();
   const log = useLogger();
   if (config.buildDirName) {
     log.debug("Using buildDirName from config:", config.buildDirName);
-    return path12.join(targetPackageDir, config.buildDirName);
+    return path14.join(targetPackageDir, config.buildDirName);
   }
-  const tsconfigPath = path12.join(targetPackageDir, config.tsconfigPath);
-  if (fs11.existsSync(tsconfigPath)) {
+  const tsconfigPath = path14.join(targetPackageDir, config.tsconfigPath);
+  if (fs12.existsSync(tsconfigPath)) {
     log.debug("Found tsconfig at:", config.tsconfigPath);
     const tsconfig = await readTypedJson(tsconfigPath);
     const outDir = tsconfig.compilerOptions?.outDir;
     if (outDir) {
-      return path12.join(targetPackageDir, outDir);
+      return path14.join(targetPackageDir, outDir);
     } else {
       throw new Error(outdent`
         Failed to find outDir in tsconfig. If you are executing isolate from the root of a monorepo you should specify the buildDirName in isolate.config.json.
@@ -809,8 +841,8 @@ async function packDependencies({
 }
 
 // src/lib/output/process-build-output-files.ts
-import fs12 from "fs-extra";
-import path13 from "node:path";
+import fs13 from "fs-extra";
+import path15 from "node:path";
 var TIMEOUT_MS = 5e3;
 async function processBuildOutputFiles({
   targetPackageDir,
@@ -819,10 +851,10 @@ async function processBuildOutputFiles({
 }) {
   const log = useLogger();
   const packedFilePath = await pack(targetPackageDir, tmpDir);
-  const unpackDir = path13.join(tmpDir, "target");
+  const unpackDir = path15.join(tmpDir, "target");
   const now = Date.now();
   let isWaitingYet = false;
-  while (!fs12.existsSync(packedFilePath) && Date.now() - now < TIMEOUT_MS) {
+  while (!fs13.existsSync(packedFilePath) && Date.now() - now < TIMEOUT_MS) {
     if (!isWaitingYet) {
       log.debug(`Waiting for ${packedFilePath} to become available...`);
     }
@@ -830,23 +862,23 @@ async function processBuildOutputFiles({
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
   await unpack(packedFilePath, unpackDir);
-  await fs12.copy(path13.join(unpackDir, "package"), isolateDir);
+  await fs13.copy(path15.join(unpackDir, "package"), isolateDir);
 }
 
 // src/lib/output/unpack-dependencies.ts
-import fs13 from "fs-extra";
-import path14, { join } from "node:path";
+import fs14 from "fs-extra";
+import path16, { join } from "node:path";
 async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, isolateDir) {
   const log = useLogger();
   await Promise.all(
     Object.entries(packedFilesByName).map(async ([packageName, filePath]) => {
       const dir = packagesRegistry[packageName].rootRelativeDir;
       const unpackDir = join(tmpDir, dir);
-      log.debug("Unpacking", `(temp)/${path14.basename(filePath)}`);
+      log.debug("Unpacking", `(temp)/${path16.basename(filePath)}`);
       await unpack(filePath, unpackDir);
       const destinationDir = join(isolateDir, dir);
-      await fs13.ensureDir(destinationDir);
-      await fs13.move(join(unpackDir, "package"), destinationDir, {
+      await fs14.ensureDir(destinationDir);
+      await fs14.move(join(unpackDir, "package"), destinationDir, {
         overwrite: true
       });
       log.debug(
@@ -860,27 +892,27 @@ async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, i
 }
 
 // src/lib/registry/create-packages-registry.ts
-import fs14 from "fs-extra";
+import fs15 from "fs-extra";
 import { globSync } from "glob";
-import path16 from "node:path";
+import path18 from "node:path";
 
 // src/lib/registry/helpers/find-packages-globs.ts
 import assert5 from "node:assert";
-import path15 from "node:path";
+import path17 from "node:path";
 function findPackagesGlobs(workspaceRootDir) {
   const log = useLogger();
   const packageManager2 = usePackageManager();
   switch (packageManager2.name) {
     case "pnpm": {
       const { packages: globs } = readTypedYamlSync(
-        path15.join(workspaceRootDir, "pnpm-workspace.yaml")
+        path17.join(workspaceRootDir, "pnpm-workspace.yaml")
       );
       log.debug("Detected pnpm packages globs:", inspectValue(globs));
       return globs;
     }
     case "yarn":
     case "npm": {
-      const workspaceRootManifestPath = path15.join(
+      const workspaceRootManifestPath = path17.join(
         workspaceRootDir,
         "package.json"
       );
@@ -914,14 +946,16 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
       `Override workspace packages via config: ${workspacePackagesOverride}`
     );
   }
-  const packagesGlobs = workspacePackagesOverride ?? findPackagesGlobs(workspaceRootDir);
+  const allPackages = listWorkspacePackages(
+    workspacePackagesOverride,
+    workspaceRootDir
+  );
   const cwd = process.cwd();
   process.chdir(workspaceRootDir);
-  const allPackages = packagesGlobs.flatMap((glob) => globSync(glob)).filter((dir) => fs14.lstatSync(dir).isDirectory());
   const registry = (await Promise.all(
     allPackages.map(async (rootRelativeDir) => {
-      const manifestPath = path16.join(rootRelativeDir, "package.json");
-      if (!fs14.existsSync(manifestPath)) {
+      const manifestPath = path18.join(rootRelativeDir, "package.json");
+      if (!fs15.existsSync(manifestPath)) {
         log.warn(
           `Ignoring directory ./${rootRelativeDir} because it does not contain a package.json file`
         );
@@ -929,12 +963,12 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
       } else {
         log.debug(`Registering package ./${rootRelativeDir}`);
         const manifest = await readTypedJson(
-          path16.join(rootRelativeDir, "package.json")
+          path18.join(rootRelativeDir, "package.json")
         );
         return {
           manifest,
           rootRelativeDir,
-          absoluteDir: path16.join(workspaceRootDir, rootRelativeDir)
+          absoluteDir: path18.join(workspaceRootDir, rootRelativeDir)
         };
       }
     })
@@ -947,6 +981,18 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
   process.chdir(cwd);
   return registry;
 }
+function listWorkspacePackages(workspacePackagesOverride, workspaceRootDir) {
+  if (isRushWorkspace(workspaceRootDir)) {
+    const rushConfig = readTypedJsonSync(
+      path18.join(workspaceRootDir, "rush.json")
+    );
+    return rushConfig.projects.map(({ projectFolder }) => projectFolder);
+  } else {
+    const packagesGlobs = workspacePackagesOverride ?? findPackagesGlobs(workspaceRootDir);
+    const allPackages = packagesGlobs.flatMap((glob) => globSync(glob)).filter((dir) => fs15.lstatSync(dir).isDirectory());
+    return allPackages;
+  }
+}
 
 // src/lib/registry/list-internal-packages.ts
 import { uniq } from "remeda";
@@ -979,14 +1025,14 @@ async function isolate(options = {}) {
   setLogLevel(config.logLevel);
   const log = useLogger();
   const thisPackageManifest = await readTypedJson(
-    path17.join(path17.join(__dirname, "..", "package.json"))
+    path19.join(path19.join(__dirname, "..", "package.json"))
   );
   log.debug("Using isolate-package version", thisPackageManifest.version);
-  const targetPackageDir = config.targetPackagePath ? path17.join(process.cwd(), config.targetPackagePath) : process.cwd();
-  const workspaceRootDir = config.targetPackagePath ? process.cwd() : path17.join(targetPackageDir, config.workspaceRoot);
+  const targetPackageDir = config.targetPackagePath ? path19.join(process.cwd(), config.targetPackagePath) : process.cwd();
+  const workspaceRootDir = config.targetPackagePath ? process.cwd() : path19.join(targetPackageDir, config.workspaceRoot);
   const buildOutputDir = await getBuildOutputDir(targetPackageDir);
   assert6(
-    fs15.existsSync(buildOutputDir),
+    fs16.existsSync(buildOutputDir),
     `Failed to find build output path at ${buildOutputDir}. Please make sure you build the source before isolating it.`
   );
   log.debug("Workspace root resolved to", workspaceRootDir);
@@ -994,20 +1040,20 @@ async function isolate(options = {}) {
     "Isolate target package",
     getRootRelativePath(targetPackageDir, workspaceRootDir)
   );
-  const isolateDir = path17.join(targetPackageDir, config.isolateDirName);
+  const isolateDir = path19.join(targetPackageDir, config.isolateDirName);
   log.debug(
     "Isolate output directory",
     getRootRelativePath(isolateDir, workspaceRootDir)
   );
-  if (fs15.existsSync(isolateDir)) {
-    await fs15.remove(isolateDir);
+  if (fs16.existsSync(isolateDir)) {
+    await fs16.remove(isolateDir);
     log.debug("Cleaned the existing isolate output directory");
   }
-  await fs15.ensureDir(isolateDir);
-  const tmpDir = path17.join(isolateDir, "__tmp");
-  await fs15.ensureDir(tmpDir);
+  await fs16.ensureDir(isolateDir);
+  const tmpDir = path19.join(isolateDir, "__tmp");
+  await fs16.ensureDir(tmpDir);
   const targetPackageManifest = await readTypedJson(
-    path17.join(targetPackageDir, "package.json")
+    path19.join(targetPackageDir, "package.json")
   );
   const packageManager2 = detectPackageManager(workspaceRootDir);
   log.debug(
@@ -1069,21 +1115,36 @@ async function isolate(options = {}) {
     await writeManifest(isolateDir, manifest);
   }
   if (packageManager2.name === "pnpm" && !config.forceNpm) {
-    fs15.copyFileSync(
-      path17.join(workspaceRootDir, "pnpm-workspace.yaml"),
-      path17.join(isolateDir, "pnpm-workspace.yaml")
-    );
+    if (isRushWorkspace(workspaceRootDir)) {
+      const packagesFolderNames = unique(
+        internalPackageNames.map(
+          (name) => path19.parse(packagesRegistry[name].rootRelativeDir).dir
+        )
+      );
+      log.debug("Generating pnpm-workspace.yaml for Rush workspace");
+      log.debug("Packages folder names:", packagesFolderNames);
+      const workspaceConfig = packagesFolderNames.map((x) => x + "/*");
+      await writeTypedYamlSync(
+        path19.join(isolateDir, "pnpm-workspace.yaml"),
+        workspaceConfig
+      );
+    } else {
+      fs16.copyFileSync(
+        path19.join(workspaceRootDir, "pnpm-workspace.yaml"),
+        path19.join(isolateDir, "pnpm-workspace.yaml")
+      );
+    }
   }
-  const npmrcPath = path17.join(workspaceRootDir, ".npmrc");
-  if (fs15.existsSync(npmrcPath)) {
-    fs15.copyFileSync(npmrcPath, path17.join(isolateDir, ".npmrc"));
+  const npmrcPath = path19.join(workspaceRootDir, ".npmrc");
+  if (fs16.existsSync(npmrcPath)) {
+    fs16.copyFileSync(npmrcPath, path19.join(isolateDir, ".npmrc"));
     log.debug("Copied .npmrc file to the isolate output");
   }
   log.debug(
     "Deleting temp directory",
     getRootRelativePath(tmpDir, workspaceRootDir)
   );
-  await fs15.remove(tmpDir);
+  await fs16.remove(tmpDir);
   log.info("Isolate completed at", isolateDir);
   return isolateDir;
 }