isolate-package 1.6.2-0 → 1.7.0

package/dist/index.mjs

@@ -1,30 +1,77 @@
 // src/isolate.ts
-import fs15 from "fs-extra";
+import fs16 from "fs-extra";
 import assert6 from "node:assert";
-import path15 from "node:path";
+import path17 from "node:path";
 
-// src/helpers/adapt-internal-package-manifests.ts
-import fs9 from "fs-extra";
-import path8 from "node:path";
-import { omit as omit2 } from "ramda";
+// src/lib/config.ts
+import fs5 from "fs-extra";
+import assert from "node:assert";
+import path2 from "node:path";
+import { isEmpty } from "ramda";
 
-// src/helpers/adapt-manifest-internal-deps.ts
-import { omit } from "ramda";
+// src/lib/logger.ts
+import chalk from "chalk";
+var _loggerHandlers = {
+  debug(...args) {
+    console.log(chalk.blue("debug"), ...args);
+  },
+  info(...args) {
+    console.log(chalk.green("info"), ...args);
+  },
+  warn(...args) {
+    console.log(chalk.yellow("warning"), ...args);
+  },
+  error(...args) {
+    console.log(chalk.red("error"), ...args);
+  }
+};
+var _logger = {
+  debug(...args) {
+    if (_logLevel === "debug") {
+      _loggerHandlers.debug(...args);
+    }
+  },
+  info(...args) {
+    if (_logLevel === "debug" || _logLevel === "info") {
+      _loggerHandlers.info(...args);
+    }
+  },
+  warn(...args) {
+    if (_logLevel === "debug" || _logLevel === "info" || _logLevel === "warn") {
+      _loggerHandlers.warn(...args);
+    }
+  },
+  error(...args) {
+    _loggerHandlers.error(...args);
+  }
+};
+var _logLevel = "info";
+function setLogger(logger) {
+  _loggerHandlers = logger;
+  return _logger;
+}
+function setLogLevel(logLevel) {
+  _logLevel = logLevel;
+  return _logger;
+}
+function useLogger() {
+  return _logger;
+}
 
-// src/utils/filter-object-undefined.ts
+// src/lib/utils/filter-object-undefined.ts
 function filterObjectUndefined(object) {
   return Object.fromEntries(
     Object.entries(object).filter(([_, value]) => value !== void 0)
   );
 }
 
-// src/utils/get-dirname.ts
+// src/lib/utils/get-dirname.ts
 import { fileURLToPath } from "url";
 function getDirname(importMetaUrl) {
   return fileURLToPath(new URL(".", importMetaUrl));
 }
 
-// src/utils/get-error-message.ts
+// src/lib/utils/get-error-message.ts
 function getErrorMessage(error) {
   return toErrorWithMessage(error).message;
 }
@@ -41,28 +88,28 @@ function toErrorWithMessage(maybeError) {
   }
 }
 
-// src/utils/get-relative-path.ts
-function getRootRelativePath(path16, rootPath) {
-  const strippedPath = path16.replace(rootPath, "");
+// src/lib/utils/get-relative-path.ts
+function getRootRelativePath(path18, rootPath) {
+  const strippedPath = path18.replace(rootPath, "");
   return strippedPath.startsWith("/") ? `(root)${strippedPath}` : `(root)/${strippedPath}`;
 }
-function getIsolateRelativePath(path16, isolatePath) {
-  const strippedPath = path16.replace(isolatePath, "");
+function getIsolateRelativePath(path18, isolatePath) {
+  const strippedPath = path18.replace(isolatePath, "");
   return strippedPath.startsWith("/") ? `(isolate)${strippedPath}` : `(isolate)/${strippedPath}`;
 }
 
-// src/utils/inspect-value.ts
+// src/lib/utils/inspect-value.ts
 import { inspect } from "node:util";
 function inspectValue(value) {
   return inspect(value, false, 4, true);
 }
 
-// src/utils/is-present.ts
+// src/lib/utils/is-present.ts
 function isDefined(t) {
   return t !== void 0;
 }
 
-// src/utils/json.ts
+// src/lib/utils/json.ts
 import fs from "fs-extra";
 import stripJsonComments from "strip-json-comments";
 function readTypedJsonSync(filePath) {
@@ -88,56 +135,7 @@ async function readTypedJson(filePath) {
   }
 }
 
-// src/utils/logger.ts
-import chalk from "chalk";
-var _loggerHandlers = {
-  debug(...args) {
-    console.log(chalk.blue("debug"), ...args);
-  },
-  info(...args) {
-    console.log(chalk.green("info"), ...args);
-  },
-  warn(...args) {
-    console.log(chalk.yellow("warning"), ...args);
-  },
-  error(...args) {
-    console.log(chalk.red("error"), ...args);
-  }
-};
-var _logger = {
-  debug(...args) {
-    if (_logLevel === "debug") {
-      _loggerHandlers.debug(...args);
-    }
-  },
-  info(...args) {
-    if (_logLevel === "debug" || _logLevel === "info") {
-      _loggerHandlers.info(...args);
-    }
-  },
-  warn(...args) {
-    if (_logLevel === "debug" || _logLevel === "info" || _logLevel === "warn") {
-      _loggerHandlers.warn(...args);
-    }
-  },
-  error(...args) {
-    _loggerHandlers.error(...args);
-  }
-};
-var _logLevel = "info";
-function setLogger(logger) {
-  _loggerHandlers = logger;
-  return _logger;
-}
-function setLogLevel(logLevel) {
-  _logLevel = logLevel;
-  return _logger;
-}
-function useLogger() {
-  return _logger;
-}
-
-// src/utils/pack.ts
+// src/lib/utils/pack.ts
 import fs2 from "fs-extra";
 import { exec } from "node:child_process";
 import path from "node:path";
@@ -185,7 +183,7 @@ async function pack(srcDir, dstDir, usePnpmPack = false) {
   return filePath;
 }
 
-// src/utils/unpack.ts
+// src/lib/utils/unpack.ts
 import fs3 from "fs-extra";
 import tar from "tar-fs";
 import { createGunzip } from "zlib";
@@ -195,7 +193,7 @@ async function unpack(filePath, unpackDir) {
   });
 }
 
