isolate-package 1.4.0 → 1.4.1-0

package/dist/isolate-bin.mjs

@@ -1,21 +1,980 @@
 #!/usr/bin/env node
-import {
-  isolate
-} from "./chunk-PXDYN4JI.mjs";
 
 // src/isolate-bin.ts
-import console from "node:console";
+import console2 from "node:console";
 import sourceMaps from "source-map-support";
+
+// src/isolate.ts
+import fs15 from "fs-extra";
+import assert6 from "node:assert";
+import path15 from "node:path";
+
+// src/utils/filter-object-undefined.ts
+function filterObjectUndefined(object) {
+  return Object.fromEntries(
+    Object.entries(object).filter(([_, value]) => value !== void 0)
+  );
+}
+
+// src/utils/get-dirname.ts
+import { fileURLToPath } from "url";
+function getDirname(importMetaUrl) {
+  return fileURLToPath(new URL(".", importMetaUrl));
+}
+
+// src/utils/get-error-message.ts
+function getErrorMessage(error) {
+  return toErrorWithMessage(error).message;
+}
+function isErrorWithMessage(error) {
+  return typeof error === "object" && error !== null && "message" in error;
+}
+function toErrorWithMessage(maybeError) {
+  if (isErrorWithMessage(maybeError))
+    return maybeError;
+  try {
+    return new Error(JSON.stringify(maybeError));
+  } catch {
+    return new Error(String(maybeError));
+  }
+}
+
+// src/utils/get-relative-path.ts
+function getRootRelativePath(path16, rootPath) {
+  const strippedPath = path16.replace(rootPath, "");
+  return strippedPath.startsWith("/") ? `(root)${strippedPath}` : `(root)/${strippedPath}`;
+}
+function getIsolateRelativePath(path16, isolatePath) {
+  const strippedPath = path16.replace(isolatePath, "");
+  return strippedPath.startsWith("/") ? `(isolate)${strippedPath}` : `(isolate)/${strippedPath}`;
+}
+
+// src/utils/inspect-value.ts
+import { inspect } from "node:util";
+function inspectValue(value) {
+  return inspect(value, false, 4, true);
+}
+
+// src/utils/is-present.ts
+function isDefined(t) {
+  return t !== void 0;
+}
+
+// src/utils/json.ts
+import fs from "fs-extra";
+import stripJsonComments from "strip-json-comments";
+function readTypedJsonSync(filePath) {
+  try {
+    const rawContent = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(stripJsonComments(rawContent));
+    return data;
+  } catch (err) {
+    throw new Error(
+      `Failed to read JSON from ${filePath}: ${getErrorMessage(err)}`
+    );
+  }
+}
+async function readTypedJson(filePath) {
+  try {
+    const rawContent = await fs.readFile(filePath, "utf-8");
+    const data = JSON.parse(rawContent);
+    return data;
+  } catch (err) {
+    throw new Error(
+      `Failed to read JSON from ${filePath}: ${getErrorMessage(err)}`
+    );
+  }
+}
+
+// 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
+import fs2 from "fs-extra";
+import { exec } from "node:child_process";
+import path from "node:path";
+async function pack(srcDir, dstDir, usePnpmPack = false) {
+  const execOptions = {
+    maxBuffer: 10 * 1024 * 1024
+  };
+  const log = useLogger();
+  const previousCwd = process.cwd();
+  process.chdir(srcDir);
+  const stdout = usePnpmPack ? await new Promise((resolve, reject) => {
+    exec(
+      `pnpm pack --pack-destination ${dstDir}`,
+      execOptions,
+      (err, stdout2, stderr) => {
+        if (err) {
+          log.error(stderr);
+          return reject(err);
+        }
+        resolve(stdout2);
+      }
+    );
+  }) : await new Promise((resolve, reject) => {
+    exec(
+      `npm pack --pack-destination ${dstDir}`,
+      execOptions,
+      (err, stdout2) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(stdout2);
+      }
+    );
+  });
+  const fileName = path.basename(stdout.trim());
+  const filePath = path.join(dstDir, fileName);
+  if (!fs2.existsSync(filePath)) {
+    log.error(
+      `The response from pack could not be resolved to an existing file: ${filePath}`
+    );
+  } else {
+    log.debug(`Packed (temp)/${fileName}`);
+  }
+  process.chdir(previousCwd);
+  return filePath;
+}
+
+// src/utils/unpack.ts
+import fs3 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));
+  });
+}
+
+// src/utils/yaml.ts
+import fs4 from "fs-extra";
+import yaml from "yaml";
+function readTypedYamlSync(filePath) {
+  try {
+    const rawContent = fs4.readFileSync(filePath, "utf-8");
+    const data = yaml.parse(rawContent);
+    return data;
+  } catch (err) {
+    throw new Error(
+      `Failed to read YAML from ${filePath}: ${getErrorMessage(err)}`
+    );
+  }
+}
+
+// src/helpers/adapt-internal-package-manifests.ts
+import fs9 from "fs-extra";
+import path8 from "node:path";
+import { omit as omit2 } from "ramda";
+
+// src/helpers/adapt-manifest-internal-deps.ts
+import { omit } from "ramda";
+
+// 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";
+var configDefaults = {
+  buildDirName: void 0,
+  includeDevDependencies: false,
+  isolateDirName: "isolate",
+  logLevel: "info",
+  targetPackagePath: void 0,
+  tsconfigPath: "./tsconfig.json",
+  workspacePackages: void 0,
+  workspaceRoot: "../..",
+  excludeLockfile: false,
+  avoidPnpmPack: false
+};
+var _resolvedConfig;
+var _user_defined_config;
+var validConfigKeys = Object.keys(configDefaults);
+var CONFIG_FILE_NAME = "isolate.config.json";
+function setUserConfig(config) {
+  _user_defined_config = config;
+  if (config.logLevel) {
+    setLogLevel(config.logLevel);
+  }
+}
+function useConfig() {
+  if (_resolvedConfig) {
+    return _resolvedConfig;
+  } else {
+    throw new Error("Called useConfig before config was made available");
+  }
+}
+function resolveConfig() {
+  if (_resolvedConfig) {
+    return _resolvedConfig;
+  }
+  setLogLevel(process.env.DEBUG_ISOLATE_CONFIG ? "debug" : "info");
+  const log = useLogger();
+  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) : {};
+  }
+  const foreignKeys = Object.keys(_user_defined_config).filter(
+    (key) => !validConfigKeys.includes(key)
+  );
+  if (!isEmpty(foreignKeys)) {
+    log.warn(`Found invalid config settings:`, foreignKeys.join(", "));
+  }
+  const config = Object.assign(
+    {},
+    configDefaults,
+    _user_defined_config
+  );
+  log.debug("Using configuration:", inspectValue(config));
+  _resolvedConfig = config;
+  return config;
+}
+function getUserDefinedConfig() {
+  assert(
+    _user_defined_config,
+    "Called getUserDefinedConfig before user config was made available"
+  );
+  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";
+import path7 from "node:path";
+
+// src/helpers/process-lockfile.ts
+import fs7 from "fs-extra";
+import path6 from "node:path";
+import { mapObjIndexed } from "ramda";
+
+// src/helpers/generate-npm-lockfile.ts
+import Arborist from "@npmcli/arborist";
+import fs6 from "node:fs/promises";
+import path4 from "node:path";
+
+// src/helpers/generate-pnpm-lockfile.ts
+import {
+  getLockfileImporterId,
+  readWantedLockfile,
+  writeWantedLockfile
+} from "@pnpm/lockfile-file";
+import assert2 from "node:assert";
+import path5 from "node:path";
+import { pick } from "ramda";
+async function generatePnpmLockfile({
+  workspaceRootDir,
+  targetPackageDir,
+  isolateDir,
+  internalDepPackageNames,
+  packagesRegistry
+}) {
+  const { includeDevDependencies } = useConfig();
+  const log = useLogger();
+  log.debug("Generating PNPM lockfile");
+  const lockfile = await readWantedLockfile(workspaceRootDir, {
+    ignoreIncompatible: false
+  });
+  assert2(lockfile, "No lockfile found");
+  const targetImporterId = getLockfileImporterId(
+    workspaceRootDir,
+    targetPackageDir
+  );
+  const directoryByPackageName = Object.fromEntries(
+    internalDepPackageNames.map((name) => {
+      const pkg = packagesRegistry[name];
+      assert2(pkg, `Package ${name} not found in packages registry`);
+      return [name, pkg.rootRelativeDir];
+    })
+  );
+  const relevantImporterIds = [
+    targetImporterId,
+    /**
+     * The directory paths happen to correspond with what PNPM calls the
+     * importer ids in the context of a lockfile.
+     */
+    ...Object.values(directoryByPackageName)
+  ];
+  log.debug("Relevant importer ids:", relevantImporterIds);
+  lockfile.importers = Object.fromEntries(
+    Object.entries(pick(relevantImporterIds, lockfile.importers)).map(
+      ([importerId, importer]) => {
+        if (importerId === targetImporterId) {
+          log.debug("Setting target package importer on root");
+          return [
+            ".",
+            pnpmMapImporter(importer, {
+              includeDevDependencies,
+              directoryByPackageName
+            })
+          ];
+        }
+        log.debug("Setting internal package importer:", importerId);
+        return [
+          importerId,
+          pnpmMapImporter(importer, {
+            includeDevDependencies,
+            directoryByPackageName
+          })
+        ];
+      }
+    )
+  );
+  await writeWantedLockfile(isolateDir, lockfile);
+  log.debug("Created lockfile at", path5.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";
+  }
+}
+function pnpmMapImporter({ dependencies, devDependencies, ...rest }, {
+  includeDevDependencies,
+  directoryByPackageName
+}) {
+  return {
+    dependencies: dependencies ? pnpmMapDependenciesLinks(dependencies, directoryByPackageName) : void 0,
+    devDependencies: includeDevDependencies && devDependencies ? pnpmMapDependenciesLinks(devDependencies, directoryByPackageName) : void 0,
+    ...rest
+  };
+}
+function pnpmMapDependenciesLinks(def, directoryByPackageName) {
+  return mapObjIndexed(
+    (version, name) => version.startsWith("link:") ? `link:./${directoryByPackageName[name]}` : version,
+    def
+  );
+}
+async function processLockfile({
+  workspaceRootDir,
+  packagesRegistry,
+  isolateDir,
+  internalDepPackageNames,
+  targetPackageDir,
+  targetPackageName
+}) {
+  const log = useLogger();
+  const { name } = usePackageManager();
+  const fileName = getLockfileFileName(name);
+  const lockfileSrcPath = path6.join(workspaceRootDir, fileName);
+  const lockfileDstPath = path6.join(isolateDir, fileName);
+  switch (name) {
+    case "npm": {
+      const shrinkwrapSrcPath = path6.join(
+        workspaceRootDir,
+        "npm-shrinkwrap.json"
+      );
+      const shrinkwrapDstPath = path6.join(isolateDir, "npm-shrinkwrap.json");
+      if (fs7.existsSync(shrinkwrapSrcPath)) {
+        fs7.copyFileSync(shrinkwrapSrcPath, shrinkwrapDstPath);
+        log.debug("Copied shrinkwrap to", shrinkwrapDstPath);
+      } else {
+        fs7.copyFileSync(lockfileSrcPath, lockfileDstPath);
+        log.debug("Copied lockfile to", lockfileDstPath);
+      }
+      if (false) {
+        await generateNpmLockfile({
+          workspaceRootDir,
+          targetPackageName,
+          isolateDir,
+          packagesRegistry
+        });
+      }
+      break;
+    }
+    case "yarn": {
+      fs7.copyFileSync(lockfileSrcPath, lockfileDstPath);
+      log.debug("Copied lockfile to", lockfileDstPath);
+      break;
+    }
+    case "pnpm": {
+      await generatePnpmLockfile({
+        workspaceRootDir,
+        targetPackageDir,
+        isolateDir,
+        internalDepPackageNames,
+        packagesRegistry
+      });
+      break;
+    }
+    default:
+      log.warn(`Unexpected package manager ${name}`);
+  }
+}
+
+// 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) {
+  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`
+  );
+  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/helpers/adapt-internal-package-manifests.ts
+async function adaptInternalPackageManifests(internalPackageNames, packagesRegistry, isolateDir) {
+  const packageManager2 = usePackageManager();
+  const { includeDevDependencies } = useConfig();
+  await Promise.all(
+    internalPackageNames.map(async (packageName) => {
+      const { manifest, rootRelativeDir } = packagesRegistry[packageName];
+      const outputManifest = packageManager2.name === "pnpm" ? Object.assign(
+        /**
+         * For internal dependencies we want to omit the peerDependencies,
+         * because installing these is the responsibility of the consuming
+         * app / service, and otherwise the frozen lockfile install will
+         * error since the package file contains something that is not
+         * referenced in the lockfile.
+         */
+        omit2(["devDependencies", "peerDependencies"], manifest),
+        {
+          dependencies: manifest.dependencies,
+          devDependencies: includeDevDependencies ? manifest.devDependencies : void 0
+        }
+      ) : adaptManifestInternalDeps(
+        {
+          manifest,
+          packagesRegistry,
+          parentRootRelativeDir: rootRelativeDir
+        },
+        { includeDevDependencies }
+      );
+      await fs9.writeFile(
+        path8.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";
+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 }
+  );
+  await fs10.writeFile(
+    path9.join(isolateDir, "package.json"),
+    JSON.stringify(outputManifest, null, 2)
+  );
+}
+
+// src/helpers/create-packages-registry.ts
+import fs11 from "fs-extra";
+import { globSync } from "glob";
+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
+import fs12 from "fs-extra";
+import path12 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);
+  }
+  const tsconfigPath = path12.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);
+    } 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.
+      `);
+    }
+  } else {
+    log.warn("Failed to find tsconfig at:", tsconfigPath);
+    throw new Error(outdent`
+      Failed to infer the build output directory from either the isolate config buildDirName or a Typescript config file. See the documentation on how to configure one of these options.
+    `);
+  }
+}
+
+// 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";
+async function packDependencies({
+  /** All packages found in the monorepo by workspaces declaration */
+  packagesRegistry,
+  /** The dependencies that appear to be internal packages */
+  internalPackageNames,
+  /**
+   * The directory where the isolated package and all its dependencies will end
+   * up. This is also the directory from where the package will be deployed. By
+   * default it is a subfolder in targetPackageDir called "isolate" but you can
+   * configure it.
+   */
+  packDestinationDir
+}) {
+  const config = useConfig();
+  const log = useLogger();
+  const packedFileByName = {};
+  const { name, version } = usePackageManager();
+  const versionMajor = parseInt(version.split(".")[0], 10);
+  const usePnpmPack = !config.avoidPnpmPack && name === "pnpm" && versionMajor >= 8;
+  if (usePnpmPack) {
+    log.debug("Using PNPM pack instead of NPM pack");
+  }
+  for (const dependency of internalPackageNames) {
+    const def = packagesRegistry[dependency];
+    assert5(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`);
+      continue;
+    }
+    packedFileByName[name2] = await pack(
+      def.absoluteDir,
+      packDestinationDir,
+      usePnpmPack
+    );
+  }
+  return packedFileByName;
+}
+
+// src/helpers/process-build-output-files.ts
+import fs13 from "fs-extra";
+import path13 from "node:path";
+var TIMEOUT_MS = 5e3;
+async function processBuildOutputFiles({
+  targetPackageDir,
+  tmpDir,
+  isolateDir
+}) {
+  const log = useLogger();
+  const packedFilePath = await pack(targetPackageDir, tmpDir);
+  const unpackDir = path13.join(tmpDir, "target");
+  const now = Date.now();
+  let isWaitingYet = false;
+  while (!fs13.existsSync(packedFilePath) && Date.now() - now < TIMEOUT_MS) {
+    if (!isWaitingYet) {
+      log.debug(`Waiting for ${packedFilePath} to become available...`);
+    }
+    isWaitingYet = true;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  await unpack(packedFilePath, unpackDir);
+  await fs13.copy(path13.join(unpackDir, "package"), isolateDir);
+}
+
+// src/helpers/unpack-dependencies.ts
+import fs14 from "fs-extra";
+import path14, { 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)}`);
+      await unpack(filePath, unpackDir);
+      const destinationDir = join(isolateDir, dir);
+      await fs14.ensureDir(destinationDir);
+      await fs14.move(join(unpackDir, "package"), destinationDir, {
+        overwrite: true
+      });
+      log.debug(
+        `Moved package files to ${getIsolateRelativePath(
+          destinationDir,
+          isolateDir
+        )}`
+      );
+    })
+  );
+}
+
+// src/isolate.ts
+var __dirname2 = getDirname(import.meta.url);
+async function isolate(options = {}) {
+  if (options.logger) {
+    setLogger(options.logger);
+  }
+  if (options.config) {
+    setUserConfig(options.config);
+  }
+  const config = resolveConfig();
+  setLogLevel(config.logLevel);
+  const log = useLogger();
+  const thisPackageManifest = await readTypedJson(
+    path15.join(path15.join(__dirname2, "..", "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 buildOutputDir = await getBuildOutputDir(targetPackageDir);
+  assert6(
+    fs15.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);
+  log.debug(
+    "Isolate target package",
+    getRootRelativePath(targetPackageDir, workspaceRootDir)
+  );
+  const isolateDir = path15.join(targetPackageDir, config.isolateDirName);
+  log.debug(
+    "Isolate output directory",
+    getRootRelativePath(isolateDir, workspaceRootDir)
+  );
+  if (fs15.existsSync(isolateDir)) {
+    await fs15.remove(isolateDir);
+    log.debug("Cleaned the existing isolate output directory");
+  }
+  await fs15.ensureDir(isolateDir);
+  const tmpDir = path15.join(isolateDir, "__tmp");
+  await fs15.ensureDir(tmpDir);
+  const targetPackageManifest = await readTypedJson(
+    path15.join(targetPackageDir, "package.json")
+  );
+  const packageManager2 = detectPackageManager(workspaceRootDir);
+  log.debug(
+    "Detected package manager",
+    packageManager2.name,
+    packageManager2.version
+  );
+  const packagesRegistry = await createPackagesRegistry(
+    workspaceRootDir,
+    config.workspacePackages
+  );
+  const internalPackageNames = listInternalPackages(
+    targetPackageManifest,
+    packagesRegistry,
+    {
+      includeDevDependencies: config.includeDevDependencies
+    }
+  );
+  const packedFilesByName = await packDependencies({
+    internalPackageNames,
+    packagesRegistry,
+    packDestinationDir: tmpDir
+  });
+  await unpackDependencies(
+    packedFilesByName,
+    packagesRegistry,
+    tmpDir,
+    isolateDir
+  );
+  await adaptInternalPackageManifests(
+    internalPackageNames,
+    packagesRegistry,
+    isolateDir
+  );
+  await processBuildOutputFiles({
+    targetPackageDir,
+    tmpDir,
+    isolateDir
+  });
+  await adaptTargetPackageManifest(
+    targetPackageManifest,
+    packagesRegistry,
+    isolateDir
+  );
+  const userDefinedConfig = getUserDefinedConfig();
+  if (!isDefined(userDefinedConfig.excludeLockfile)) {
+    if (packageManager2.name === "npm" || packageManager2.name === "yarn") {
+      config.excludeLockfile = true;
+    }
+  }
+  if (config.excludeLockfile) {
+    log.warn("Excluding the lockfile from the isolate output");
+  } else {
+    await processLockfile({
+      workspaceRootDir,
+      isolateDir,
+      packagesRegistry,
+      internalDepPackageNames: internalPackageNames,
+      targetPackageDir,
+      targetPackageName: targetPackageManifest.name
+    });
+  }
+  if (packageManager2.name === "pnpm") {
+    fs15.copyFileSync(
+      path15.join(workspaceRootDir, "pnpm-workspace.yaml"),
+      path15.join(isolateDir, "pnpm-workspace.yaml")
+    );
+  }
+  const npmrcPath = path15.join(workspaceRootDir, ".npmrc");
+  if (fs15.existsSync(npmrcPath)) {
+    fs15.copyFileSync(npmrcPath, path15.join(isolateDir, ".npmrc"));
+    log.debug("Copied .npmrc file to the isolate output");
+  }
+  log.debug(
+    "Deleting temp directory",
+    getRootRelativePath(tmpDir, workspaceRootDir)
+  );
+  await fs15.remove(tmpDir);
+  log.info("Isolate completed at", isolateDir);
+}
+
+// src/isolate-bin.ts
 sourceMaps.install();
 async function run() {
   await isolate();
 }
 run().catch((err) => {
   if (err instanceof Error) {
-    console.error(err.stack);
+    console2.error(err.stack);
     process.exit(1);
   } else {
-    console.error(err);
+    console2.error(err);
   }
 });
-//# sourceMappingURL=isolate-bin.mjs.map
+//# sourceMappingURL=isolate-bin.js.map