isolate-package 1.3.3 → 1.4.0

package/dist/index.mjs

@@ -1,760 +1,7 @@
-#!/usr/bin/env node
-
-// src/index.ts
-import fs14 from "fs-extra";
-import assert5 from "node:assert";
-import path14 from "node:path";
-import sourceMaps from "source-map-support";
-
-// src/helpers/adapt-manifest-files.ts
-import fs from "fs-extra";
-import path from "node:path";
-async function adaptManifestFiles(localDependencies, packagesRegistry, isolateDir) {
-  await Promise.all(
-    localDependencies.map(async (packageName) => {
-      const { manifest, rootRelativeDir } = packagesRegistry[packageName];
-      const outputManifest = adaptManifestWorkspaceDeps(
-        { manifest, packagesRegistry, parentRootRelativeDir: rootRelativeDir },
-        { includeDevDependencies: getConfig().includeDevDependencies }
-      );
-      await fs.writeFile(
-        path.join(isolateDir, rootRelativeDir, "package.json"),
-        JSON.stringify(outputManifest, null, 2)
-      );
-    })
-  );
-}
-
-// src/helpers/adapt-manifest-workspace-deps.ts
-import { omit } from "lodash-es";
-
-// 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(path15, rootPath) {
-  const strippedPath = path15.replace(rootPath, "");
-  return strippedPath.startsWith("/") ? `(root)${strippedPath}` : `(root)/${strippedPath}`;
-}
-function getIsolateRelativePath(path15, isolatePath) {
-  const strippedPath = path15.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/json.ts
-import fs2 from "fs-extra";
-import stripJsonComments from "strip-json-comments";
-function readTypedJsonSync(filePath) {
-  try {
-    const rawContent = fs2.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 fs2.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";
-function createLogger(logLevel) {
-  return {
-    debug(...args) {
-      if (logLevel === "debug") {
-        console.log(chalk.blue("debug"), ...args);
-      }
-    },
-    info(...args) {
-      if (logLevel === "debug" || logLevel === "info") {
-        console.log(chalk.green("info"), ...args);
-      }
-    },
-    warn(...args) {
-      if (logLevel === "debug" || logLevel === "info" || logLevel === "warn") {
-        console.log(chalk.yellow("warning"), ...args);
-      }
-    },
-    error(...args) {
-      console.log(chalk.red("error"), ...args);
-    }
-  };
-}
-
-// src/utils/pack.ts
-import fs3 from "fs-extra";
-import { exec } from "node:child_process";
-import path2 from "node:path";
-async function pack(srcDir, dstDir, usePnpmPack = false) {
-  const execOptions = {
-    maxBuffer: 10 * 1024 * 1024
-  };
-  const log2 = createLogger(getConfig().logLevel);
-  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) {
-          log2.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 = path2.basename(stdout.trim());
-  const filePath = path2.join(dstDir, fileName);
-  if (!fs3.existsSync(filePath)) {
-    log2.error(
-      `The response from pack could not be resolved to an existing file: ${filePath}`
-    );
-  } else {
-    log2.debug(`Packed (temp)/${fileName}`);
-  }
-  process.chdir(previousCwd);
-  return filePath;
-}
-
-// src/utils/unpack.ts
-import fs4 from "fs-extra";
-import tar from "tar-fs";
-import { createGunzip } from "zlib";
-async function unpack(filePath, unpackDir) {
-  await new Promise((resolve, reject) => {
-    fs4.createReadStream(filePath).pipe(createGunzip()).pipe(tar.extract(unpackDir)).on("finish", () => resolve()).on("error", (err) => reject(err));
-  });
-}
-
-// src/utils/yaml.ts
-import fs5 from "fs-extra";
-import yaml from "yaml";
-function readTypedYamlSync(filePath) {
-  try {
-    const rawContent = fs5.readFileSync(filePath, "utf-8");
-    const data = yaml.parse(rawContent);
-    return data;
-  } catch (err) {
-    throw new Error(
-      `Failed to read YAML from ${filePath}: ${getErrorMessage(err)}`
-    );
-  }
-}
-function writeTypedYamlSync(filePath, content) {
-  fs5.writeFileSync(filePath, yaml.stringify(content), "utf-8");
-}
-
-// src/helpers/adapt-manifest-workspace-deps.ts
-function adaptManifestWorkspaceDeps({
-  manifest,
-  packagesRegistry,
-  parentRootRelativeDir
-}, opts = {}) {
-  return Object.assign(
-    omit(manifest, ["devDependencies"]),
-    filterObjectUndefined({
-      dependencies: manifest.dependencies ? patchWorkspaceEntries(
-        manifest.dependencies,
-        packagesRegistry,
-        parentRootRelativeDir
-      ) : void 0,
-      devDependencies: opts.includeDevDependencies && manifest.devDependencies ? patchWorkspaceEntries(
-        manifest.devDependencies,
-        packagesRegistry,
-        parentRootRelativeDir
-      ) : void 0
-    })
-  );
-}
-
-// src/helpers/adapt-target-package-manifest.ts
-import fs6 from "fs-extra";
-import path3 from "node:path";
-async function adaptTargetPackageManifest(manifest, packagesRegistry, isolateDir) {
-  const outputManifest = adaptManifestWorkspaceDeps(
-    {
-      manifest,
-      packagesRegistry
-    },
-    { includeDevDependencies: getConfig().includeDevDependencies }
-  );
-  await fs6.writeFile(
-    path3.join(isolateDir, "package.json"),
-    JSON.stringify(outputManifest, null, 2)
-  );
-}
-
-// src/helpers/config.ts
-import fs7 from "fs-extra";
-import { isEmpty } from "lodash-es";
-import path4 from "node:path";
-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
+import {
+  isolate
+} from "./chunk-PXDYN4JI.mjs";
+export {
+  isolate
 };
-var __config;
-var validConfigKeys = Object.keys(configDefaults);
-var CONFIG_FILE_NAME = "isolate.config.json";
-function getConfig() {
-  if (__config) {
-    return __config;
-  }
-  const log2 = createLogger(
-    process.env.ISOLATE_CONFIG_LOG_LEVEL ?? "warn"
-  );
-  const configFilePath = path4.join(process.cwd(), CONFIG_FILE_NAME);
-  log2.debug(`Attempting to load config from ${configFilePath}`);
-  const configFromFile = fs7.existsSync(configFilePath) ? readTypedJsonSync(configFilePath) : {};
-  const foreignKeys = Object.keys(configFromFile).filter(
-    (key) => !validConfigKeys.includes(key)
-  );
-  if (!isEmpty(foreignKeys)) {
-    log2.warn(`Found invalid config settings:`, foreignKeys.join(", "));
-  }
-  const config2 = Object.assign(
-    {},
-    configDefaults,
-    configFromFile
-  );
-  log2.debug("Using configuration:", inspectValue(config2));
-  __config = config2;
-  return config2;
-}
-
-// src/helpers/create-packages-registry.ts
-import fs10 from "fs-extra";
-import { globSync } from "glob";
-import path8 from "node:path";
-
-// src/helpers/find-packages-globs.ts
-import assert3 from "node:assert";
-import path7 from "node:path";
-
-// src/helpers/detect-package-manager.ts
-import fs9 from "fs-extra";
-import assert2 from "node:assert";
-import { execSync } from "node:child_process";
-import path6 from "node:path";
-
-// src/helpers/process-lockfile.ts
-import fs8 from "fs-extra";
-import assert from "node:assert";
-import path5 from "node:path";
-function getLockfileFileName(name) {
-  switch (name) {
-    case "pnpm":
-      return "pnpm-lock.yaml";
-    case "yarn":
-      return "yarn.lock";
-    case "npm":
-      return "package-lock.json";
-  }
-}
-function processLockfile({
-  workspaceRootDir,
-  targetPackageName,
-  packagesRegistry,
-  isolateDir
-}) {
-  const log2 = createLogger(getConfig().logLevel);
-  const targetPackageRelativeDir = packagesRegistry[targetPackageName].rootRelativeDir;
-  const { name } = usePackageManager();
-  const fileName = getLockfileFileName(name);
-  const lockfileSrcPath = path5.join(workspaceRootDir, fileName);
-  const lockfileDstPath = path5.join(isolateDir, fileName);
-  switch (name) {
-    case "npm": {
-      const shrinkwrapSrcPath = path5.join(
-        workspaceRootDir,
-        "npm-shrinkwrap.json"
-      );
-      const shrinkwrapDstPath = path5.join(isolateDir, "npm-shrinkwrap.json");
-      if (fs8.existsSync(shrinkwrapSrcPath)) {
-        fs8.copyFileSync(shrinkwrapSrcPath, shrinkwrapDstPath);
-        log2.debug("Copied shrinkwrap to", shrinkwrapDstPath);
-      } else {
-        fs8.copyFileSync(lockfileSrcPath, lockfileDstPath);
-        log2.debug("Copied lockfile to", lockfileDstPath);
-      }
-      return;
-    }
-    case "yarn": {
-      fs8.copyFileSync(lockfileSrcPath, lockfileDstPath);
-      log2.debug("Copied lockfile to", lockfileDstPath);
-      return;
-    }
-    case "pnpm": {
-      const origLockfile = readTypedYamlSync(lockfileSrcPath);
-      log2.debug("Read PNPM lockfile, version:", origLockfile.lockfileVersion);
-      const adaptedLockfile = structuredClone(origLockfile);
-      const targetPackageDef = adaptedLockfile.importers[targetPackageRelativeDir];
-      assert(
-        targetPackageDef,
-        `Failed to find target package in lockfile at importers[${targetPackageRelativeDir}]`
-      );
-      adaptedLockfile.importers["."] = targetPackageDef;
-      delete adaptedLockfile.importers[targetPackageRelativeDir];
-      writeTypedYamlSync(lockfileDstPath, adaptedLockfile);
-      log2.debug("Stored adapted lockfile at", lockfileDstPath);
-      return;
-    }
-  }
-}
-
-// src/helpers/detect-package-manager.ts
-var supportedPackageManagerNames = ["pnpm", "yarn", "npm"];
-var packageManager;
-function detectPackageManager(workspaceRoot) {
-  packageManager = inferFromFiles(workspaceRoot);
-  return packageManager;
-}
-function inferFromFiles(workspaceRoot) {
-  for (const name of supportedPackageManagerNames) {
-    const lockfileName = getLockfileFileName(name);
-    if (fs9.existsSync(path6.join(workspaceRoot, lockfileName))) {
-      return { name, version: getVersion(name) };
-    }
-  }
-  if (fs9.existsSync(path6.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/find-packages-globs.ts
-function findPackagesGlobs(workspaceRootDir) {
-  const log2 = createLogger(getConfig().logLevel);
-  const packageManager2 = usePackageManager();
-  switch (packageManager2.name) {
-    case "pnpm": {
-      const { packages: globs } = readTypedYamlSync(
-        path7.join(workspaceRootDir, "pnpm-workspace.yaml")
-      );
-      log2.debug("Detected pnpm packages globs:", inspectValue(globs));
-      return globs;
-    }
-    case "yarn":
-    case "npm": {
-      const workspaceRootManifestPath = path7.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;
-        assert3(
-          workspacesObject.packages,
-          "workspaces.packages must be an array"
-        );
-        return workspacesObject.packages;
-      }
-    }
-  }
-}
-
-// src/helpers/create-packages-registry.ts
-async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverride) {
-  const log2 = createLogger(getConfig().logLevel);
-  if (workspacePackagesOverride) {
-    log2.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) => fs10.lstatSync(dir).isDirectory());
-  const registry = (await Promise.all(
-    allPackages.map(async (rootRelativeDir) => {
-      const manifestPath = path8.join(rootRelativeDir, "package.json");
-      if (!fs10.existsSync(manifestPath)) {
-        log2.warn(
-          `Ignoring directory ./${rootRelativeDir} because it does not contain a package.json file`
-        );
-        return;
-      } else {
-        log2.debug(`Registering package ./${rootRelativeDir}`);
-        const manifest = await readTypedJson(
-          path8.join(rootRelativeDir, "package.json")
-        );
-        return {
-          manifest,
-          rootRelativeDir,
-          absoluteDir: path8.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 fs11 from "fs-extra";
-import path9 from "node:path";
-import outdent from "outdent";
-async function getBuildOutputDir(targetPackageDir) {
-  const config2 = getConfig();
-  const log2 = createLogger(getConfig().logLevel);
-  if (config2.buildDirName) {
-    log2.debug("Using buildDirName from config:", config2.buildDirName);
-    return path9.join(targetPackageDir, config2.buildDirName);
-  }
-  const tsconfigPath = path9.join(targetPackageDir, config2.tsconfigPath);
-  if (fs11.existsSync(tsconfigPath)) {
-    log2.debug("Found tsconfig at:", config2.tsconfigPath);
-    const tsconfig = await readTypedJson(tsconfigPath);
-    const outDir = tsconfig.compilerOptions?.outDir;
-    if (outDir) {
-      return path9.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 {
-    log2.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-local-dependencies.ts
-function listLocalDependencies(manifest, packagesRegistry, { includeDevDependencies = false } = {}) {
-  const allWorkspacePackageNames = Object.keys(packagesRegistry);
-  const localDependencyPackageNames = (includeDevDependencies ? [
-    ...Object.keys(manifest.dependencies ?? {}),
-    ...Object.keys(manifest.devDependencies ?? {})
-  ] : Object.keys(manifest.dependencies ?? {})).filter((name) => allWorkspacePackageNames.includes(name));
-  const nestedLocalDependencies = localDependencyPackageNames.flatMap(
-    (packageName) => listLocalDependencies(
-      packagesRegistry[packageName].manifest,
-      packagesRegistry,
-      { includeDevDependencies }
-    )
-  );
-  return localDependencyPackageNames.concat(nestedLocalDependencies);
-}
-
-// src/helpers/manifest.ts
-import path10 from "node:path";
-
-// src/helpers/pack-dependencies.ts
-import assert4 from "node:assert";
-async function packDependencies({
-  /**
-   * All packages found in the monorepo by workspaces declaration
-   */
-  packagesRegistry,
-  /**
-   * The package names that appear to be local dependencies
-   */
-  localDependencies,
-  /**
-   * 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 config2 = getConfig();
-  const log2 = createLogger(config2.logLevel);
-  const packedFileByName = {};
-  const { name, version } = usePackageManager();
-  const versionMajor = parseInt(version.split(".")[0], 10);
-  const usePnpmPack = !config2.avoidPnpmPack && name === "pnpm" && versionMajor >= 8;
-  if (usePnpmPack) {
-    log2.debug("Using PNPM pack instead of NPM pack");
-  }
-  for (const dependency of localDependencies) {
-    const def = packagesRegistry[dependency];
-    assert4(dependency, `Failed to find package definition for ${dependency}`);
-    const { name: name2 } = def.manifest;
-    if (packedFileByName[name2]) {
-      log2.debug(`Skipping ${name2} because it has already been packed`);
-      continue;
-    }
-    packedFileByName[name2] = await pack(
-      def.absoluteDir,
-      packDestinationDir,
-      usePnpmPack
-    );
-  }
-  return packedFileByName;
-}
-
-// src/helpers/patch-workspace-entries.ts
-import path11 from "node:path";
-function patchWorkspaceEntries(dependencies, packagesRegistry, parentRootRelativeDir) {
-  const log2 = createLogger(getConfig().logLevel);
-  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 ? path11.relative(parentRootRelativeDir, `./${def.rootRelativeDir}`) : `./${def.rootRelativeDir}`;
-        const linkPath = `file:${relativePath}`;
-        log2.debug(`Linking dependency ${key} to ${linkPath}`);
-        return [key, linkPath];
-      } else {
-        return [key, value];
-      }
-    })
-  );
-}
-
-// src/helpers/process-build-output-files.ts
-import fs12 from "fs-extra";
-import path12 from "node:path";
-var TIMEOUT_MS = 5e3;
-async function processBuildOutputFiles({
-  targetPackageDir,
-  tmpDir,
-  isolateDir
-}) {
-  const log2 = createLogger(getConfig().logLevel);
-  const packedFilePath = await pack(targetPackageDir, tmpDir);
-  const unpackDir = path12.join(tmpDir, "target");
-  const now = Date.now();
-  let isWaitingYet = false;
-  while (!fs12.existsSync(packedFilePath) && Date.now() - now < TIMEOUT_MS) {
-    if (!isWaitingYet) {
-      log2.debug(`Waiting for ${packedFilePath} to become available...`);
-    }
-    isWaitingYet = true;
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  await unpack(packedFilePath, unpackDir);
-  await fs12.copy(path12.join(unpackDir, "package"), isolateDir);
-}
-
-// src/helpers/unpack-dependencies.ts
-import fs13 from "fs-extra";
-import path13, { join } from "node:path";
-async function unpackDependencies(packedFilesByName, packagesRegistry, tmpDir, isolateDir) {
-  const log2 = createLogger(getConfig().logLevel);
-  await Promise.all(
-    Object.entries(packedFilesByName).map(async ([packageName, filePath]) => {
-      const dir = packagesRegistry[packageName].rootRelativeDir;
-      const unpackDir = join(tmpDir, dir);
-      log2.debug("Unpacking", `(temp)/${path13.basename(filePath)}`);
-      await unpack(filePath, unpackDir);
-      const destinationDir = join(isolateDir, dir);
-      await fs13.ensureDir(destinationDir);
-      await fs13.move(join(unpackDir, "package"), destinationDir, {
-        overwrite: true
-      });
-      log2.debug(
-        `Moved package files to ${getIsolateRelativePath(
-          destinationDir,
-          isolateDir
-        )}`
-      );
-    })
-  );
-}
-
-// src/index.ts
-var config = getConfig();
-var log = createLogger(config.logLevel);
-sourceMaps.install();
-async function start() {
-  const __dirname = getDirname(import.meta.url);
-  const thisPackageManifest = await readTypedJson(
-    path14.join(path14.join(__dirname, "..", "package.json"))
-  );
-  log.debug("Running isolate-package version", thisPackageManifest.version);
-  const targetPackageDir = config.targetPackagePath ? path14.join(process.cwd(), config.targetPackagePath) : process.cwd();
-  const workspaceRootDir = config.targetPackagePath ? process.cwd() : path14.join(targetPackageDir, config.workspaceRoot);
-  const buildOutputDir = await getBuildOutputDir(targetPackageDir);
-  assert5(
-    fs14.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 = path14.join(targetPackageDir, config.isolateDirName);
-  log.debug(
-    "Isolate output directory",
-    getRootRelativePath(isolateDir, workspaceRootDir)
-  );
-  if (fs14.existsSync(isolateDir)) {
-    await fs14.remove(isolateDir);
-    log.debug("Cleaned the existing isolate output directory");
-  }
-  await fs14.ensureDir(isolateDir);
-  const tmpDir = path14.join(isolateDir, "__tmp");
-  await fs14.ensureDir(tmpDir);
-  const targetPackageManifest = await readTypedJson(
-    path14.join(targetPackageDir, "package.json")
-  );
-  const packageManager2 = detectPackageManager(workspaceRootDir);
-  log.debug(
-    "Detected package manager",
-    packageManager2.name,
-    packageManager2.version
-  );
-  if (packageManager2.name === "pnpm") {
-    config.excludeLockfile = true;
-  }
-  const packagesRegistry = await createPackagesRegistry(
-    workspaceRootDir,
-    config.workspacePackages
-  );
-  const localDependencies = listLocalDependencies(
-    targetPackageManifest,
-    packagesRegistry,
-    {
-      includeDevDependencies: config.includeDevDependencies
-    }
-  );
-  const packedFilesByName = await packDependencies({
-    localDependencies,
-    packagesRegistry,
-    packDestinationDir: tmpDir
-  });
-  await unpackDependencies(
-    packedFilesByName,
-    packagesRegistry,
-    tmpDir,
-    isolateDir
-  );
-  await adaptManifestFiles(localDependencies, packagesRegistry, isolateDir);
-  await processBuildOutputFiles({
-    targetPackageDir,
-    tmpDir,
-    isolateDir
-  });
-  await adaptTargetPackageManifest(
-    targetPackageManifest,
-    packagesRegistry,
-    isolateDir
-  );
-  if (config.excludeLockfile) {
-    log.warn("Excluding the lockfile from the isolate output");
-  } else {
-    await processLockfile({
-      workspaceRootDir,
-      targetPackageName: targetPackageManifest.name,
-      isolateDir,
-      packagesRegistry
-    });
-  }
-  const npmrcPath = path14.join(workspaceRootDir, ".npmrc");
-  if (fs14.existsSync(npmrcPath)) {
-    fs14.copyFileSync(npmrcPath, path14.join(isolateDir, ".npmrc"));
-    log.debug("Copied .npmrc file to the isolate output");
-  }
-  log.debug(
-    "Deleting temp directory",
-    getRootRelativePath(tmpDir, workspaceRootDir)
-  );
-  await fs14.remove(tmpDir);
-  log.info("Isolate completed at", isolateDir);
-}
-start().catch((err) => {
-  if (err instanceof Error) {
-    log.error(err.stack);
-    process.exit(1);
-  } else {
-    console.error(err);
-  }
-});
-process.on("unhandledRejection", log.error);
 //# sourceMappingURL=index.mjs.map