-// src/utils/yaml.ts
+// src/lib/utils/yaml.ts
 import fs4 from "fs-extra";
 import yaml from "yaml";
 function readTypedYamlSync(filePath) {
@@ -210,54 +208,7 @@ function readTypedYamlSync(filePath) {
   }
 }
 
-// src/helpers/patch-internal-entries.ts
-import path2 from "node:path";
-function patchInternalEntries(dependencies, packagesRegistry, parentRootRelativeDir) {
-  const log = useLogger();
-  const allWorkspacePackageNames = Object.keys(packagesRegistry);
-  return Object.fromEntries(
-    Object.entries(dependencies).map(([key, value]) => {
-      if (allWorkspacePackageNames.includes(key)) {
-        const def = packagesRegistry[key];
-        const relativePath = parentRootRelativeDir ? path2.relative(parentRootRelativeDir, `./${def.rootRelativeDir}`) : `./${def.rootRelativeDir}`;
-        const linkPath = `file:${relativePath}`;
-        log.debug(`Linking dependency ${key} to ${linkPath}`);
-        return [key, linkPath];
-      } else {
-        return [key, value];
-      }
-    })
-  );
-}
-
-// src/helpers/adapt-manifest-internal-deps.ts
-function adaptManifestInternalDeps({
-  manifest,
-  packagesRegistry,
-  parentRootRelativeDir
-}, opts = {}) {
-  return Object.assign(
-    omit(["devDependencies"], manifest),
-    filterObjectUndefined({
-      dependencies: manifest.dependencies ? patchInternalEntries(
-        manifest.dependencies,
-        packagesRegistry,
-        parentRootRelativeDir
-      ) : void 0,
-      devDependencies: opts.includeDevDependencies && manifest.devDependencies ? patchInternalEntries(
-        manifest.devDependencies,
-        packagesRegistry,
-        parentRootRelativeDir
-      ) : void 0
-    })
-  );
-}
-
-// src/helpers/config.ts
-import fs5 from "fs-extra";
-import assert from "node:assert";
-import path3 from "node:path";
-import { isEmpty } from "ramda";
+// src/lib/config.ts
 var configDefaults = {
   buildDirName: void 0,
   includeDevDependencies: false,
@@ -293,7 +244,7 @@ function resolveConfig() {
   }
   setLogLevel(process.env.DEBUG_ISOLATE_CONFIG ? "debug" : "info");
   const log = useLogger();
-  const configFilePath = path3.join(process.cwd(), CONFIG_FILE_NAME);
+  const configFilePath = path2.join(process.cwd(), CONFIG_FILE_NAME);
   if (_user_defined_config) {
     log.debug(`Using user defined config:`, inspectValue(_user_defined_config));
   } else {
@@ -323,47 +274,138 @@ function getUserDefinedConfig() {
   return _user_defined_config;
 }
 
-// src/helpers/detect-package-manager.ts
-import fs8 from "fs-extra";
-import assert3 from "node:assert";
-import { execSync } from "node:child_process";
+// src/lib/lockfile/process-lockfile.ts
+import fs9 from "fs-extra";
 import path7 from "node:path";
+import { mapObjIndexed } from "ramda";
+
+// src/lib/package-manager/helpers/infer-from-files.ts
+import fs6 from "fs-extra";
+import { execSync } from "node:child_process";
+import path3 from "node:path";
+
+// src/lib/package-manager/names.ts
+var supportedPackageManagerNames = ["pnpm", "yarn", "npm"];
+function getLockfileFileName(name) {
+  switch (name) {
+    case "pnpm":
+      return "pnpm-lock.yaml";
+    case "yarn":
+      return "yarn.lock";
+    case "npm":
+      return "package-lock.json";
+  }
+}
+
+// src/lib/package-manager/helpers/infer-from-files.ts
+function inferFromFiles(workspaceRoot) {
+  for (const name of supportedPackageManagerNames) {
+    const lockfileName = getLockfileFileName(name);
+    if (fs6.existsSync(path3.join(workspaceRoot, lockfileName))) {
+      return { name, version: getVersion(name) };
+    }
+  }
+  if (fs6.existsSync(path3.join(workspaceRoot, "npm-shrinkwrap.json"))) {
+    return { name: "npm", version: getVersion("npm") };
+  }
+  throw new Error(`Failed to detect package manager`);
+}
+function getVersion(packageManagerName) {
+  const buffer = execSync(`${packageManagerName} --version`);
+  return buffer.toString().trim();
+}
 
-// src/helpers/process-lockfile.ts
+// src/lib/package-manager/helpers/infer-from-manifest.ts
 import fs7 from "fs-extra";
-import path6 from "node:path";
-import { mapObjIndexed } from "ramda";
+import assert2 from "node:assert";
+import path4 from "node:path";
+function inferFromManifest(workspaceRoot) {
+  const log = useLogger();
+  const rootManifest = readTypedJsonSync(
+    path4.join(workspaceRoot, "package.json")
+  );
+  if (!rootManifest.packageManager) {
+    log.debug("No packageManager field found in root manifest");
+    return;
+  }
+  const [name, version = "*"] = rootManifest.packageManager.split("@");
+  assert2(
+    supportedPackageManagerNames.includes(name),
+    `Package manager "${name}" is not currently supported`
+  );
+  const lockfileName = getLockfileFileName(name);
+  assert2(
+    fs7.existsSync(path4.join(workspaceRoot, lockfileName)),
+    `Manifest declares ${name} to be the packageManager, but failed to find ${lockfileName} in workspace root`
+  );
+  return { name, version };
+}
+
+// src/lib/package-manager/index.ts
+var packageManager;
+function usePackageManager() {
+  if (!packageManager) {
+    throw Error(
+      "No package manager detected. Make sure to call detectPackageManager() before usePackageManager()"
+    );
+  }
+  return packageManager;
+}
+function detectPackageManager(workspaceRoot) {
+  packageManager = inferFromManifest(workspaceRoot) ?? inferFromFiles(workspaceRoot);
+  return packageManager;
+}
 
-// src/helpers/generate-npm-lockfile.ts
+// src/lib/lockfile/helpers/generate-npm-lockfile.ts
 import Arborist from "@npmcli/arborist";
-import fs6 from "node:fs/promises";
-import path4 from "node:path";
+import fs8 from "fs-extra";
+import path5 from "node:path";
 async function generateNpmLockfile({
-  targetPackageDir,
-  packagesRegistry,
-  isolateDir
+  workspaceRootDir,
+  isolateDir,
+  packagesRegistry
 }) {
   const log = useLogger();
-  log.debug("Generating NPM lockfile...");
-  const internalPackageNames = Object.keys(packagesRegistry);
-  const arborist = new Arborist({ path: targetPackageDir });
-  const { meta } = await arborist.buildIdealTree({
-    // rm: internalPackageNames,
-  });
-  meta?.commit();
-  const lockfilePath = path4.join(isolateDir, "package-lock.json");
-  await fs6.writeFile(lockfilePath, String(meta));
-  log.debug("Created lockfile at", lockfilePath);
+  log.info("Generating NPM lockfile...");
+  const origRootNodeModulesPath = path5.join(workspaceRootDir, "node_modules");
+  const tempRootNodeModulesPath = path5.join(isolateDir, "node_modules");
+  if (!fs8.existsSync(origRootNodeModulesPath)) {
+    throw new Error(
+      `Failed to find node_modules at ${origRootNodeModulesPath}`
+    );
+  }
+  log.debug(`Temporarily moving node_modules to the isolate output`);
+  let hasMovedNodeModules = false;
+  try {
+    await fs8.move(origRootNodeModulesPath, tempRootNodeModulesPath);
+    hasMovedNodeModules = true;
+    const internalPackageNames = Object.keys(packagesRegistry);
+    const arborist = new Arborist({ path: isolateDir });
+    const { meta } = await arborist.buildIdealTree({
+      rm: internalPackageNames
+    });
+    meta?.commit();
+    const lockfilePath = path5.join(isolateDir, "package-lock.json");
+    await fs8.writeFile(lockfilePath, String(meta));
+    log.debug("Created lockfile at", lockfilePath);
+  } catch (err) {
+    log.error(getErrorMessage(err));
+  } finally {
+    if (hasMovedNodeModules) {
+      log.debug(`Restoring node_modules to the workspace root`);
+      await fs8.move(tempRootNodeModulesPath, origRootNodeModulesPath);
+    }
+  }
 }
 
-// src/helpers/generate-pnpm-lockfile.ts
+// src/lib/lockfile/helpers/generate-pnpm-lockfile.ts
 import {
   getLockfileImporterId,
   readWantedLockfile,
   writeWantedLockfile
 } from "@pnpm/lockfile-file";
-import assert2 from "node:assert";
-import path5 from "node:path";
+import assert3 from "node:assert";
+import path6 from "node:path";
 import { pick } from "ramda";
 async function generatePnpmLockfile({
   workspaceRootDir,
@@ -374,11 +416,11 @@ async function generatePnpmLockfile({
 }) {
   const { includeDevDependencies } = useConfig();
   const log = useLogger();
-  log.debug("Generating PNPM lockfile...");
+  log.info("Generating PNPM lockfile...");
   const lockfile = await readWantedLockfile(workspaceRootDir, {
     ignoreIncompatible: false
   });
-  assert2(lockfile, `No input lockfile found at ${workspaceRootDir}`);
+  assert3(lockfile, `No input lockfile found at ${workspaceRootDir}`);
   const targetImporterId = getLockfileImporterId(
     workspaceRootDir,
     targetPackageDir
@@ -386,7 +428,7 @@ async function generatePnpmLockfile({
   const directoryByPackageName = Object.fromEntries(
     internalDepPackageNames.map((name) => {
       const pkg = packagesRegistry[name];
-      assert2(pkg, `Package ${name} not found in packages registry`);
+      assert3(pkg, `Package ${name} not found in packages registry`);
       return [name, pkg.rootRelativeDir];
     })
   );
@@ -424,20 +466,10 @@ async function generatePnpmLockfile({
     )
   );
   await writeWantedLockfile(isolateDir, lockfile);
-  log.debug("Created lockfile at", path5.join(isolateDir, "pnpm-lock.yaml"));
+  log.debug("Created lockfile at", path6.join(isolateDir, "pnpm-lock.yaml"));
 }
 
-// src/helpers/process-lockfile.ts
-function getLockfileFileName(name) {
-  switch (name) {
-    case "pnpm":
-      return "pnpm-lock.yaml";
-    case "yarn":
-      return "yarn.lock";
-    case "npm":
-      return "package-lock.json";
-  }
-}
+// src/lib/lockfile/process-lockfile.ts
 function pnpmMapImporter({ dependencies, devDependencies, ...rest }, {
   includeDevDependencies,
   directoryByPackageName
@@ -467,16 +499,16 @@ async function processLockfile({
   switch (name) {
     case "npm": {
       await generateNpmLockfile({
-        targetPackageDir,
+        workspaceRootDir,
         isolateDir,
         packagesRegistry
       });
       break;
     }
     case "yarn": {
-      const lockfileSrcPath = path6.join(workspaceRootDir, fileName);
-      const lockfileDstPath = path6.join(isolateDir, fileName);
-      fs7.copyFileSync(lockfileSrcPath, lockfileDstPath);
+      const lockfileSrcPath = path7.join(workspaceRootDir, fileName);
+      const lockfileDstPath = path7.join(isolateDir, fileName);
+      fs9.copyFileSync(lockfileSrcPath, lockfileDstPath);
       log.debug("Copied lockfile to", lockfileDstPath);
       break;
     }
@@ -495,60 +527,63 @@ async function processLockfile({
   }
 }
 
-// src/helpers/detect-package-manager.ts
-var supportedPackageManagerNames = ["pnpm", "yarn", "npm"];
-var packageManager;
-function detectPackageManager(workspaceRoot) {
-  packageManager = inferFromManifest(workspaceRoot) ?? inferFromFiles(workspaceRoot);
-  return packageManager;
-}
-function inferFromManifest(workspaceRoot) {
+// src/lib/manifest/adapt-target-package-manifest.ts
+import fs11 from "fs-extra";
+import path10 from "node:path";
+import { omit as omit3 } from "ramda";
+
+// src/lib/manifest/helpers/adapt-internal-package-manifests.ts
+import fs10 from "fs-extra";
+import path9 from "node:path";
+import { omit as omit2 } from "ramda";
+
+// src/lib/manifest/helpers/adapt-manifest-internal-deps.ts
+import { omit } from "ramda";
+
+// src/lib/manifest/helpers/patch-internal-entries.ts
+import path8 from "node:path";
+function patchInternalEntries(dependencies, packagesRegistry, parentRootRelativeDir) {
   const log = useLogger();
-  const rootManifest = readTypedJsonSync(
-    path7.join(workspaceRoot, "package.json")
-  );
-  if (!rootManifest.packageManager) {
-    log.debug("No packageManager field found in root manifest");
-    return;
-  }
-  const [name, version = "*"] = rootManifest.packageManager.split("@");
-  assert3(
-    supportedPackageManagerNames.includes(name),
-    `Package manager "${name}" is not currently supported`
-  );
-  const lockfileName = getLockfileFileName(name);
-  assert3(
-    fs8.existsSync(path7.join(workspaceRoot, lockfileName)),
-    `Manifest declares ${name} to be the packageManager, but failed to find ${lockfileName} in workspace root`
+  const allWorkspacePackageNames = Object.keys(packagesRegistry);
+  return Object.fromEntries(
+    Object.entries(dependencies).map(([key, value]) => {
+      if (allWorkspacePackageNames.includes(key)) {
+        const def = packagesRegistry[key];
+        const relativePath = parentRootRelativeDir ? path8.relative(parentRootRelativeDir, `./${def.rootRelativeDir}`) : `./${def.rootRelativeDir}`;
+        const linkPath = `file:${relativePath}`;
+        log.debug(`Linking dependency ${key} to ${linkPath}`);
+        return [key, linkPath];
+      } else {
+        return [key, value];
+      }
+    })
   );
-  return { name, version };
-}
-function inferFromFiles(workspaceRoot) {
-  for (const name of supportedPackageManagerNames) {
-    const lockfileName = getLockfileFileName(name);
-    if (fs8.existsSync(path7.join(workspaceRoot, lockfileName))) {
-      return { name, version: getVersion(name) };
-    }
-  }
-  if (fs8.existsSync(path7.join(workspaceRoot, "npm-shrinkwrap.json"))) {
-    return { name: "npm", version: getVersion("npm") };
-  }
-  throw new Error(`Failed to detect package manager`);
 }
-function getVersion(packageManagerName) {
-  const buffer = execSync(`${packageManagerName} --version`);
-  return buffer.toString().trim();
-}
-function usePackageManager() {
-  if (!packageManager) {
-    throw Error(
-      "No package manager detected. Make sure to call detectPackageManager() before usePackageManager()"
-    );
-  }
-  return packageManager;
+
+// src/lib/manifest/helpers/adapt-manifest-internal-deps.ts
+function adaptManifestInternalDeps({
+  manifest,
+  packagesRegistry,
+  parentRootRelativeDir
+}, opts = {}) {
+  return Object.assign(
+    omit(["devDependencies"], manifest),
+    filterObjectUndefined({
+      dependencies: manifest.dependencies ? patchInternalEntries(
+        manifest.dependencies,
+        packagesRegistry,
+        parentRootRelativeDir
+      ) : void 0,
+      devDependencies: opts.includeDevDependencies && manifest.devDependencies ? patchInternalEntries(
+        manifest.devDependencies,
+        packagesRegistry,
+        parentRootRelativeDir
+      ) : void 0
+    })
+  );
 }
 
-// src/helpers/adapt-internal-package-manifests.ts
+// src/lib/manifest/helpers/adapt-internal-package-manifests.ts
 async function adaptInternalPackageManifests(internalPackageNames, packagesRegistry, isolateDir) {
   const packageManager2 = usePackageManager();
   const { includeDevDependencies } = useConfig();
@@ -576,126 +611,46 @@ async function adaptInternalPackageManifests(internalPackageNames, packagesRegis
         },
         { includeDevDependencies }
       );
-      await fs9.writeFile(
-        path8.join(isolateDir, rootRelativeDir, "package.json"),
+      await fs10.writeFile(
+        path9.join(isolateDir, rootRelativeDir, "package.json"),
         JSON.stringify(outputManifest, null, 2)
       );
     })
   );
 }
 
-// src/helpers/adapt-target-package-manifest.ts
-import fs10 from "fs-extra";
-import path9 from "node:path";
-import { omit as omit3 } from "ramda";
+// src/lib/manifest/adapt-target-package-manifest.ts
 async function adaptTargetPackageManifest(manifest, packagesRegistry, isolateDir) {
   const packageManager2 = usePackageManager();
   const { includeDevDependencies } = useConfig();
-  const outputManifest = packageManager2.name === "pnpm" ? Object.assign(omit3(["devDependencies", "scripts"], manifest), {
-    devDependencies: includeDevDependencies ? manifest.devDependencies : void 0
-  }) : adaptManifestInternalDeps(
-    {
-      manifest,
-      packagesRegistry
-    },
-    { includeDevDependencies }
+  const outputManifest = packageManager2.name === "pnpm" ? (
+    /**
+     * For PNPM the output itself is a workspace so we can preserve the specifiers
+     * with "workspace:*" in the output manifest.
+     */
+    Object.assign(omit3(["devDependencies", "scripts"], manifest), {
+      devDependencies: includeDevDependencies ? manifest.devDependencies : void 0
+    })
+  ) : (
+    /** For other package managers we replace the links to internal dependencies */
+    adaptManifestInternalDeps(
+      {
+        manifest,
+        packagesRegistry
+      },
+      { includeDevDependencies }
+    )
   );
-  await fs10.writeFile(
-    path9.join(isolateDir, "package.json"),
+  await fs11.writeFile(
+    path10.join(isolateDir, "package.json"),
     JSON.stringify(outputManifest, null, 2)
   );
 }
 
-// src/helpers/create-packages-registry.ts
-import fs11 from "fs-extra";
-import { globSync } from "glob";
+// src/lib/manifest/import-manifest.ts
 import path11 from "node:path";
 
-// src/helpers/find-packages-globs.ts
-import assert4 from "node:assert";
-import path10 from "node:path";
-function findPackagesGlobs(workspaceRootDir) {
-  const log = useLogger();
-  const packageManager2 = usePackageManager();
-  switch (packageManager2.name) {
-    case "pnpm": {
-      const { packages: globs } = readTypedYamlSync(
-        path10.join(workspaceRootDir, "pnpm-workspace.yaml")
-      );
-      log.debug("Detected pnpm packages globs:", inspectValue(globs));
-      return globs;
-    }
-    case "yarn":
-    case "npm": {
-      const workspaceRootManifestPath = path10.join(
-        workspaceRootDir,
-        "package.json"
-      );
-      const { workspaces } = readTypedJsonSync(
-        workspaceRootManifestPath
-      );
-      if (!workspaces) {
-        throw new Error(
-          `No workspaces field found in ${workspaceRootManifestPath}`
-        );
-      }
-      if (Array.isArray(workspaces)) {
-        return workspaces;
-      } else {
-        const workspacesObject = workspaces;
-        assert4(
-          workspacesObject.packages,
-          "workspaces.packages must be an array"
-        );
-        return workspacesObject.packages;
-      }
-    }
-  }
-}
-
-// src/helpers/create-packages-registry.ts
-async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverride) {
-  const log = useLogger();
-  if (workspacePackagesOverride) {
-    log.debug(
-      `Override workspace packages via config: ${workspacePackagesOverride}`
-    );
-  }
-  const packagesGlobs = workspacePackagesOverride ?? findPackagesGlobs(workspaceRootDir);
-  const cwd = process.cwd();
-  process.chdir(workspaceRootDir);
-  const allPackages = packagesGlobs.flatMap((glob) => globSync(glob)).filter((dir) => fs11.lstatSync(dir).isDirectory());
-  const registry = (await Promise.all(
-    allPackages.map(async (rootRelativeDir) => {
-      const manifestPath = path11.join(rootRelativeDir, "package.json");
-      if (!fs11.existsSync(manifestPath)) {
-        log.warn(
-          `Ignoring directory ./${rootRelativeDir} because it does not contain a package.json file`
-        );
-        return;
-      } else {
-        log.debug(`Registering package ./${rootRelativeDir}`);
-        const manifest = await readTypedJson(
-          path11.join(rootRelativeDir, "package.json")
-        );
-        return {
-          manifest,
-          rootRelativeDir,
-          absoluteDir: path11.join(workspaceRootDir, rootRelativeDir)
-        };
-      }
-    })
-  )).reduce((acc, info) => {
-    if (info) {
-      acc[info.manifest.name] = info;
-    }
-    return acc;
-  }, {});
-  process.chdir(cwd);
-  return registry;
-}
-
-// src/helpers/get-build-output-dir.ts
+// src/lib/output/get-build-output-dir.ts
 import fs12 from "fs-extra";
 import path12 from "node:path";
 import outdent from "outdent";
@@ -726,26 +681,8 @@ async function getBuildOutputDir(targetPackageDir) {
   }
 }
 
-// src/helpers/list-internal-packages.ts
-import { uniq } from "ramda";
-function listInternalPackages(manifest, packagesRegistry, { includeDevDependencies = false } = {}) {
-  const allWorkspacePackageNames = Object.keys(packagesRegistry);
-  const internalPackageNames = (includeDevDependencies ? [
-    ...Object.keys(manifest.dependencies ?? {}),
-    ...Object.keys(manifest.devDependencies ?? {})
-  ] : Object.keys(manifest.dependencies ?? {})).filter((name) => allWorkspacePackageNames.includes(name));
-  const nestedInternalPackageNames = internalPackageNames.flatMap(
-    (packageName) => listInternalPackages(
-      packagesRegistry[packageName].manifest,
-      packagesRegistry,
-      { includeDevDependencies }
-    )
-  );
-  return uniq(internalPackageNames.concat(nestedInternalPackageNames));
-}
-
-// src/helpers/pack-dependencies.ts
-import assert5 from "node:assert";
+// src/lib/output/pack-dependencies.ts
+import assert4 from "node:assert";
 async function packDependencies({
   /** All packages found in the monorepo by workspaces declaration */
   packagesRegistry,
@@ -770,7 +707,7 @@ async function packDependencies({
   }
   for (const dependency of internalPackageNames) {
     const def = packagesRegistry[dependency];
-    assert5(dependency, `Failed to find package definition for ${dependency}`);
+    assert4(dependency, `Failed to find package definition for ${dependency}`);
     const { name: name2 } = def.manifest;
     if (packedFileByName[name2]) {
       log.debug(`Skipping ${name2} because it has already been packed`);
@@ -785,7 +722,7 @@ async function packDependencies({
   return packedFileByName;
 }
 
-// src/helpers/process-build-output-files.ts
+// src/lib/output/process-build-output-files.ts
 import fs13 from "fs-extra";
 import path13 from "node:path";
 var TIMEOUT_MS = 5e3;
@@ -810,7 +747,7 @@ async function processBuildOutputFiles({
   await fs13.copy(path13.join(unpackDir, "package"), isolateDir);
 }
 
-// src/helpers/unpack-dependencies.ts
+// src/lib/output/unpack-dependencies.ts
 import fs14 from "fs-extra";
 import path14, { join } from "node:path";
 async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, isolateDir) {
@@ -836,6 +773,113 @@ async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, i
   );
 }
 
+// src/lib/registry/create-packages-registry.ts
+import fs15 from "fs-extra";
+import { globSync } from "glob";
+import path16 from "node:path";
+
+// src/lib/registry/helpers/find-packages-globs.ts
+import assert5 from "node:assert";
+import path15 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")
+      );
+      log.debug("Detected pnpm packages globs:", inspectValue(globs));
+      return globs;
+    }
+    case "yarn":
+    case "npm": {
+      const workspaceRootManifestPath = path15.join(
+        workspaceRootDir,
+        "package.json"
+      );
+      const { workspaces } = readTypedJsonSync(
+        workspaceRootManifestPath
+      );
+      if (!workspaces) {
+        throw new Error(
+          `No workspaces field found in ${workspaceRootManifestPath}`
+        );
+      }
+      if (Array.isArray(workspaces)) {
+        return workspaces;
+      } else {
+        const workspacesObject = workspaces;
+        assert5(
+          workspacesObject.packages,
+          "workspaces.packages must be an array"
+        );
+        return workspacesObject.packages;
+      }
+    }
+  }
+}
+
+// src/lib/registry/create-packages-registry.ts
+async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverride) {
+  const log = useLogger();
+  if (workspacePackagesOverride) {
+    log.debug(
+      `Override workspace packages via config: ${workspacePackagesOverride}`
+    );
+  }
+  const packagesGlobs = workspacePackagesOverride ?? findPackagesGlobs(workspaceRootDir);
+  const cwd = process.cwd();
+  process.chdir(workspaceRootDir);
+  const allPackages = packagesGlobs.flatMap((glob) => globSync(glob)).filter((dir) => fs15.lstatSync(dir).isDirectory());
+  const registry = (await Promise.all(
+    allPackages.map(async (rootRelativeDir) => {
+      const manifestPath = path16.join(rootRelativeDir, "package.json");
+      if (!fs15.existsSync(manifestPath)) {
+        log.warn(
+          `Ignoring directory ./${rootRelativeDir} because it does not contain a package.json file`
+        );
+        return;
+      } else {
+        log.debug(`Registering package ./${rootRelativeDir}`);
+        const manifest = await readTypedJson(
+          path16.join(rootRelativeDir, "package.json")
+        );
+        return {
+          manifest,
+          rootRelativeDir,
+          absoluteDir: path16.join(workspaceRootDir, rootRelativeDir)
+        };
+      }
+    })
+  )).reduce((acc, info) => {
+    if (info) {
+      acc[info.manifest.name] = info;
+    }
+    return acc;
+  }, {});
+  process.chdir(cwd);
+  return registry;
+}
+
+// src/lib/registry/list-internal-packages.ts
+import { uniq } from "ramda";
+function listInternalPackages(manifest, packagesRegistry, { includeDevDependencies = false } = {}) {
+  const allWorkspacePackageNames = Object.keys(packagesRegistry);
+  const internalPackageNames = (includeDevDependencies ? [
+    ...Object.keys(manifest.dependencies ?? {}),
+    ...Object.keys(manifest.devDependencies ?? {})
+  ] : Object.keys(manifest.dependencies ?? {})).filter((name) => allWorkspacePackageNames.includes(name));
+  const nestedInternalPackageNames = internalPackageNames.flatMap(
+    (packageName) => listInternalPackages(
+      packagesRegistry[packageName].manifest,
+      packagesRegistry,
+      { includeDevDependencies }
+    )
+  );
+  return uniq(internalPackageNames.concat(nestedInternalPackageNames));
+}
+
 // src/isolate.ts
 var __dirname = getDirname(import.meta.url);
 async function isolate(options = {}) {
@@ -849,14 +893,14 @@ async function isolate(options = {}) {
   setLogLevel(config.logLevel);
   const log = useLogger();
   const thisPackageManifest = await readTypedJson(
-    path15.join(path15.join(__dirname, "..", "package.json"))
+    path17.join(path17.join(__dirname, "..", "package.json"))
   );
   log.debug("Using isolate-package version", thisPackageManifest.version);
-  const targetPackageDir = config.targetPackagePath ? path15.join(process.cwd(), config.targetPackagePath) : process.cwd();
-  const workspaceRootDir = config.targetPackagePath ? process.cwd() : path15.join(targetPackageDir, config.workspaceRoot);
+  const targetPackageDir = config.targetPackagePath ? path17.join(process.cwd(), config.targetPackagePath) : process.cwd();
+  const workspaceRootDir = config.targetPackagePath ? process.cwd() : path17.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);
@@ -864,20 +908,20 @@ async function isolate(options = {}) {
     "Isolate target package",
     getRootRelativePath(targetPackageDir, workspaceRootDir)
   );
-  const isolateDir = path15.join(targetPackageDir, config.isolateDirName);
+  const isolateDir = path17.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 = path15.join(isolateDir, "__tmp");
-  await fs15.ensureDir(tmpDir);
+  await fs16.ensureDir(isolateDir);
+  const tmpDir = path17.join(isolateDir, "__tmp");
+  await fs16.ensureDir(tmpDir);
   const targetPackageManifest = await readTypedJson(
-    path15.join(targetPackageDir, "package.json")
+    path17.join(targetPackageDir, "package.json")
   );
   const packageManager2 = detectPackageManager(workspaceRootDir);
   log.debug(
@@ -941,21 +985,21 @@ async function isolate(options = {}) {
     });
   }
   if (packageManager2.name === "pnpm") {
-    fs15.copyFileSync(
-      path15.join(workspaceRootDir, "pnpm-workspace.yaml"),
-      path15.join(isolateDir, "pnpm-workspace.yaml")
+    fs16.copyFileSync(
+      path17.join(workspaceRootDir, "pnpm-workspace.yaml"),
+      path17.join(isolateDir, "pnpm-workspace.yaml")
     );
   }
-  const npmrcPath = path15.join(workspaceRootDir, ".npmrc");
-  if (fs15.existsSync(npmrcPath)) {
-    fs15.copyFileSync(npmrcPath, path15.join(isolateDir, ".npmrc"));
+  const npmrcPath = path17.join(workspaceRootDir, ".npmrc");
+  if (fs16.existsSync(npmrcPath)) {
+    fs16.copyFileSync(npmrcPath, path17.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;
 }