@vltpkg/cli-js 0.0.0-7

package/chunk-66GJ6BNX.js

@@ -0,0 +1,2666 @@
+var global = globalThis;
+import {setTimeout,clearTimeout,setImmediate,clearImmediate,setInterval,clearInterval} from "node:timers";
+import {createRequire as _vlt_createRequire} from "node:module";
+var require = _vlt_createRequire(import.meta.filename);
+import {
+  rimraf
+} from "./chunk-OSVOPGNL.js";
+import {
+  platformCheck
+} from "./chunk-TV2RDGWY.js";
+import {
+  graphStep
+} from "./chunk-V4TLWRQW.js";
+import {
+  run
+} from "./chunk-OGUMFXHI.js";
+import {
+  Monorepo,
+  asDepID,
+  getId,
+  graphRun,
+  hydrate,
+  hydrateTuple,
+  joinDepIDTuple,
+  splitDepID
+} from "./chunk-457WPPV5.js";
+import {
+  PackageJson,
+  Spec,
+  Spec2,
+  Version,
+  defaultGitHostArchives,
+  defaultGitHosts,
+  defaultRegistries,
+  defaultRegistry,
+  defaultScopeRegistries,
+  dependencyTypes,
+  fastSplit,
+  longDependencyTypes,
+  parse,
+  shortDependencyTypes
+} from "./chunk-OKDQY2GQ.js";
+import {
+  error,
+  typeError
+} from "./chunk-LJEVKV7R.js";
+
+// ../../src/graph/src/visualization/json-output.ts
+function jsonOutput({ edges, nodes }) {
+  const res = [];
+  for (const node of nodes) {
+    if (node.importer) {
+      res.push({
+        /* c8 ignore next - name can't be missing but ts won't know */
+        name: node.name || node.id,
+        to: node
+      });
+    }
+  }
+  for (const edge of edges) {
+    res.push({
+      name: edge.name,
+      fromID: edge.from.id,
+      spec: String(edge.spec),
+      type: edge.type,
+      to: edge.to
+    });
+  }
+  return res;
+}
+
+// ../../src/graph/src/visualization/human-readable-output.ts
+var chars = new Map(
+  Object.entries({
+    connection: "\u2500",
+    down: "\u2502",
+    "last-child": "\u2514",
+    "middle-child": "\u251C",
+    t: "\u252C"
+  })
+);
+var isSelected = (options, edge, node) => !!((!node || options.nodes.includes(node)) && (!edge || options.edges.includes(edge)));
+var getTreeItems = (initialItems, options) => {
+  const seenNodes = /* @__PURE__ */ new Set();
+  const treeItems = /* @__PURE__ */ new Map();
+  const traverse = new Set(initialItems);
+  for (const item of traverse) {
+    if (item.node) {
+      if (seenNodes.has(item.node)) {
+        item.deduped = true;
+        continue;
+      }
+      seenNodes.add(item.node);
+      const edges = [...item.node.edgesOut.values()].sort(
+        (i) => Number(i.to?.importer)
+      );
+      for (const edge of edges) {
+        const toItems = treeItems.get(edge) ?? /* @__PURE__ */ new Map();
+        const nextItem = {
+          edge,
+          node: edge.to,
+          hasSibling: false,
+          padding: "",
+          prefix: "",
+          deduped: false,
+          include: isSelected(options, edge, edge.to),
+          parent: item
+        };
+        toItems.set(edge.to, nextItem);
+        treeItems.set(edge, toItems);
+        traverse.add(nextItem);
+      }
+    }
+  }
+  for (const item of [...traverse].reverse()) {
+    if (item.include && item.parent) {
+      item.parent.include = true;
+    }
+  }
+  return treeItems;
+};
+function humanReadableOutput(options, { colors }) {
+  const { importers } = options;
+  const noop = (s) => s;
+  const {
+    dim = noop,
+    red = noop,
+    reset = noop,
+    yellow = noop
+  } = colors ?? {};
+  const initialItems = /* @__PURE__ */ new Set();
+  for (const importer of importers) {
+    initialItems.add({
+      name: importer.name,
+      edge: void 0,
+      node: importer,
+      prefix: "",
+      padding: "",
+      hasSibling: false,
+      deduped: false,
+      include: isSelected(options, void 0, importer),
+      parent: void 0
+    });
+  }
+  const treeItems = getTreeItems(initialItems, options);
+  let res = "";
+  const traverse = (item) => {
+    let header = "";
+    let content = "";
+    const depIdTuple = item.node?.id && splitDepID(item.node.id);
+    const hasCustomReg = depIdTuple?.[0] === "registry" && depIdTuple[1];
+    const name = hasCustomReg ? `${depIdTuple[1]}:${item.name}` : item.name;
+    const decoratedName = options.highlightSelection && isSelected(options, item.edge, item.node) ? yellow(name) : name;
+    if (!item.node && item.include) {
+      const missing = item.edge?.type.endsWith("ptional") ? dim("(missing optional)") : red("(missing)");
+      return `${item.padding}${item.prefix}${decoratedName} ${missing}
+`;
+    }
+    const deduped = item.deduped ? ` ${dim("(deduped)")}` : "";
+    header += `${item.padding}${item.prefix}${decoratedName}${deduped}
+`;
+    if (!item.deduped) {
+      const edges = item.node ? [...item.node.edgesOut.values()] : [];
+      const nextItems = edges.map((i) => treeItems.get(i)?.get(i.to));
+      const includedItems = nextItems.filter((i) => i?.include);
+      for (const nextItem of nextItems) {
+        if (!nextItem) continue;
+        const parent = item;
+        const isLast = includedItems.indexOf(nextItem) === includedItems.length - 1;
+        const toName = nextItem.node?.version ? `${nextItem.node.name}@${nextItem.node.version}` : nextItem.node?.name;
+        const nextChar = isLast ? "last-child" : "middle-child";
+        nextItem.name = nextItem.node?.name && nextItem.edge?.name !== nextItem.edge?.to?.name ? `${nextItem.edge?.name} (${toName})` : `${nextItem.edge?.name}@${nextItem.node?.version || nextItem.edge?.spec.bareSpec}`;
+        nextItem.padding = parent.prefix.length ? `${parent.padding}${parent.hasSibling ? chars.get("down") : " "} ` : "";
+        nextItem.prefix = `${chars.get(nextChar)}${chars.get("connection")}${chars.get("connection")} `;
+        nextItem.hasSibling = !isLast;
+        content += traverse(nextItem);
+      }
+    }
+    const regularConnection = `${chars.get("connection")} `;
+    const parentConnection = `${chars.get("t")} `;
+    return item.include ? `${content ? header.replace(regularConnection, parentConnection) : header}${content}` : "";
+  };
+  for (const item of initialItems) {
+    res += traverse(item);
+  }
+  return reset(res);
+}
+
+// ../../src/satisfies/src/index.ts
+import { relative, resolve } from "node:path";
+var satisfies = (id, spec, fromLocation = process.cwd(), projectRoot = process.cwd(), monorepo) => !!id && satisfiesTuple(
+  splitDepID(id),
+  spec,
+  fromLocation,
+  projectRoot,
+  monorepo
+);
+var satisfiesTuple = (tuple, spec, fromLocation = process.cwd(), projectRoot = process.cwd(), monorepo) => {
+  const { options } = spec;
+  spec = spec.final;
+  const [type, first, second] = tuple;
+  if (spec.type !== type) return false;
+  switch (spec.type) {
+    case "registry": {
+      if (!first) {
+        if (spec.registry !== options.registry) {
+          return false;
+        }
+      } else {
+        const namedRegistry = options.registries[first];
+        if (namedRegistry && namedRegistry !== spec.registry) {
+          return false;
+        } else if (!namedRegistry && first !== spec.registry) {
+          return false;
+        }
+      }
+      if (!second) throw error("Invalid DepID", { found: tuple });
+      const [name, version] = parseNameVer(second);
+      return (
+        // mismatched name always invalid
+        name !== spec.name || !version ? false : !spec.range ? true : spec.range.test(Version.parse(version))
+      );
+    }
+    case "file": {
+      if (spec.file === void 0) return false;
+      const resolvedSpec = resolve(
+        projectRoot,
+        fromLocation,
+        spec.file
+      );
+      const resolvedId = resolve(projectRoot, first);
+      return !relative(resolvedSpec, resolvedId);
+    }
+    case "workspace": {
+      monorepo ??= Monorepo.load(projectRoot);
+      if (!spec.workspace) return false;
+      const fromID = monorepo.get(first);
+      const fromSpec = monorepo.get(spec.workspace);
+      if (fromID !== fromSpec || !fromSpec || !fromID) return false;
+      if (!spec.range) return true;
+      const v = parse(fromID.manifest.version ?? "");
+      return !!v && spec.range.test(v);
+    }
+    case "remote": {
+      return spec.remoteURL === first;
+    }
+    case "git": {
+      const {
+        gitRemote,
+        gitSelectorParsed = {},
+        gitSelector,
+        gitCommittish,
+        namedGitHost,
+        namedGitHostPath
+      } = spec;
+      if (gitRemote !== first) {
+        if (namedGitHost && namedGitHostPath) {
+          const ngh = `${namedGitHost}:`;
+          if (first.startsWith(ngh)) {
+            if (first !== ngh + namedGitHostPath) return false;
+          } else return false;
+        } else return false;
+      }
+      if (gitSelector && !second) return false;
+      const [parsed, committish] = Spec2.parseGitSelector(second ?? "");
+      if (gitCommittish && committish)
+        return !!committish.startsWith(gitCommittish);
+      for (const [k, v] of Object.entries(gitSelectorParsed)) {
+        if (parsed[k] !== v) return false;
+      }
+      return true;
+    }
+    /* c8 ignore start */
+    default: {
+      throw error("Invalid spec type", { spec });
+    }
+  }
+};
+var parseNameVer = (nv) => {
+  const at = nv.lastIndexOf("@");
+  return at <= 0 ? [nv, ""] : [nv.substring(0, at), nv.substring(at + 1)];
+};
+
+// ../../src/graph/src/edge.ts
+import { inspect } from "node:util";
+var kCustomInspect = Symbol.for("nodejs.util.inspect.custom");
+var Edge = class {
+  get [Symbol.toStringTag]() {
+    return "@vltpkg/graph.Edge";
+  }
+  [kCustomInspect](_, options) {
+    const str = inspect(
+      {
+        from: this.from.id,
+        type: this.type,
+        spec: String(this.spec),
+        to: this.to?.id
+      },
+      options
+    );
+    return `${this[Symbol.toStringTag]} ${str}`;
+  }
+  /**
+   * The Node this Edge is connecting from, this is usually the dependent.
+   */
+  from;
+  /**
+   * The node this Edge is connecting to, this is usually a direct dependency.
+   */
+  to;
+  /**
+   * What type of dependency relationship `from` and `to` nodes have.
+   */
+  type;
+  /**
+   * The defined spec value for `to` as parsed from the dependent metadata.
+   */
+  spec;
+  constructor(type, spec, from, to) {
+    this.from = from;
+    this.to = to;
+    this.type = type;
+    this.spec = spec;
+  }
+  /**
+   * The name of the dependency `to` as defined in the dependent metadata.
+   */
+  get name() {
+    return this.spec.name;
+  }
+  /**
+   * This edge was defined as part of a `devDependencies` in `package.json`
+   */
+  get dev() {
+    return this.type === "dev";
+  }
+  get optional() {
+    return this.type === "peerOptional" || this.type === "optional";
+  }
+  get peer() {
+    return this.type === "peer" || this.type === "peerOptional";
+  }
+  get peerOptional() {
+    return this.type === "peerOptional";
+  }
+  valid() {
+    return !this.to ? this.optional : satisfies(
+      this.to.id,
+      this.spec,
+      this.from.location,
+      this.from.projectRoot
+    );
+  }
+};
+
+// ../../src/dep-id/src/browser.ts
+var delimiter = "\xB7";
+var depIDRegExp = new RegExp(
+  `^((git)?${delimiter}[^${delimiter}]*${delimiter}[^${delimiter}]*(${delimiter}[^${delimiter}]*)?$|^(file|remote|workspace)${delimiter}[^${delimiter}]*)(${delimiter}[^${delimiter}]*)?$`
+);
+var isDepID = (str) => typeof str === "string" && depIDRegExp.test(str);
+var asDepID2 = (str) => {
+  if (!isDepID(str)) {
+    throw error("Expected dep id", {
+      found: str
+    });
+  }
+  return str;
+};
+var splitDepID2 = (id) => {
+  const [type, first = "", second, extra] = id.replaceAll("\xA7", "/").split(delimiter, 4);
+  const f = decodeURIComponent(first);
+  switch (type) {
+    case "git":
+    case "": {
+      if (second === void 0) {
+        throw error(`invalid ${type} id`, { found: id });
+      }
+      const t = [
+        type || "registry",
+        f,
+        decodeURIComponent(second)
+      ];
+      if (extra) t.push(decodeURIComponent(extra));
+      return t;
+    }
+    case "file":
+    case "remote":
+    case "workspace": {
+      const t = [type, f];
+      if (second) t.push(decodeURIComponent(second));
+      return t;
+    }
+    default: {
+      throw error("invalid DepID type", {
+        found: type,
+        validOptions: ["git", "file", "workspace", "remote", ""]
+      });
+    }
+  }
+};
+var hydrate2 = (id, name, options = {}) => hydrateTuple2(splitDepID2(id), name, options);
+var hydrateTuple2 = (tuple, name, options = {}) => {
+  const [type, first, second] = tuple;
+  switch (type) {
+    case "remote": {
+      if (!first)
+        throw error("no remoteURL found on remote id", {
+          found: tuple
+        });
+      return Spec.parse(name ?? "(unknown)", first);
+    }
+    case "file": {
+      if (!first) {
+        throw error("no file path found on remote id", {
+          found: tuple
+        });
+      }
+      return Spec.parse(name ?? "(unknown)", `file:${first}`, options);
+    }
+    case "registry": {
+      if (typeof first !== "string") {
+        throw error("no registry url or name in registry ID", {
+          found: tuple
+        });
+      }
+      if (!second) {
+        throw error("no name/specifier in registry ID", {
+          found: tuple
+        });
+      }
+      if (!first) {
+        const s2 = Spec.parse(second);
+        if (name && s2.name !== name) {
+          return Spec.parse(`${name}@npm:${second}`);
+        } else {
+          return s2;
+        }
+      }
+      if (!/^https?:\/\//.test(first)) {
+        const reg = options.registries?.[first];
+        if (first !== "npm" && !reg) {
+          throw error("named registry not found in options", {
+            name: first,
+            found: tuple
+          });
+        }
+        return Spec.parse(
+          name ?? "(unknown)",
+          `${first}:${second}`,
+          options
+        );
+      }
+      const s = Spec.parse(
+        name ?? "(unknown)",
+        `registry:${first}#${second}`,
+        options
+      );
+      return name && s.final.name !== name ? Spec.parse(s.final.name + "@" + s.bareSpec) : s;
+    }
+    case "git": {
+      if (!first) {
+        throw error("no git remote in git ID", {
+          found: tuple
+        });
+      }
+      return Spec.parse(
+        name ?? "(unknown)",
+        first + "#" + second,
+        options
+      );
+    }
+    case "workspace": {
+      if (!first) {
+        throw error("no name/path on workspace id", { found: tuple });
+      }
+      return name && name !== first ? Spec.parse(name, `workspace:${first}@*`, options) : Spec.parse(first, `workspace:*`, options);
+    }
+  }
+};
+
+// ../../src/graph/src/stringify-node.ts
+var stringifyNode = (node) => {
+  if (!node) return "";
+  const version = node.version ? `@${node.version}` : "";
+  const [type, ref, nameVersion] = splitDepID2(node.id);
+  if (type === "registry") {
+    const prefix = ref ? `${ref}:` : "npm:";
+    return `${prefix}${nameVersion}`;
+  } else if (type === "workspace") {
+    return `workspace:${node.name}`;
+  } else if (type === "file" && node.mainImporter) {
+    return `root:${node.name}`;
+  } else {
+    const nameVersion2 = node.name !== node.id ? `:${node.name}${version}` : "";
+    return `${type}(${ref})${nameVersion2}`;
+  }
+};
+
+// ../../src/graph/src/node.ts
+var Node = class _Node {
+  get [Symbol.toStringTag]() {
+    return "@vltpkg/graph.Node";
+  }
+  #options;
+  #location;
+  #optional = false;
+  /**
+   * True if a node is only reachable via optional or peerOptional edges from
+   * any importer.
+   *
+   * Setting this to false, if previously set to true, will also unset
+   * the flag on any optional-flagged non-optional dependencies.
+   */
+  get optional() {
+    return this.#optional;
+  }
+  set optional(optional) {
+    const before = this.#optional;
+    this.#optional = optional;
+    if (before && !optional) {
+      for (const { to, optional: optional2 } of this.edgesOut.values()) {
+        if (!optional2 && to?.optional) to.optional = false;
+      }
+    }
+  }
+  isOptional() {
+    return this.#optional;
+  }
+  #dev = false;
+  /**
+   * True if a node is only reachable via dev edges from any importer.
+   *
+   * Setting this to false, if previously set to true, will also unset
+   * the flag on any dev-flagged non-dev dependencies.
+   */
+  get dev() {
+    return this.#dev;
+  }
+  set dev(dev) {
+    const before = this.#dev;
+    this.#dev = dev;
+    if (before && !dev) {
+      for (const { to, dev: dev2 } of this.edgesOut.values()) {
+        if (!dev2 && to?.dev) to.dev = false;
+      }
+    }
+  }
+  isDev() {
+    return this.#dev;
+  }
+  /**
+   * List of edges coming into this node.
+   */
+  edgesIn = /* @__PURE__ */ new Set();
+  /**
+   * List of edges from this node into other nodes. This usually represents
+   * that the connected node is a direct dependency of this node.
+   */
+  edgesOut = /* @__PURE__ */ new Map();
+  /**
+   * A reference to the {@link DepID} this node represents in the graph.
+   */
+  id;
+  /**
+   * True if this node is an importer node.
+   */
+  importer = false;
+  /**
+   * True if this node is the project root node.
+   */
+  mainImporter = false;
+  /**
+   * A reference to the graph this node is a part of.
+   */
+  graph;
+  /**
+   * The manifest integrity value.
+   */
+  integrity;
+  /**
+   * The manifest this node represents in the graph.
+   */
+  manifest;
+  /**
+   * Project where this node resides
+   */
+  projectRoot;
+  /**
+   * For registry nodes, this is the registry we fetched them from.
+   * Needed because their un-prefixed dependencies need to come from
+   * the same registry, if it's not the default.
+   */
+  registry;
+  /**
+   * The name of the package represented by this node, this is usually
+   * equivalent to `manifest.name` but in a few ways it may differ such as
+   * nodes loaded from a lockfile that lacks a loaded manifest.
+   * This field should be used to retrieve package names instead.
+   */
+  #name;
+  get name() {
+    if (this.#name) return this.#name;
+    this.#name = this.id;
+    return this.#name;
+  }
+  /**
+   * The version of the package represented by this node, this is usually
+   * equivalent to `manifest.version` but in a few ways it may differ such as
+   * nodes loaded from a lockfile that lacks a loaded manifest.
+   * This field should be used to retrieve package versions instead.
+   */
+  version;
+  /**
+   * An address {@link PackageInfoClient} may use to extract this package.
+   */
+  resolved;
+  /**
+   * The file system location for this node.
+   */
+  get location() {
+    if (this.#location) {
+      return this.#location;
+    }
+    this.#location = `./node_modules/.vlt/${this.id}/node_modules/${this.name}`;
+    this.inVltStore = () => true;
+    return this.#location;
+  }
+  set location(location) {
+    this.#location = location;
+    if (this.inVltStore !== _Node.prototype.inVltStore) {
+      this.inVltStore = _Node.prototype.inVltStore;
+    }
+  }
+  /**
+   * The resolved location of the node in the file system.
+   */
+  resolvedLocation(scurry) {
+    return scurry.cwd.resolve(this.location).fullpath();
+  }
+  /**
+   * The location of the node_modules folder where this node's edgesOut
+   * should be linked into. For nodes in the store, this is the parent
+   * directory, since they're extracted into a node_modules folder
+   * side by side with links to their deps. For nodes outside of the store
+   * (ie, importers and arbitrary link deps) this is the node_modules folder
+   * directly inside the node's directory.
+   */
+  nodeModules(scurry) {
+    const loc = this.resolvedLocation(scurry);
+    return this.inVltStore() ? loc.substring(0, loc.length - this.name.length - 1) : scurry.resolve(loc, "node_modules");
+  }
+  constructor(options, id, manifest, spec, name, version) {
+    this.#options = options;
+    this.projectRoot = options.projectRoot;
+    if (id) {
+      this.id = id;
+    } else {
+      if (!manifest || !spec) {
+        throw typeError(
+          "A new Node needs either a manifest & spec or an id parameter",
+          {
+            manifest
+          }
+        );
+      }
+      this.id = getId(spec, manifest);
+    }
+    this.graph = options.graph;
+    this.manifest = manifest;
+    this.#name = name || this.manifest?.name;
+    this.version = version || this.manifest?.version;
+    if (this.version?.startsWith("v")) {
+      this.version = this.version.slice(1);
+    }
+  }
+  /**
+   * return true if this node is located in the vlt store
+   * memoized the first time it's called, since the store location
+   * doesn't change within the context of a single operation.
+   */
+  inVltStore() {
+    const inStore = this.location.endsWith(
+      `.vlt/${this.id}/node_modules/${this.name}`
+    );
+    this.inVltStore = () => inStore;
+    return inStore;
+  }
+  #registryNodeResolved(tuple) {
+    const spec = hydrateTuple(tuple, this.#name, this.#options);
+    this.resolved = this.manifest?.dist?.tarball || spec.conventionalRegistryTarball;
+    this.integrity ??= this.manifest?.dist?.integrity;
+  }
+  equals(other) {
+    return this.id === other.id && this.location === other.location;
+  }
+  /**
+   * Sets the node as an importer along with its location.
+   */
+  setImporterLocation(location) {
+    this.#location = location;
+    this.importer = true;
+  }
+  /**
+   * Sets the appropriate resolve / integrity value for this node.
+   * Note that other places might also set these values, like for
+   * example the lockfile that might have already have this info.
+   */
+  setResolved() {
+    const tuple = splitDepID(this.id);
+    const [type, resolved] = tuple;
+    switch (type) {
+      case "registry":
+        this.#registryNodeResolved(tuple);
+        break;
+      default:
+        this.resolved = resolved;
+        break;
+    }
+  }
+  setDefaultLocation() {
+    const def = `./node_modules/.vlt/${this.id}/node_modules/${this.name}`;
+    if (!this.importer && (!this.#location || this.#location !== def && /^(?:\.\/)?node_modules\//.test(this.#location))) {
+      this.#location = def;
+    }
+  }
+  /**
+   * Add an edge from this node connecting it to a direct dependency.
+   */
+  addEdgesTo(type, spec, node) {
+    const edge = new Edge(type, spec, this, node);
+    node?.edgesIn.add(edge);
+    this.edgesOut.set(spec.name, edge);
+    return edge;
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      version: this.version,
+      location: this.location,
+      importer: this.importer,
+      manifest: this.manifest,
+      projectRoot: this.projectRoot,
+      integrity: this.integrity,
+      resolved: this.resolved,
+      dev: this.dev,
+      optional: this.optional
+    };
+  }
+  toString() {
+    return stringifyNode(this);
+  }
+};
+
+// ../../src/graph/src/visualization/mermaid-output.ts
+var missingCount = 0;
+var nodeLabel = (node) => `"${String(node).replaceAll("@", "#64;")}"`;
+function parseNode(seenNodes, includedItems, node) {
+  if (seenNodes.has(node.id) || !includedItems.get(node)) {
+    return "";
+  }
+  seenNodes.add(node.id);
+  const edges = [...node.edgesOut.values()].map((e) => parseEdge(seenNodes, includedItems, e)).filter(Boolean).join("\n");
+  return `${encodeURIComponent(node.id)}(${nodeLabel(node)})${edges.length ? "\n" : ""}${edges}`;
+}
+function parseEdge(seenNodes, includedItems, edge) {
+  if (!includedItems.get(edge)) {
+    return "";
+  }
+  const edgeResult = `${encodeURIComponent(edge.from.id)}(${nodeLabel(edge.from)}) -->|"${String(edge.spec).replaceAll("@", "#64;")} (${edge.type})"| `;
+  const missingLabel = edge.type.endsWith("ptional") ? "Missing Optional" : "Missing";
+  if (!edge.to) {
+    return edgeResult + `missing-${missingCount++}(${missingLabel})
+`;
+  }
+  return edgeResult + `${encodeURIComponent(edge.to.id)}(${nodeLabel(edge.to)})
+` + parseNode(seenNodes, includedItems, edge.to);
+}
+function mermaidOutput({
+  edges,
+  importers,
+  nodes
+}) {
+  const seen = /* @__PURE__ */ new Set();
+  const includedItems = /* @__PURE__ */ new Map();
+  const traverse = new Set(
+    [...importers].map((i) => ({ self: i, parent: void 0 }))
+  );
+  for (const item of traverse) {
+    if (seen.has(item.self)) continue;
+    seen.add(item.self);
+    if (item.self instanceof Edge) {
+      if (edges.includes(item.self)) {
+        includedItems.set(item.self, true);
+      }
+      if (item.self.to) {
+        traverse.add({ self: item.self.to, parent: item.self });
+      }
+    }
+    if (item.self instanceof Node) {
+      if (nodes.includes(item.self)) {
+        includedItems.set(item.self, true);
+      }
+      for (const edge of item.self.edgesOut.values()) {
+        traverse.add({ self: edge, parent: item.self });
+      }
+    }
+  }
+  for (const item of [...traverse].reverse()) {
+    if (includedItems.has(item.self) && item.parent) {
+      includedItems.set(item.parent, true);
+    }
+  }
+  return "flowchart TD\n" + [...importers].map((i) => parseNode(/* @__PURE__ */ new Set(), includedItems, i)).join("\n");
+}
+
+// ../../src/graph/src/dependencies.ts
+var isDependencyTypeShort = (obj) => shortDependencyTypes.has(obj);
+var isObj = (o) => !!o && typeof o === "object";
+var isDependency = (o) => (
+  // TODO: it would be nice to have a @vltpkg/spec.isSpec method
+  isObj(o) && isObj(o.spec) && !!o.spec.type && isDependencyTypeShort(o.type)
+);
+var asDependency = (obj) => {
+  if (!isDependency(obj)) {
+    throw error("Invalid dependency", { found: obj });
+  }
+  return obj;
+};
+var shorten = (typeLong, name, manifest) => {
+  const shortName = dependencyTypes.get(typeLong);
+  if (!shortName) {
+    throw error("Invalid dependency type name", {
+      found: typeLong,
+      validOptions: [...longDependencyTypes]
+    });
+  }
+  if (shortName !== "peer") {
+    return shortName;
+  }
+  if (name && manifest?.peerDependenciesMeta?.[name]?.optional === true) {
+    return "peerOptional";
+  }
+  return "peer";
+};
+
+// ../../src/graph/src/graph.ts
+import { inspect as inspect2 } from "node:util";
+
+// ../../src/graph/src/lockfile/save.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve as resolve2 } from "node:path";
+
+// ../../src/graph/src/lockfile/types.ts
+var getFlagNumFromNode = (node) => node.optional && node.dev ? LockfileNodeFlagDevOptional : node.optional ? LockfileNodeFlagOptional : node.dev ? LockfileNodeFlagDev : LockfileNodeFlagNone;
+var getBooleanFlagsFromNum = (flags) => ({
+  dev: !!(flags & LockfileNodeFlagDev),
+  optional: !!(flags & LockfileNodeFlagOptional)
+});
+var LockfileNodeFlagNone = 0;
+var LockfileNodeFlagOptional = 1;
+var LockfileNodeFlagDev = 2;
+var LockfileNodeFlagDevOptional = 3;
+
+// ../../src/graph/src/lockfile/save.ts
+var formatNodes = (nodes, saveManifests, registry) => {
+  const arr = [...nodes].filter((node) => !node.importer);
+  const orderedNodes = arr.sort(
+    (a, b) => a.id.localeCompare(b.id, "en")
+  );
+  const res = {};
+  for (const node of orderedNodes) {
+    const customRegistry = node.resolved && registry && !node.resolved.startsWith(registry);
+    const resolved = customRegistry ? node.resolved : void 0;
+    const location = node.id.startsWith("file") || node.location.endsWith(
+      "/node_modules/.vlt/" + node.id + "/node_modules/" + node.name
+    ) ? void 0 : node.location;
+    const flags = getFlagNumFromNode(node);
+    const lockfileNode = [flags, node.name];
+    if (node.integrity) {
+      lockfileNode[2] = node.integrity;
+    }
+    if (resolved) {
+      lockfileNode[3] = resolved;
+    }
+    if (location) {
+      lockfileNode[4] = location;
+    }
+    if (saveManifests) {
+      lockfileNode[5] = node.manifest;
+    }
+    res[node.id] = lockfileNode;
+  }
+  return res;
+};
+var formatEdges = (edges) => Object.fromEntries(
+  [...edges].sort(
+    (a, b) => (
+      /* c8 ignore start - nondeterminstic and annoying to test */
+      // sort importers to the top, then alphabetically by
+      // id, type, target
+      Number(b.from.importer) - Number(a.from.importer) || a.from.id.localeCompare(b.from.id, "en") || a.type.localeCompare(b.type, "en") || (a.to?.id ?? "").localeCompare(b.to?.id ?? "")
+    )
+    /* c8 ignore stop */
+  ).map((edge) => [
+    `${edge.from.id} ${edge.spec.name}`,
+    `${edge.type} ${edge.spec.bareSpec || "*"} ${edge.to?.id ?? "MISSING"}`
+  ])
+);
+var isRecordStringString = (registries) => !(!registries || typeof registries === "string");
+var removeDefaultItems = (defaultItems, items) => {
+  const res = {};
+  for (const [key, value] of Object.entries(items)) {
+    if (!defaultItems[key] || defaultItems[key] !== value) {
+      res[key] = value;
+    }
+  }
+  return res;
+};
+var lockfileData = ({
+  graph,
+  "git-hosts": gitHosts,
+  "git-host-archives": gitHostArchives,
+  registry,
+  registries,
+  saveManifests,
+  "scope-registries": scopeRegistries
+}) => {
+  const cleanGitHosts = isRecordStringString(gitHosts) ? removeDefaultItems(defaultGitHosts, gitHosts) : void 0;
+  const cleanGitHostArchives = isRecordStringString(gitHostArchives) ? removeDefaultItems(defaultGitHostArchives, gitHostArchives) : void 0;
+  const cleanRegistries = isRecordStringString(registries) ? removeDefaultItems(defaultRegistries, registries) : void 0;
+  const cleanScopeRegistries = isRecordStringString(scopeRegistries) ? removeDefaultItems(defaultScopeRegistries, scopeRegistries) : void 0;
+  const hasItems = (clean) => clean && Object.keys(clean).length;
+  return {
+    options: {
+      ...hasItems(cleanScopeRegistries) ? { "scope-registries": cleanScopeRegistries } : void 0,
+      ...registry !== void 0 && registry !== defaultRegistry ? { registry } : void 0,
+      ...hasItems(registries) ? { registries: cleanRegistries } : void 0,
+      ...hasItems(cleanGitHosts) ? { "git-hosts": cleanGitHosts } : void 0,
+      ...hasItems(cleanGitHostArchives) ? { "git-host-archives": cleanGitHostArchives } : void 0
+    },
+    nodes: formatNodes(graph.nodes.values(), saveManifests, registry),
+    edges: formatEdges(graph.edges)
+  };
+};
+var extraFormat = (jsonString) => {
+  const str = `${jsonString}
+`;
+  const [init, ...parts] = str.split('  "nodes": {');
+  const res = [init];
+  for (const part of parts) {
+    res.push(
+      part.replaceAll("\n      ", "").replaceAll("\n    ]", "]")
+    );
+  }
+  return res.join('  "nodes": {');
+};
+var saveData = (data, fileName, saveManifests = false) => {
+  const json = JSON.stringify(data, null, 2);
+  const content = saveManifests ? json : extraFormat(json);
+  writeFileSync(fileName, content);
+};
+var save = (options) => {
+  const { graph } = options;
+  const data = lockfileData({ ...options, saveManifests: false });
+  const fileName = resolve2(graph.projectRoot, "vlt-lock.json");
+  return saveData(data, fileName, false);
+};
+var saveHidden = (options) => {
+  const { graph } = options;
+  const data = lockfileData({ ...options, saveManifests: true });
+  const fileName = resolve2(
+    graph.projectRoot,
+    "node_modules/.vlt-lock.json"
+  );
+  mkdirSync(dirname(fileName), { recursive: true });
+  return saveData(data, fileName, true);
+};
+
+// ../../src/graph/src/graph.ts
+var kCustomInspect2 = Symbol.for("nodejs.util.inspect.custom");
+var mainDepID = joinDepIDTuple(["file", "."]);
+var getMap = (m) => m ?? /* @__PURE__ */ new Map();
+var Graph = class {
+  get [Symbol.toStringTag]() {
+    return "@vltpkg/graph.Graph";
+  }
+  #options;
+  #nodeOptions;
+  /**
+   * A {@link Monorepo} instance, used for managing workspaces.
+   */
+  monorepo;
+  /**
+   * An inventory with all manifests related to an install.
+   */
+  manifests;
+  /**
+   * A set of all edges in this graph.
+   */
+  edges = /* @__PURE__ */ new Set();
+  /**
+   * Map registered dep ids to the node that represent them in the graph.
+   */
+  nodes = /* @__PURE__ */ new Map();
+  /**
+   * Map of nodes by their name
+   */
+  nodesByName = /* @__PURE__ */ new Map();
+  /**
+   * Cached resolutions for spec lookups
+   */
+  resolutions = /* @__PURE__ */ new Map();
+  /**
+   * Reverse map of resolutions
+   */
+  resolutionsReverse = /* @__PURE__ */ new Map();
+  /**
+   * A set of importer nodes in this graph.
+   */
+  importers = /* @__PURE__ */ new Set();
+  /**
+   * The {@link Node} that represents the project root `package.json`.
+   */
+  mainImporter;
+  /**
+   * A set of extraneous dependencies found when building the graph.
+   */
+  extraneousDependencies = /* @__PURE__ */ new Set();
+  /**
+   * The root of the project this graph represents
+   */
+  projectRoot;
+  constructor(options) {
+    const { mainManifest, monorepo } = options;
+    this.#options = options;
+    this.manifests = getMap(options.manifests);
+    this.projectRoot = options.projectRoot;
+    this.#nodeOptions = {
+      ...this.#options,
+      graph: this
+    };
+    const mainImporterLocation = ".";
+    const mainImporterSpec = Spec2.parse(
+      mainManifest.name || "(root)",
+      mainImporterLocation
+    );
+    const mainImporter = this.addNode(
+      mainDepID,
+      mainManifest,
+      mainImporterSpec
+    );
+    mainImporter.setImporterLocation(mainImporterLocation);
+    mainImporter.mainImporter = true;
+    this.mainImporter = mainImporter;
+    this.importers.add(mainImporter);
+    this.manifests.set(mainImporter.id, mainManifest);
+    this.monorepo = monorepo;
+    if (this.monorepo) {
+      for (const ws of this.monorepo) {
+        const wsNode = this.addNode(
+          ws.id,
+          ws.manifest,
+          void 0,
+          ws.name
+        );
+        wsNode.setImporterLocation(`./${ws.path}`);
+        if (wsNode.manifest) {
+          this.manifests.set(wsNode.id, wsNode.manifest);
+        }
+        this.importers.add(wsNode);
+      }
+    }
+  }
+  /**
+   * Delete all nodes that are unreachable from the importers.
+   * The collection of deleted nodes is returned.
+   *
+   * NOTE: This can be extremely slow for large graphs, and is almost always
+   * unnecessary! Only call when it is known that some unreachable nodes may
+   * have been created, for example when deleting the unneeded subgraph when an
+   * optional node fails to resolve/install.
+   */
+  gc() {
+    const { nodes } = this;
+    this.nodes = /* @__PURE__ */ new Map();
+    const marked = new Set(this.importers);
+    for (const imp of marked) {
+      nodes.delete(imp.id);
+      this.nodes.set(imp.id, imp);
+      for (const { to } of imp.edgesOut.values()) {
+        if (!to || marked.has(to)) continue;
+        marked.add(to);
+        nodes.delete(to.id);
+        this.nodes.set(to.id, to);
+      }
+    }
+    for (const node of nodes.values()) {
+      this.removeNode(node);
+    }
+    return nodes;
+  }
+  /**
+   * Create a new edge between two nodes of the graph in case both exist,
+   * in case the destination node does not exists, then a dangling edge,
+   * pointing to nothing will be created to represent that missing dependency.
+   */
+  addEdge(type, spec, from, to) {
+    if (spec.name === "(unknown)") {
+      if (to) {
+        spec.name = to.name || "(unknown)";
+        spec.spec = `${to.name}@${spec.bareSpec}`;
+      } else {
+        throw error(
+          "Impossible to place a missing, nameless dependency",
+          { spec }
+        );
+      }
+    }
+    const existing = from.edgesOut.get(spec.name);
+    if (existing) {
+      const edge = existing;
+      if (edge.type === type && edge.spec.bareSpec === spec.bareSpec) {
+        if (to && to !== edge.to) {
+          edge.to = to;
+          edge.to.edgesIn.add(edge);
+        }
+        return edge;
+      }
+      this.edges.delete(edge);
+    }
+    const f = from;
+    const edgeOut = f.addEdgesTo(type, spec, to);
+    this.edges.add(edgeOut);
+    return edgeOut;
+  }
+  /**
+   * Find an existing node to satisfy a dependency
+   */
+  findResolution(spec, fromNode) {
+    const f = spec.final;
+    const fromPref = f.type === "file" ? fromNode.location + " : " : "";
+    const sf = fromPref + String(f);
+    const cached = this.resolutions.get(sf);
+    if (cached) return cached;
+    const nbn = this.nodesByName.get(f.name);
+    if (!nbn) return void 0;
+    for (const node of nbn) {
+      if (satisfies(
+        node.id,
+        f,
+        fromNode.location,
+        this.projectRoot,
+        this.monorepo
+      )) {
+        this.resolutions.set(sf, node);
+        this.resolutionsReverse.get(node)?.add(sf);
+        return node;
+      }
+    }
+  }
+  /**
+   * Create a new node in the graph.
+   */
+  addNode(id, manifest, spec, name, version) {
+    const node = new Node(
+      this.#nodeOptions,
+      id,
+      manifest,
+      spec,
+      name,
+      version
+    );
+    this.nodes.set(node.id, node);
+    const nbn = this.nodesByName.get(node.name) ?? /* @__PURE__ */ new Set();
+    nbn.add(node);
+    this.nodesByName.set(node.name, nbn);
+    if (spec) {
+      const f = String(spec.final);
+      if (spec.final.type !== "file") {
+        this.resolutions.set(f, node);
+        const rrev = this.resolutionsReverse.get(node) ?? /* @__PURE__ */ new Set();
+        rrev.add(f);
+        this.resolutionsReverse.set(node, rrev);
+      }
+    }
+    if (manifest) {
+      this.manifests.set(node.id, manifest);
+    }
+    return node;
+  }
+  /**
+   * Place a new package into the graph representation, creating the new
+   * edges and possibly new nodes that are to be expected when traversing
+   * the graph in a top-down direction, e.g: from importers to leafs.
+   *
+   * For different uses that are not a direct top-down traversal of the graph
+   * consider using `addNode()` and `addEdge()` instead.
+   */
+  placePackage(fromNode, depType, spec, manifest, id) {
+    if (!manifest && !id) {
+      this.addEdge(depType, spec, fromNode);
+      return;
+    }
+    const flags = {
+      dev: fromNode.dev || depType === "dev",
+      optional: fromNode.optional || depType === "optional" || depType === "peerOptional"
+    };
+    const depId = id || manifest && getId(spec, manifest);
+    if (!depId) {
+      throw error("Could not find dep id when placing package", {
+        spec,
+        manifest
+      });
+    }
+    const toFoundNode = this.nodes.get(depId);
+    if (toFoundNode) {
+      this.addEdge(depType, spec, fromNode, toFoundNode);
+      toFoundNode.dev &&= flags.dev;
+      toFoundNode.optional &&= flags.optional;
+      return toFoundNode;
+    }
+    const toNode = this.addNode(depId, manifest);
+    toNode.registry = spec.registry;
+    toNode.dev = flags.dev;
+    toNode.optional = flags.optional;
+    this.addEdge(depType, spec, fromNode, toNode);
+    return toNode;
+  }
+  /**
+   * Removes a node and its relevant edges from the graph.
+   *
+   * If a replacement is provided, then any edges that were previously
+   * pointing to the removed node will be directed to the replacement,
+   * if it is valid to do so.
+   */
+  removeNode(node, replacement) {
+    this.nodes.delete(node.id);
+    const nbn = this.nodesByName.get(node.name);
+    if (nbn?.size === 1) this.nodesByName.delete(node.name);
+    else nbn?.delete(node);
+    for (const r of this.resolutionsReverse.get(node) ?? /* @__PURE__ */ new Set()) {
+      this.resolutions.delete(r);
+    }
+    this.resolutionsReverse.delete(node);
+    this.manifests.delete(node.id);
+    for (const edge of node.edgesOut.values()) {
+      this.edges.delete(edge);
+    }
+    for (const edge of node.edgesIn) {
+      if (replacement && satisfies(
+        replacement.id,
+        edge.spec,
+        edge.from.location,
+        this.projectRoot,
+        this.monorepo
+      )) {
+        edge.to = replacement;
+      } else {
+        edge.from.edgesOut.delete(edge.spec.name);
+        this.edges.delete(edge);
+      }
+    }
+  }
+  toJSON() {
+    return lockfileData({
+      ...this.#options,
+      graph: this,
+      saveManifests: true
+    });
+  }
+  [kCustomInspect2](_, options) {
+    const data = this.toJSON();
+    return `${this[Symbol.toStringTag]} ${inspect2(data, options)}`;
+  }
+};
+
+// ../../src/graph/src/lockfile/load.ts
+import { readFileSync } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+
+// ../../src/graph/src/lockfile/load-edges.ts
+var loadEdges = (graph, edges, options) => {
+  const entries = Object.entries(edges);
+  for (const [key, value] of entries) {
+    const [fromId, specName] = fastSplit(key, " ", 2);
+    const [depType, valRest] = fastSplit(value, " ", 2);
+    const vrSplit = valRest?.lastIndexOf(" ") ?? -1;
+    if (!valRest || !depType || !fromId || !specName || vrSplit < 1) {
+      continue;
+    }
+    const spec = Spec.parse(
+      specName,
+      valRest.substring(0, vrSplit),
+      options
+    );
+    const toId = valRest.substring(vrSplit + 1);
+    const from = graph.nodes.get(asDepID2(fromId));
+    if (!from) {
+      throw error("Edge info missing its `from` node", {
+        found: {
+          nodes: [...graph.nodes].map(([id]) => id),
+          from,
+          fromId,
+          edge: { [key]: value }
+        }
+      });
+    }
+    const to = toId === "MISSING" ? void 0 : graph.nodes.get(asDepID2(toId));
+    if (!isDependencyTypeShort(depType)) {
+      throw error("Found unsupported dependency type in lockfile", {
+        validOptions: [...longDependencyTypes]
+      });
+    }
+    graph.addEdge(depType, spec, from, to);
+  }
+};
+
+// ../../src/graph/src/lockfile/load-nodes.ts
+var loadNodes = (graph, nodes) => {
+  const entries = Object.entries(nodes);
+  for (const [id, lockfileNode] of entries) {
+    if (graph.nodes.has(id)) continue;
+    const [flags, name, integrity, resolved, location, manifest] = lockfileNode;
+    const [type, , spec] = splitDepID2(id);
+    const node = manifest ? graph.addNode(id, manifest) : graph.addNode(
+      id,
+      void 0,
+      void 0,
+      name ?? void 0,
+      type === "registry" && spec.indexOf("@") > 0 ? spec.split("@").slice(-1)[0] : void 0
+    );
+    const { dev, optional } = getBooleanFlagsFromNum(flags);
+    node.dev = dev;
+    node.optional = optional;
+    node.integrity = integrity ?? void 0;
+    node.resolved = resolved ?? void 0;
+    if (!node.resolved) node.setResolved();
+    if (location) node.location = location;
+  }
+};
+
+// ../../src/graph/src/lockfile/load.ts
+var loadLockfile = (projectRoot, lockfilePath) => JSON.parse(
+  readFileSync(resolve3(projectRoot, lockfilePath), {
+    encoding: "utf8"
+  })
+);
+var load = (options) => {
+  const { projectRoot } = options;
+  return loadObject(
+    options,
+    loadLockfile(projectRoot, "vlt-lock.json")
+  );
+};
+var loadHidden = (options) => {
+  const { projectRoot } = options;
+  return loadObject(
+    options,
+    loadLockfile(projectRoot, "node_modules/.vlt-lock.json")
+  );
+};
+var loadObject = (options, lockfileData2) => {
+  const { mainManifest, scurry } = options;
+  const packageJson = options.packageJson ?? new PackageJson();
+  const monorepo = options.monorepo ?? Monorepo.maybeLoad(options.projectRoot, { packageJson, scurry });
+  const {
+    "scope-registries": scopeRegistries,
+    registry,
+    registries,
+    "git-hosts": gitHosts,
+    "git-host-archives": gitHostArchives
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  } = lockfileData2.options || {};
+  const mergedOptions = {
+    ...options,
+    "scope-registries": {
+      ...options["scope-registries"],
+      ...scopeRegistries
+    },
+    registry: registry ?? options.registry,
+    registries: {
+      ...options.registries,
+      ...registries
+    },
+    "git-hosts": {
+      ...options["git-hosts"],
+      ...gitHosts
+    },
+    "git-host-archives": {
+      ...options["git-host-archives"],
+      ...gitHostArchives
+    }
+  };
+  const graph = new Graph({
+    ...mergedOptions,
+    mainManifest,
+    monorepo
+  });
+  loadNodes(graph, lockfileData2.nodes);
+  loadEdges(graph, lockfileData2.edges, mergedOptions);
+  return graph;
+};
+
+// ../../src/graph/src/actual/load.ts
+var pathBasedType = /* @__PURE__ */ new Set(["file", "workspace"]);
+var isPathBasedType = (type) => pathBasedType.has(type);
+var getPathBasedId = (spec, path) => isPathBasedType(spec.type) ? joinDepIDTuple([spec.type, path]) : void 0;
+var findDepID = ({ parent, name }) => parent?.name === ".vlt" ? asDepID(name) : parent?.isCWD === false ? findDepID(parent) : void 0;
+var findNodeModules = ({
+  parent,
+  name,
+  isCWD
+}) => parent?.name === "node_modules" ? parent : parent && name !== ".vlt" && !isCWD ? findNodeModules(parent) : void 0;
+var findName = ({ parent, name }) => parent?.name.startsWith("@") ? `${parent.name}/${name}` : name;
+var isStringArray = (a) => Array.isArray(a) && !a.some((b) => typeof b !== "string");
+var getDeps = (node) => {
+  const dependencies = /* @__PURE__ */ new Map();
+  const bundleDeps = node.manifest?.bundleDependencies ?? [];
+  const bundled = !node.importer && !node.id.startsWith("git") && isStringArray(bundleDeps) ? new Set(bundleDeps) : /* @__PURE__ */ new Set();
+  for (const depType of longDependencyTypes) {
+    const obj = node.manifest?.[depType];
+    if (depType === "devDependencies" && !node.importer && !node.id.startsWith("git") && !node.id.startsWith("file")) {
+      continue;
+    }
+    if (obj) {
+      for (const [name, bareSpec] of Object.entries(obj)) {
+        if (bundled.has(name)) continue;
+        dependencies.set(name, {
+          name,
+          type: depType,
+          bareSpec,
+          registry: node.registry
+        });
+      }
+    }
+  }
+  return dependencies;
+};
+var readDir = (scurry, currDir, fromNodeName) => {
+  const res = /* @__PURE__ */ new Set();
+  for (const entry of scurry.readdirSync(currDir)) {
+    if (entry.name.startsWith(".")) continue;
+    if (entry.name.startsWith("@")) {
+      const scopedItems = readDir(scurry, entry, fromNodeName);
+      for (const scopedItem of scopedItems) {
+        res.add(scopedItem);
+      }
+      continue;
+    }
+    if (!entry.isSymbolicLink()) continue;
+    const realpath = entry.realpathSync();
+    if (!realpath) {
+      continue;
+    }
+    const alias = findName(entry);
+    const name = findName(realpath);
+    res.add({
+      alias,
+      name,
+      realpath
+    });
+  }
+  return res;
+};
+var parseDir = (options, scurry, packageJson, depsFound, graph, fromNode, currDir) => {
+  const { loadManifests } = options;
+  const dependencies = getDeps(fromNode);
+  const seenDeps = /* @__PURE__ */ new Set();
+  const readItems = readDir(
+    scurry,
+    currDir,
+    fromNode.name
+  );
+  for (const { alias, name, realpath } of readItems) {
+    let node;
+    seenDeps.add(alias);
+    if (!loadManifests) {
+      const depId = findDepID(realpath);
+      if (depId) {
+        const h = hydrate(depId, alias, {
+          ...options,
+          registry: fromNode.registry
+        });
+        node = graph.placePackage(
+          fromNode,
+          "prod",
+          // defaults to prod deps
+          h,
+          // uses spec from hydrated id
+          {
+            name,
+            ...h.registrySpec ? { version: h.registrySpec } : null
+          },
+          depId
+        );
+      }
+    }
+    const deps = dependencies.get(alias);
+    if (!node) {
+      const mani = packageJson.read(realpath.fullpath());
+      const type = deps?.type || "dependencies";
+      const bareSpec = deps?.bareSpec || "*";
+      const depType = shorten(type, alias, fromNode.manifest);
+      const spec = Spec2.parse(alias, bareSpec, {
+        ...options,
+        registry: fromNode.registry
+      });
+      const maybeId = getPathBasedId(spec, realpath.relativePosix());
+      node = graph.placePackage(
+        fromNode,
+        depType,
+        spec,
+        mani,
+        maybeId
+      );
+    }
+    if (node) {
+      if (loadManifests && !deps) {
+        const [edge] = node.edgesIn;
+        if (edge) {
+          graph.extraneousDependencies.add(edge);
+        }
+      }
+      node.location = `./${realpath.relativePosix()}`;
+      const node_modules = findNodeModules(realpath);
+      if (node_modules) {
+        depsFound.set(node, node_modules);
+      }
+    }
+  }
+  for (const { name, type, bareSpec } of dependencies.values()) {
+    if (!seenDeps.has(name)) {
+      const depType = shorten(type, name, fromNode.manifest);
+      const spec = Spec2.parse(name, bareSpec, {
+        ...options,
+        registry: fromNode.registry
+      });
+      graph.placePackage(fromNode, depType, spec);
+    }
+  }
+};
+var load2 = (options) => {
+  const done = graphStep("actual");
+  const {
+    skipHiddenLockfile = true,
+    projectRoot,
+    packageJson,
+    scurry,
+    monorepo
+  } = options;
+  const mainManifest = options.mainManifest ?? packageJson.read(projectRoot);
+  if (!skipHiddenLockfile) {
+    try {
+      const graph2 = loadHidden({
+        projectRoot,
+        mainManifest,
+        packageJson,
+        monorepo,
+        scurry
+      });
+      return graph2;
+    } catch {
+    }
+  }
+  const graph = new Graph({ ...options, mainManifest });
+  const depsFound = /* @__PURE__ */ new Map();
+  for (const importer of graph.importers) {
+    depsFound.set(
+      importer,
+      scurry.cwd.resolve(`${importer.location}/node_modules`)
+    );
+  }
+  for (const [node, path] of depsFound.entries()) {
+    parseDir(
+      options,
+      scurry,
+      packageJson,
+      depsFound,
+      graph,
+      node,
+      path
+    );
+  }
+  done();
+  return graph;
+};
+
+// ../../src/graph/src/ideal/remove-satisfied-specs.ts
+var removeSatisfiedSpecs = ({
+  add,
+  graph
+}) => {
+  for (const [depID, dependencies] of add.entries()) {
+    const importer = graph.nodes.get(depID);
+    if (!importer) {
+      throw error("Referred importer node id could not be found", {
+        found: depID
+      });
+    }
+    for (const [name, dependency] of dependencies) {
+      const edge = importer.edgesOut.get(name);
+      if (!edge) {
+        continue;
+      }
+      if (satisfies(
+        edge.to?.id,
+        dependency.spec,
+        edge.from.location,
+        graph.projectRoot,
+        graph.monorepo
+      )) {
+        dependencies.delete(name);
+      }
+    }
+  }
+  for (const [depID, dependencies] of add.entries()) {
+    if (dependencies.size === 0) {
+      add.delete(depID);
+    }
+  }
+};
+
+// ../../src/graph/src/ideal/get-importer-specs.ts
+var hasDepName = (importer, edge) => {
+  for (const depType of longDependencyTypes) {
+    const listedDeps = importer.manifest?.[depType];
+    if (listedDeps && Object.hasOwn(listedDeps, edge.name))
+      return true;
+  }
+  return false;
+};
+var AddImportersDependenciesMapImpl = class extends Map {
+  modifiedDependencies = false;
+};
+var RemoveImportersDependenciesMapImpl = class extends Map {
+  modifiedDependencies = false;
+};
+var getImporterSpecs = ({
+  add,
+  graph,
+  remove
+}) => {
+  const addResult = new AddImportersDependenciesMapImpl();
+  const removeResult = new RemoveImportersDependenciesMapImpl();
+  for (const importer of graph.importers) {
+    const addDeps = /* @__PURE__ */ new Map();
+    const removeDeps = /* @__PURE__ */ new Set();
+    for (const edge of importer.edgesOut.values()) {
+      if (!hasDepName(importer, edge) && !add.get(importer.id)?.has(edge.name)) {
+        removeDeps.add(edge.name);
+        removeResult.modifiedDependencies = true;
+      }
+    }
+    for (const depType of longDependencyTypes) {
+      const deps = Object.entries(importer.manifest?.[depType] ?? {});
+      for (const [depName, depSpec] of deps) {
+        const edge = importer.edgesOut.get(depName);
+        if (!edge?.to) {
+          addDeps.set(
+            depName,
+            asDependency({
+              spec: Spec2.parse(depName, depSpec),
+              type: shorten(depType, depName, importer.manifest)
+            })
+          );
+        }
+      }
+    }
+    addResult.set(importer.id, addDeps);
+    removeResult.set(importer.id, removeDeps);
+  }
+  for (const [id, addDeps] of add.entries()) {
+    const deps = addResult.get(id);
+    if (!deps) {
+      throw error("Not an importer", { found: id });
+    }
+    for (const [name, dep] of addDeps.entries()) {
+      deps.set(name, dep);
+    }
+  }
+  for (const [key, removeSet] of remove) {
+    const importerRemoveItem = removeResult.get(key);
+    if (importerRemoveItem) {
+      for (const depName of removeSet) {
+        importerRemoveItem.add(depName);
+      }
+    }
+  }
+  for (const [key, removeItem] of removeResult) {
+    if (removeItem.size === 0) {
+      removeResult.delete(key);
+    }
+  }
+  removeSatisfiedSpecs({
+    add: addResult,
+    graph
+  });
+  for (const addDeps of addResult.values()) {
+    if (addDeps.size > 0) {
+      addResult.modifiedDependencies = true;
+      break;
+    }
+  }
+  return {
+    add: addResult,
+    remove: removeResult
+  };
+};
+
+// ../../src/graph/src/remove-optional-subgraph.ts
+var removeOptionalSubgraph = (graph, startingNode) => {
+  const removed = /* @__PURE__ */ new Set();
+  for (const node of findOptionalSubgraph(startingNode)) {
+    graph.removeNode(node);
+    removed.add(node);
+  }
+  return removed;
+};
+function* findOptionalSubgraph(node, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(node)) return;
+  seen.add(node);
+  yield node;
+  for (const { from, optional } of node.edgesIn) {
+    if (from.isOptional() && !optional) {
+      for (const dep of findOptionalSubgraph(from, seen)) yield dep;
+    }
+  }
+}
+
+// ../../src/graph/src/ideal/append-nodes.ts
+var shouldInstallDepType = (node, depType) => depType !== "devDependencies" || node.importer || node.id.startsWith("git");
+var getFileTypeInfo = (spec, fromNode, scurry) => {
+  const f = spec.final;
+  if (f.type !== "file") return;
+  if (!f.file) {
+    throw error("no path on file specifier", { spec });
+  }
+  const target = scurry.cwd.resolve(fromNode.location).resolve(f.file);
+  const path = target.relativePosix();
+  const id = joinDepIDTuple(["file", path]);
+  return {
+    path,
+    id,
+    isDirectory: !!target.lstatSync()?.isDirectory()
+  };
+};
+var isStringArray2 = (a) => Array.isArray(a) && !a.some((b) => typeof b !== "string");
+var appendNodes = async (add, packageInfo, graph, fromNode, deps, scurry, options, seen) => {
+  if (seen.has(fromNode.id)) return;
+  seen.add(fromNode.id);
+  await Promise.all(
+    deps.map(async ({ spec, type }) => {
+      const fileTypeInfo = getFileTypeInfo(spec, fromNode, scurry);
+      const existingNode = graph.findResolution(spec, fromNode);
+      if (existingNode) {
+        graph.addEdge(type, spec, fromNode, existingNode);
+        return;
+      }
+      const edgeOptional = type === "optional" || type === "peerOptional";
+      const mani = await packageInfo.manifest(spec, { from: scurry.resolve(fromNode.location) }).catch((er) => {
+        if (edgeOptional || fromNode.optional) {
+          return void 0;
+        }
+        throw er;
+      });
+      if (mani?.name && spec.name === "(unknown)") {
+        const s = add.get(String(spec));
+        if (s) {
+          add.delete(String(spec));
+          spec = Spec2.parse(mani.name, spec.bareSpec, options);
+          const n = asDependency({
+            ...s,
+            spec
+          });
+          add.set(mani.name, n);
+        }
+      }
+      if (!mani) {
+        if (!edgeOptional && fromNode.isOptional()) {
+          removeOptionalSubgraph(graph, fromNode);
+          return;
+        } else if (edgeOptional) {
+          return;
+        } else {
+          throw error("failed to resolve dependency", {
+            spec,
+            from: fromNode.location
+          });
+        }
+      }
+      const node = graph.placePackage(
+        fromNode,
+        type,
+        spec,
+        mani,
+        fileTypeInfo?.id
+      );
+      if (!node) {
+        throw error("failed to place package", {
+          from: fromNode.location,
+          spec
+        });
+      }
+      if (fileTypeInfo?.path && fileTypeInfo.isDirectory) {
+        node.location = fileTypeInfo.path;
+      }
+      node.setResolved();
+      const nestedAppends = [];
+      const bundleDeps = node.manifest?.bundleDependencies;
+      const bundled = new Set(
+        node.id.startsWith("git") || node.importer || !isStringArray2(bundleDeps) ? [] : bundleDeps
+      );
+      const nextDeps = [];
+      for (const depTypeName of longDependencyTypes) {
+        const depRecord = mani[depTypeName];
+        if (depRecord && shouldInstallDepType(node, depTypeName)) {
+          for (const [name, bareSpec] of Object.entries(depRecord)) {
+            if (bundled.has(name)) continue;
+            nextDeps.push({
+              type: shorten(depTypeName, name, mani),
+              spec: Spec2.parse(name, bareSpec, {
+                ...options,
+                registry: spec.registry
+              })
+            });
+          }
+        }
+      }
+      if (nextDeps.length) {
+        nestedAppends.push(
+          appendNodes(
+            add,
+            packageInfo,
+            graph,
+            node,
+            nextDeps,
+            scurry,
+            options,
+            seen
+          )
+        );
+      }
+      await Promise.all(nestedAppends);
+    })
+  );
+};
+
+// ../../src/graph/src/ideal/add-nodes.ts
+var addNodes = async ({
+  add,
+  graph,
+  packageInfo,
+  scurry,
+  ...specOptions
+}) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [depID, dependencies] of add) {
+    const importer = graph.nodes.get(depID);
+    if (!importer) {
+      throw error("Could not find importer", { found: depID });
+    }
+    const deps = [...dependencies.values()];
+    for (const { spec } of deps) {
+      const node = importer.edgesOut.get(spec.name)?.to;
+      if (node) graph.removeNode(node);
+    }
+    await appendNodes(
+      dependencies,
+      packageInfo,
+      graph,
+      importer,
+      deps,
+      scurry,
+      specOptions,
+      seen
+    );
+  }
+};
+
+// ../../src/graph/src/ideal/remove-nodes.ts
+var removeNodes = ({
+  graph,
+  remove
+}) => {
+  for (const [depID, names] of remove) {
+    const importer = graph.nodes.get(depID);
+    if (!importer) {
+      throw error("Could not find importer", { found: depID });
+    }
+    for (const name of names) {
+      const node = importer.edgesOut.get(name)?.to;
+      if (node) graph.removeNode(node);
+    }
+  }
+};
+
+// ../../src/graph/src/ideal/build-ideal-from-starting-graph.ts
+var buildIdealFromStartingGraph = async (options) => {
+  const importerSpecs = getImporterSpecs(options);
+  options.add.modifiedDependencies = options.add.modifiedDependencies || importerSpecs.add.modifiedDependencies;
+  options.remove.modifiedDependencies = options.remove.modifiedDependencies || importerSpecs.remove.modifiedDependencies;
+  for (const [importerId, deps] of importerSpecs.add) {
+    if (!options.add.has(importerId)) {
+      options.add.set(importerId, deps);
+      continue;
+    }
+    for (const [depName, dep] of deps) {
+      if (!options.add.get(importerId)?.has(depName)) {
+        options.add.get(importerId)?.set(depName, dep);
+      }
+    }
+  }
+  await addNodes(options);
+  for (const node of options.graph.nodes.values()) {
+    node.setDefaultLocation();
+  }
+  removeNodes({ ...options, remove: importerSpecs.remove });
+  options.graph.gc();
+  return options.graph;
+};
+
+// ../../src/graph/src/ideal/build.ts
+var getMap2 = (m) => m ?? /* @__PURE__ */ new Map();
+var build = async (options) => {
+  const done = graphStep("build");
+  const { packageInfo, packageJson, scurry, monorepo } = options;
+  const mainManifest = options.mainManifest ?? packageJson.read(options.projectRoot);
+  let graph;
+  try {
+    graph = load({
+      ...options,
+      mainManifest,
+      monorepo
+    });
+  } catch {
+    graph = load2({
+      ...options,
+      mainManifest,
+      monorepo
+    });
+  }
+  const res = await buildIdealFromStartingGraph({
+    ...options,
+    scurry,
+    add: getMap2(options.add),
+    graph,
+    packageInfo,
+    remove: getMap2(options.remove)
+  });
+  done();
+  return res;
+};
+
+// ../../src/rollback-remove/src/index.ts
+import { spawn } from "node:child_process";
+import { rename } from "node:fs/promises";
+import { basename, dirname as dirname2 } from "node:path";
+
+// ../../src/rollback-remove/src/remove.ts
+import { resolve as resolve4 } from "node:path";
+var __CODE_SPLIT_SCRIPT_NAME = resolve4(import.meta.dirname, "rollback-remove-src-remove.js");
+
+// ../../src/rollback-remove/src/index.ts
+var RollbackRemove = class {
+  #key = String(Math.random()).substring(2);
+  #paths = /* @__PURE__ */ new Map();
+  async rm(path) {
+    const target = `${dirname2(path)}/.VLT.DELETE.${this.#key}.${basename(path)}`;
+    this.#paths.set(path, target);
+    await rename(path, target).catch((e) => {
+      if (e instanceof Error && "code" in e && e.code === "ENOENT") {
+        this.#paths.delete(path);
+        return;
+      }
+      throw e;
+    });
+  }
+  confirm() {
+    if (!this.#paths.size) return;
+    const child = spawn(
+      process.execPath,
+      [__CODE_SPLIT_SCRIPT_NAME],
+      {
+        stdio: ["pipe", "ignore", "ignore"],
+        detached: true
+      }
+    );
+    child.unref();
+    for (const path of this.#paths.values()) {
+      child.stdin.write(path + "\0");
+    }
+    child.stdin.end();
+    this.#paths.clear();
+  }
+  async rollback() {
+    const promises = [];
+    for (const [original, moved] of this.#paths) {
+      promises.push(
+        rimraf(original).catch(() => {
+        }).then(() => rename(moved, original))
+      );
+    }
+    await Promise.all(promises);
+    this.#paths.clear();
+  }
+};
+
+// ../../src/graph/src/reify/index.ts
+import { availableParallelism as availableParallelism2 } from "node:os";
+
+// ../../node_modules/.pnpm/promise-call-limit@3.0.2/node_modules/promise-call-limit/dist/esm/index.js
+import * as os from "node:os";
+var defLimit = "availableParallelism" in os ? Math.max(1, os.availableParallelism() - 1) : Math.max(1, os.cpus().length - 1);
+var callLimit = (queue, { limit: limit2 = defLimit, rejectLate } = {}) => new Promise((res, rej) => {
+  let active = 0;
+  let current = 0;
+  const results = [];
+  let rejected = false;
+  let rejection;
+  const reject = (er) => {
+    if (rejected)
+      return;
+    rejected = true;
+    rejection ??= er;
+    if (!rejectLate)
+      rej(rejection);
+  };
+  let resolved = false;
+  const resolve5 = () => {
+    if (resolved || active > 0)
+      return;
+    resolved = true;
+    res(results);
+  };
+  const run2 = () => {
+    const c = current++;
+    if (c >= queue.length)
+      return rejected ? reject() : resolve5();
+    active++;
+    const step = queue[c];
+    if (!step)
+      throw new Error("walked off queue");
+    results[c] = step().then((result) => {
+      active--;
+      results[c] = result;
+      return result;
+    }, (er) => {
+      active--;
+      reject(er);
+    }).then((result) => {
+      if (rejected && active === 0)
+        return rej(rejection);
+      run2();
+      return result;
+    });
+  };
+  for (let i = 0; i < limit2; i++)
+    run2();
+});
+
+// ../../src/graph/src/diff.ts
+var kCustomInspect3 = Symbol.for("nodejs.util.inspect.custom");
+var Diff = class {
+  from;
+  to;
+  projectRoot;
+  /**
+   * If changes need to be made later for failures of optional nodes,
+   * set this flag so that we know to call graph.gc() at the appropriate time.
+   */
+  hadOptionalFailures = false;
+  /**
+   * Collection of nodes to add and delete
+   */
+  nodes = {
+    /** Nodes in the `to` graph that are not in the `from` graph */
+    add: /* @__PURE__ */ new Set(),
+    /** Nodes in the `from` graph that are not in the `to` graph */
+    delete: /* @__PURE__ */ new Set()
+  };
+  /**
+   * Collection of nodes to add and delete
+   */
+  edges = {
+    /** Edges in the `to` graph that are not found in the `from` graph */
+    add: /* @__PURE__ */ new Set(),
+    /** Edges in the `from` graph that are not found in the `to` graph */
+    delete: /* @__PURE__ */ new Set()
+  };
+  get [Symbol.toStringTag]() {
+    return "@vltpkg/graph.Diff";
+  }
+  constructor(from, to) {
+    this.from = from;
+    this.to = to;
+    this.projectRoot = from.projectRoot;
+    if (to.projectRoot !== from.projectRoot) {
+      throw error("projectRoot mismatch in Graph diff", {
+        wanted: from.projectRoot,
+        found: to.projectRoot
+      });
+    }
+    for (const [id, node] of this.from.nodes) {
+      if (!this.to.nodes.get(id)?.equals(node)) {
+        this.nodes.delete.add(node);
+      }
+    }
+    for (const [id, node] of this.to.nodes) {
+      if (!this.from.nodes.get(id)?.equals(node)) {
+        this.nodes.add.add(node);
+      }
+    }
+    for (const edge of this.to.edges) {
+      const fromNode = this.from.nodes.get(edge.from.id);
+      const fromEdge = fromNode?.edgesOut.get(edge.spec.name);
+      if (fromEdge?.to?.id === edge.to?.id) continue;
+      if (fromEdge?.to) this.edges.delete.add(fromEdge);
+      if (edge.to) this.edges.add.add(edge);
+    }
+    for (const edge of this.from.edges) {
+      const toNode = this.to.nodes.get(edge.from.id);
+      const toEdge = toNode?.edgesOut.get(edge.spec.name);
+      if (toEdge?.to?.id === edge.to?.id) continue;
+      if (edge.to) this.edges.delete.add(edge);
+      if (toEdge?.to) this.edges.add.add(toEdge);
+    }
+  }
+  [kCustomInspect3](_, options) {
+    const red = options?.colors ? ["\x1B[31m", "\x1B[m"] : ["", ""];
+    const green = options?.colors ? ["\x1B[32m", "\x1B[m"] : ["", ""];
+    const lines = [];
+    for (const node of this.nodes.add) {
+      lines.push(`+ ${node.id}`);
+    }
+    for (const node of this.nodes.delete) {
+      lines.push(`- ${node.id}`);
+    }
+    for (const edge of this.edges.add) {
+      const to = edge.to?.id ?? "";
+      lines.push(
+        `+ ${edge.from.id} ${edge.type} ${edge.spec} ${to}`.trim()
+      );
+    }
+    for (const edge of this.edges.delete) {
+      const to = edge.to?.id ?? "";
+      lines.push(
+        `- ${edge.from.id} ${edge.type} ${edge.spec} ${to}`.trim()
+      );
+    }
+    const wrap = (s, c) => c.join(s);
+    const color = options?.colors ? (s) => wrap(s, s.startsWith("+") ? green : red) : (s) => s;
+    return `${this[Symbol.toStringTag]} {
+${lines.sort((a, b) => a.substring(1).localeCompare(b.substring(1), "en")).map((s) => "  " + color(s)).join("\n")}
+}`;
+  }
+};
+
+// ../../src/graph/src/uninstall.ts
+var uninstall = async (options, remove) => {
+  const mainManifest = options.packageJson.read(options.projectRoot);
+  const graph = await build({
+    ...options,
+    remove,
+    mainManifest,
+    loadManifests: true
+  });
+  const act = load2({
+    ...options,
+    mainManifest,
+    loadManifests: true
+  });
+  const diff = await reify({
+    ...options,
+    remove,
+    actual: act,
+    graph,
+    loadManifests: true
+  });
+  return { graph, diff };
+};
+
+// ../../src/graph/src/index.ts
+var actual = { load: load2 };
+var lockfile = {
+  load,
+  loadEdges,
+  loadNodes,
+  save
+};
+
+// ../../src/graph/src/reify/add-edge.ts
+import { mkdir, symlink } from "node:fs/promises";
+import { dirname as dirname3, relative as relative2 } from "node:path";
+
+// ../../src/graph/src/reify/bin-paths.ts
+var parseScope = (scoped) => {
+  if (scoped.startsWith("@")) {
+    const [scope, name, ...rest] = scoped.split("/");
+    if (scope && name && rest.length === 0) return [scope, name];
+  }
+  return [void 0, scoped];
+};
+var binPaths = (manifest) => {
+  const { name, bin } = manifest;
+  if (bin) {
+    if (name && typeof bin === "string") {
+      const [_scope, pkg] = parseScope(name);
+      return { [pkg]: bin };
+    } else if (typeof bin === "object") {
+      return bin;
+    }
+  }
+  return {};
+};
+
+// ../../src/graph/src/reify/add-edge.ts
+var clobberSymlink = async (target, link, remover, type = "file") => {
+  await mkdir(dirname3(link), { recursive: true });
+  try {
+    await symlink(target, link, type);
+  } catch (e) {
+    const er = e;
+    if (er.code === "EEXIST") {
+      return remover.rm(link).then(() => symlink(target, link));
+    } else {
+      throw er;
+    }
+  }
+};
+var addEdge = async (edge, manifest, scurry, remover) => {
+  if (!edge.to) return;
+  const binRoot = scurry.resolve(
+    edge.from.nodeModules(scurry),
+    ".bin"
+  );
+  const path = scurry.resolve(
+    edge.from.nodeModules(scurry),
+    edge.spec.name
+  );
+  const promises = [];
+  const target = relative2(
+    dirname3(path),
+    edge.to.resolvedLocation(scurry)
+  );
+  promises.push(clobberSymlink(target, path, remover, "dir"));
+  const bp = binPaths(manifest);
+  for (const [key, val] of Object.entries(bp)) {
+    const link = scurry.resolve(binRoot, key);
+    const target2 = relative2(binRoot, scurry.resolve(path, val));
+    promises.push(clobberSymlink(target2, link, remover));
+  }
+  await Promise.all(promises);
+};
+
+// ../../src/graph/src/reify/add-edges.ts
+var addEdges = (diff, packageJson, scurry, remover) => {
+  const actions = [];
+  for (const edge of diff.edges.add) {
+    const { to } = edge;
+    if (!to) continue;
+    const mani = to.manifest ?? packageJson.read(to.resolvedLocation(scurry));
+    actions.push(addEdge(edge, mani, scurry, remover));
+  }
+  return actions;
+};
+
+// ../../src/graph/src/reify/optional-fail.ts
+function optionalFail(diff, node) {
+  return node.isOptional() ? () => del(diff, node) : void 0;
+}
+var del = (diff, node) => {
+  diff.hadOptionalFailures = true;
+  for (const del2 of removeOptionalSubgraph(diff.to, node)) {
+    diff.nodes.delete.add(del2);
+    diff.nodes.add.delete(del2);
+  }
+  diff.nodes.add.delete(node);
+  diff.nodes.delete.add(node);
+};
+
+// ../../src/graph/src/reify/add-nodes.ts
+var addNodes2 = (diff, scurry, remover, options, packageInfo) => {
+  const actions = [];
+  for (const node of diff.nodes.add) {
+    const { manifest = {} } = node;
+    if (!node.inVltStore()) continue;
+    const target = node.resolvedLocation(scurry);
+    const from = scurry.resolve("");
+    const spec = hydrate(node.id, manifest.name, options);
+    const onErr = optionalFail(diff, node);
+    const { integrity, resolved } = node;
+    if (onErr && (manifest.deprecated || !platformCheck(
+      manifest,
+      process.version,
+      process.platform,
+      process.arch
+    ))) {
+      onErr();
+      continue;
+    }
+    actions.push(
+      () => remover.rm(target).then(
+        () => onErr ? packageInfo.extract(spec, target, { from, integrity, resolved }).then((x) => x, onErr) : packageInfo.extract(spec, target, {
+          from,
+          integrity,
+          resolved
+        })
+      )
+    );
+  }
+  return actions;
+};
+
+// ../../src/graph/src/reify/build.ts
+import { statSync } from "node:fs";
+import { chmod } from "node:fs/promises";
+
+// ../../src/graph/src/non-empty-list.ts
+var isNonEmptyList = (list) => !!list.length;
+var nonEmptyList = (nodes) => isNonEmptyList(nodes) ? nodes : void 0;
+
+// ../../src/graph/src/reify/build.ts
+var build2 = async (diff, packageJson, scurry) => {
+  const graph = diff.to;
+  const nodes = nonEmptyList([...graph.importers]);
+  if (!nodes) return;
+  await graphRun({
+    graph: nodes,
+    visit: async (node, signal, path) => {
+      if (!node.importer && !diff.nodes.add.has(node)) return;
+      await visit(packageJson, scurry, node, signal, path).then(
+        (x) => x,
+        optionalFail(diff, node)
+      );
+    },
+    getDeps: (node) => {
+      const deps = [];
+      for (const { to } of node.edgesOut.values()) {
+        if (to) deps.push(to);
+      }
+      return deps;
+    }
+  });
+};
+var visit = async (packageJson, scurry, node, signal, _path) => {
+  node.manifest ??= packageJson.read(node.resolvedLocation(scurry));
+  const { manifest } = node;
+  const { scripts = {} } = manifest;
+  const {
+    install: install2,
+    preinstall,
+    postinstall,
+    prepare,
+    preprepare,
+    postprepare
+  } = scripts;
+  const runInstall = !!(install2 || preinstall || postinstall);
+  if (runInstall) {
+    await run({
+      signal,
+      arg0: "install",
+      ignoreMissing: true,
+      packageJson,
+      cwd: node.resolvedLocation(scurry),
+      projectRoot: node.projectRoot,
+      manifest
+    });
+  }
+  const prepable = node.id.startsWith("git") || node.importer || !node.inVltStore();
+  const runPrepare = !!(prepare || preprepare || postprepare) && prepable;
+  if (runPrepare) {
+    await run({
+      signal,
+      arg0: "prepare",
+      ignoreMissing: true,
+      packageJson,
+      cwd: node.resolvedLocation(scurry),
+      projectRoot: node.projectRoot,
+      manifest
+    });
+  }
+  const chmods = [];
+  for (const bin of Object.values(binPaths(manifest))) {
+    const path = scurry.resolve(
+      `${node.resolvedLocation(scurry)}/${bin}`
+    );
+    chmods.push(makeExecutable(path));
+  }
+  await Promise.all(chmods);
+};
+var execMode = 0;
+var makeExecutable = async (path) => {
+  if (!execMode) {
+    execMode = statSync(path).mode & 511 | 73;
+  }
+  await chmod(path, execMode);
+};
+
+// ../../src/graph/src/reify/delete-edge.ts
+var rmBinPosix = (remover, bin) => {
+  return [remover.rm(bin)];
+};
+var rmBinWin32 = (remover, bin) => {
+  return [
+    remover.rm(bin),
+    remover.rm(bin + ".cmd"),
+    remover.rm(bin + ".pwsh")
+  ];
+};
+var rmBin = process.platform === "win32" ? rmBinWin32 : rmBinPosix;
+var deleteEdge = async (edge, scurry, remover) => {
+  const {
+    spec: { name },
+    to
+  } = edge;
+  const nm = edge.from.nodeModules(scurry);
+  const path = scurry.resolve(nm, name);
+  const binRoot = scurry.cwd.resolve(`${nm}/.bin`);
+  const promises = [];
+  promises.push(remover.rm(path));
+  const manifest = to?.manifest;
+  if (manifest) {
+    for (const key of Object.keys(binPaths(manifest))) {
+      const bin = binRoot.resolve(key).fullpath();
+      promises.push(...rmBin(remover, bin));
+    }
+  }
+  await Promise.all(promises);
+};
+
+// ../../src/graph/src/reify/delete-edges.ts
+var deleteEdges = (diff, scurry, remover) => {
+  const promises = [];
+  for (const edge of diff.edges.delete) {
+    if (diff.nodes.delete.has(edge.from) && edge.from.inVltStore()) {
+      continue;
+    }
+    promises.push(() => deleteEdge(edge, scurry, remover));
+  }
+  return promises;
+};
+
+// ../../src/graph/src/reify/delete-nodes.ts
+var deleteNodes = (diff, remover, scurry) => {
+  const store = scurry.resolve("node_modules/.vlt");
+  const rmActions = [];
+  for (const node of diff.nodes.delete) {
+    if (!node.inVltStore()) continue;
+    rmActions.push(remover.rm(scurry.resolve(store, node.id)));
+  }
+  return rmActions;
+};
+
+// ../../src/graph/src/reify/rollback.ts
+var rollback = async (remover, diff, scurry) => {
+  const promises = [];
+  const store = scurry.resolve("node_modules/.vlt");
+  const backRoller = new RollbackRemove();
+  for (const node of diff.nodes.add) {
+    if (!node.inVltStore()) continue;
+    const path = scurry.resolve(store, node.id);
+    promises.push(backRoller.rm(path).catch(() => {
+    }));
+  }
+  for (const edge of diff.edges.add) {
+    promises.push(deleteEdge(edge, scurry, backRoller));
+  }
+  await Promise.all(promises).catch(() => {
+  });
+  backRoller.confirm();
+  await remover.rollback().catch(() => {
+  });
+};
+
+// ../../src/graph/src/reify/update-importers-package-json.ts
+var SAVE_PREFIX = "^";
+var depTypesMap = /* @__PURE__ */ new Map([
+  ["prod", "dependencies"],
+  ["dev", "devDependencies"],
+  ["peer", "peerDependencies"],
+  ["peerOptional", "peerDependencies"],
+  ["optional", "optionalDependencies"]
+]);
+var addOrRemoveDeps = (importerId, graph, addOrRemove) => {
+  const importer = graph.nodes.get(importerId);
+  if (!importer) {
+    throw error("Failed to retrieve importer node", {
+      found: importerId
+    });
+  }
+  const manifest = importer.manifest;
+  if (!manifest) {
+    throw error("Could not find manifest data for node", {
+      found: importerId
+    });
+  }
+  const deps = addOrRemove?.get(importerId);
+  if (!deps) {
+    throw error("Failed to retrieve added deps info", {
+      manifest
+    });
+  }
+  let manifestChanged = false;
+  for (const deleteNameOrAddItem of deps) {
+    if (typeof deleteNameOrAddItem === "string") {
+      const name = deleteNameOrAddItem;
+      for (const depType of longDependencyTypes) {
+        if (manifest[depType]?.[name]) {
+          delete manifest[depType][name];
+          manifestChanged = true;
+        }
+      }
+    } else {
+      const [name, dep] = deleteNameOrAddItem;
+      const depType = depTypesMap.get(dep.type);
+      if (!depType) {
+        throw error("Failed to retrieve dependency type", {
+          validOptions: [...depTypesMap.keys()],
+          found: dep.type
+        });
+      }
+      const node = importer.edgesOut.get(name)?.to;
+      if (!node) {
+        throw error("Dependency node could not be found");
+      }
+      const [nodeType] = splitDepID(node.id);
+      const dependencies = manifest[depType] ?? (manifest[depType] = {});
+      dependencies[name] = nodeType === "registry" && (!dep.spec.final.semver || !dep.spec.final.range) ? dep.spec.subspec && dep.spec.namedRegistry ? `${dep.spec.final.namedRegistry}:${dep.spec.final.name}@${SAVE_PREFIX}${node.version}` : `${SAVE_PREFIX}${node.version}` : dep.spec.bareSpec;
+      manifestChanged = true;
+    }
+  }
+  return manifestChanged ? manifest : void 0;
+};
+var updatePackageJson = ({
+  add,
+  graph,
+  packageJson,
+  remove
+}) => {
+  const manifestsToUpdate = /* @__PURE__ */ new Set();
+  const operations = /* @__PURE__ */ new Set([add, remove]);
+  for (const operation of operations) {
+    if (operation) {
+      for (const importerId of operation.keys()) {
+        const manifest = addOrRemoveDeps(importerId, graph, operation);
+        if (manifest) {
+          manifestsToUpdate.add(manifest);
+        }
+      }
+    }
+  }
+  const commit = () => {
+    for (const manifest of manifestsToUpdate) {
+      packageJson.save(manifest);
+    }
+  };
+  return commit;
+};
+
+// ../../src/graph/src/reify/index.ts
+var limit = Math.max(availableParallelism2() - 1, 1) * 8;
+var reify = async (options) => {
+  const done = graphStep("reify");
+  const { graph, scurry } = options;
+  const actual2 = options.actual ?? load2({
+    ...options,
+    loadManifests: true
+  });
+  const diff = new Diff(actual2, graph);
+  const remover = new RollbackRemove();
+  let success = false;
+  try {
+    await reify_(options, diff, remover);
+    remover.confirm();
+    success = true;
+  } finally {
+    if (!success) {
+      await rollback(remover, diff, scurry).catch(() => {
+      });
+    }
+  }
+  done();
+  return diff;
+};
+var reify_ = async (options, diff, remover) => {
+  const { add, remove, packageInfo, packageJson, scurry } = options;
+  const saveImportersPackageJson = add?.modifiedDependencies || remove?.modifiedDependencies ? updatePackageJson({
+    add,
+    remove,
+    graph: options.graph,
+    packageJson
+  }) : void 0;
+  const lfData = lockfileData(options);
+  const actions = addNodes2(
+    diff,
+    scurry,
+    remover,
+    options,
+    packageInfo
+  ).concat(deleteEdges(diff, scurry, remover));
+  if (actions.length) await callLimit(actions, { limit });
+  const edgeActions = addEdges(
+    diff,
+    packageJson,
+    scurry,
+    remover
+  );
+  if (edgeActions.length) await Promise.all(edgeActions);
+  await build2(diff, packageJson, scurry);
+  lockfile.save(options);
+  if (diff.hadOptionalFailures) {
+    for (const node of options.graph.gc().values()) {
+      diff.nodes.add.delete(node);
+      diff.nodes.delete.add(node);
+    }
+  }
+  saveHidden(options);
+  const rmActions = deleteNodes(
+    diff,
+    remover,
+    scurry
+  );
+  if (rmActions.length) await Promise.all(rmActions);
+  saveImportersPackageJson?.();
+  saveData(lfData, scurry.resolve("vlt-lock.json"), false);
+};
+
+// ../../src/graph/src/install.ts
+var install = async (options, add) => {
+  const mainManifest = options.packageJson.read(options.projectRoot);
+  const graph = await build({
+    ...options,
+    add,
+    mainManifest,
+    loadManifests: true
+  });
+  const act = load2({
+    ...options,
+    mainManifest,
+    loadManifests: true
+  });
+  const diff = await reify({
+    ...options,
+    add,
+    actual: act,
+    graph,
+    loadManifests: true
+  });
+  return { graph, diff };
+};
+
+export {
+  callLimit,
+  splitDepID2 as splitDepID,
+  hydrate2 as hydrate,
+  asDependency,
+  jsonOutput,
+  humanReadableOutput,
+  mermaidOutput,
+  install,
+  uninstall,
+  actual
+};
+//# sourceMappingURL=chunk-66GJ6BNX.js.map