vlt 0.0.0-3 → 0.0.0-5

package/chunk-JMGSFQ32.js

@@ -1,969 +0,0 @@
-var global = globalThis;
-import {Buffer} from "node:buffer";
-import {setImmediate, clearImmediate} from "node:timers";
-import {createRequire as _vlt_createRequire} from 'node:module';
-var require = _vlt_createRequire(import.meta.filename);
-import {
-  PathScurry,
-  globSync,
-  minimatch
-} from "./chunk-O7CDQZDW.js";
-import {
-  PackageJson,
-  Spec2 as Spec,
-  parse
-} from "./chunk-POVPHE2F.js";
-import {
-  error
-} from "./chunk-ZRNJWPYC.js";
-
-// ../../src/dep-id/src/index.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 asDepID = (str) => {
-  if (!isDepID(str)) {
-    throw error("Expected dep id", {
-      found: str
-    });
-  }
-  return str;
-};
-var joinDepIDTuple = (list) => {
-  const [type, first, second, extra] = list;
-  const f = encode(first);
-  switch (type) {
-    case "registry":
-      return `${delimiter}${f}${delimiter}${encode(second)}${extra ? `${delimiter}${encode(extra)}` : ""}`;
-    case "git":
-      return `${type}${delimiter}${f}${delimiter}${encode(second)}${extra ? `${delimiter}${encode(extra)}` : ""}`;
-    default:
-      return `${type}${delimiter}${f}${second ? `${delimiter}${encode(second)}` : ""}`;
-  }
-};
-var encode = (s) => encodeURIComponent(s).replaceAll("%40", "@").replaceAll("%2f", "\xA7").replaceAll("%2F", "\xA7");
-var splitDepID = (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 hydrate = (id, name, options = {}) => hydrateTuple(splitDepID(id), name, options);
-var hydrateTuple = (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);
-    }
-  }
-};
-var omitDefReg = (s) => !s || s === "https://registry.npmjs.org" || s === "https://registry.npmjs.org/" ? "" : s;
-var getTuple = (spec, mani) => {
-  const f = spec.final;
-  switch (f.type) {
-    case "registry": {
-      const reg = omitDefReg(f.registry);
-      if (!f.namedRegistry && reg) {
-        for (const [alias, host] of Object.entries(
-          spec.options.registries
-        )) {
-          if (reg === host) {
-            f.namedRegistry = alias;
-            break;
-          }
-        }
-      }
-      return [
-        f.type,
-        f.namedRegistry ?? reg,
-        `${mani.name ?? spec.name}@${mani.version ?? spec.bareSpec}`
-      ];
-    }
-    case "git": {
-      const {
-        namedGitHost,
-        namedGitHostPath,
-        gitRemote,
-        gitSelector = ""
-      } = f;
-      if (!gitRemote)
-        throw error("no host on git specifier", { spec });
-      if (namedGitHost) {
-        if (!namedGitHostPath) {
-          throw error("named git host without path portion", {
-            spec
-          });
-        }
-        return [
-          f.type,
-          `${namedGitHost}:${namedGitHostPath}`,
-          gitSelector
-        ];
-      } else {
-        return [f.type, gitRemote, gitSelector];
-      }
-    }
-    case "remote": {
-      const { remoteURL } = f;
-      if (!remoteURL)
-        throw error("no URL on remote specifier", { spec });
-      return [f.type, remoteURL];
-    }
-    case "file":
-    case "workspace":
-      throw error("Path-based dep ids are not supported", { spec });
-  }
-};
-var getId = (spec, mani) => joinDepIDTuple(getTuple(spec, mani));
-
-// ../../src/workspaces/src/index.ts
-import { readFileSync, statSync } from "node:fs";
-
-// ../../node_modules/.pnpm/graph-run@1.0.4/node_modules/graph-run/dist/esm/index.js
-import { setMaxListeners } from "node:events";
-var RunnerBase = class {
-  results = /* @__PURE__ */ new Map();
-  settled = /* @__PURE__ */ new Map();
-  dependents = /* @__PURE__ */ new Map();
-  directDependents = /* @__PURE__ */ new Map();
-  options;
-  abortController;
-  failFast;
-  errors = [];
-  from;
-  constructor(options, from) {
-    const ac = new AbortController();
-    this.from = from ?? this.constructor;
-    this.abortController = ac;
-    setMaxListeners(Infinity, ac.signal);
-    this.options = options;
-    if (!options.graph.length) {
-      const er = new Error("no nodes provided to graph traversal", {
-        cause: {
-          found: options.graph,
-          wanted: "[first: Node, ...rest: Node[]]"
-        }
-      });
-      Error.captureStackTrace(er, from);
-      throw er;
-    }
-    this.failFast = options.failFast !== false;
-    const { signal } = options;
-    if (signal !== void 0) {
-      signal.addEventListener("abort", (reason) => ac.abort(reason), {
-        once: true,
-        signal: ac.signal
-      });
-    }
-  }
-  route(n, d) {
-    const dependents = this.dependents.get(d);
-    if (!dependents?.has(n))
-      return void 0;
-    const directDependents = this.directDependents.get(d);
-    if (!directDependents)
-      return void 0;
-    if (directDependents.has(n)) {
-      return [n, d];
-    }
-    const queue = [
-      ...directDependents
-    ].map((dd) => [dd, d]);
-    let step = void 0;
-    while (void 0 !== (step = queue.shift())) {
-      if (!dependents.has(step[0]))
-        continue;
-      if (step[0] === n) {
-        return step;
-      }
-      const ddd = this.directDependents.get(step[0]);
-      if (ddd) {
-        for (const d2 of ddd) {
-          queue.push([d2, ...step]);
-        }
-      }
-    }
-  }
-  cycleCheck(n, path, d) {
-    const dependents = this.dependents.get(n) ?? /* @__PURE__ */ new Set();
-    this.dependents.set(n, dependents);
-    const isCycle = dependents.has(d);
-    if (isCycle) {
-      const cycle = this.route(d, n);
-      if (!cycle) {
-        throw new Error("cycle detected, but cycle route not found");
-      }
-      cycle.unshift(n);
-      this.onCycle(d, cycle, path);
-      return true;
-    }
-    const depDD = this.directDependents.get(d) ?? /* @__PURE__ */ new Set();
-    this.directDependents.set(d, depDD);
-    depDD.add(n);
-    const depDependents = this.dependents.get(d) ?? /* @__PURE__ */ new Set();
-    this.dependents.set(d, depDependents);
-    for (const n2 of dependents) {
-      depDependents.add(n2);
-    }
-    depDependents.add(n);
-    return false;
-  }
-  handleError(er, n, path) {
-    this.errors.push(er);
-    this.settled.set(n, {
-      status: "rejected",
-      reason: er
-    });
-    if (this.failFast) {
-      this.abortController.abort(er);
-      const e = new Error("failed graph traversal", {
-        cause: {
-          node: n,
-          path,
-          cause: er
-        }
-      });
-      Error.captureStackTrace(e, this.from);
-      throw e;
-    }
-  }
-  handleValue(value, n) {
-    this.results.set(n, value);
-    this.settled.set(n, {
-      status: "fulfilled",
-      value
-    });
-  }
-};
-var Runner = class extends RunnerBase {
-  running = /* @__PURE__ */ new Map();
-  async getDeps(n) {
-    if (this.abortController.signal.aborted)
-      return [];
-    const deps = await this.options.getDeps(n);
-    for (const d of deps) {
-      const dependents = this.dependents.get(d) ?? /* @__PURE__ */ new Set();
-      this.dependents.set(d, dependents);
-      dependents.add(n);
-      const depDD = this.directDependents.get(d) ?? /* @__PURE__ */ new Set();
-      this.directDependents.set(d, depDD);
-      depDD.add(n);
-    }
-    return deps;
-  }
-  async visit(n, path, depResults) {
-    const { signal } = this.abortController;
-    return this.options.visit(n, signal, path, depResults);
-  }
-  async onCycle(n, cycle, path) {
-    if (this.abortController.signal.aborted)
-      return;
-    await this.options.onCycle?.(n, cycle, path);
-  }
-  async #walk(n, path) {
-    const r = this.running.get(n);
-    if (r)
-      return r;
-    if (this.settled.get(n))
-      return;
-    const p = this.#step(n, path).then(() => {
-      this.running.delete(n);
-    }, (er) => {
-      this.running.delete(n);
-      throw er;
-    });
-    this.running.set(n, p);
-    return p;
-  }
-  async #step(n, path) {
-    const dependents = this.dependents.get(n) ?? /* @__PURE__ */ new Set();
-    this.dependents.set(n, dependents);
-    const deps = await this.getDeps(n);
-    const awaiting = [];
-    const depPath = [...path, n];
-    for (const d of deps) {
-      if (this.abortController.signal.aborted)
-        return;
-      if (d === n)
-        continue;
-      if (this.cycleCheck(n, depPath, d))
-        continue;
-      if (this.settled.get(d))
-        continue;
-      awaiting.push(this.running.get(d) ?? this.#walk(d, depPath));
-    }
-    if (this.abortController.signal.aborted)
-      return;
-    await Promise.all(awaiting);
-    if (this.abortController.signal.aborted)
-      return;
-    const depRes = new Map(deps.map((d) => [d, this.results.get(d)]));
-    try {
-      this.handleValue(await this.visit(n, path, depRes), n);
-    } catch (er) {
-      this.handleError(er, n, path);
-    }
-  }
-  async run() {
-    const promises = [];
-    for (const n of this.options.graph) {
-      promises.push(this.#walk(n, []));
-    }
-    await Promise.all(promises);
-  }
-};
-var RunnerSync = class extends RunnerBase {
-  getDeps(n) {
-    if (this.abortController.signal.aborted)
-      return [];
-    return this.options.getDeps(n);
-  }
-  visit(n, path, depResults) {
-    const { signal } = this.abortController;
-    return this.options.visit(n, signal, path, depResults);
-  }
-  onCycle(n, cycle, path) {
-    if (this.abortController.signal.aborted)
-      return;
-    this.options.onCycle?.(n, cycle, path);
-  }
-  #walk(n, path) {
-    if (this.settled.get(n))
-      return;
-    this.#step(n, path);
-  }
-  #step(n, path) {
-    const dependents = this.dependents.get(n) ?? /* @__PURE__ */ new Set();
-    this.dependents.set(n, dependents);
-    const deps = this.getDeps(n);
-    const depPath = [...path, n];
-    for (const d of deps) {
-      if (this.abortController.signal.aborted)
-        return;
-      if (d === n)
-        continue;
-      if (this.cycleCheck(n, depPath, d))
-        continue;
-      if (!this.settled.get(d))
-        this.#walk(d, depPath);
-    }
-    if (this.abortController.signal.aborted)
-      return;
-    const depRes = new Map(deps.map((d) => [d, this.results.get(d)]));
-    try {
-      this.handleValue(this.visit(n, path, depRes), n);
-    } catch (er) {
-      this.handleError(er, n, path);
-    }
-  }
-  run() {
-    for (const n of this.options.graph) {
-      this.#walk(n, []);
-    }
-    return this.results;
-  }
-};
-var graphRun = async (options) => {
-  const runner = new Runner(options, graphRun);
-  await runner.run();
-  if (runner.errors.length) {
-    const e = new AggregateError(runner.errors, "failed graph traversal");
-    Error.captureStackTrace(e, graphRun);
-    throw e;
-  }
-  return runner.results;
-};
-var graphRunSync = (options) => {
-  const runner = new RunnerSync(options, graphRunSync);
-  runner.run();
-  if (runner.errors.length) {
-    const e = new AggregateError(runner.errors, "failed graph traversal");
-    Error.captureStackTrace(e, graphRunSync);
-    throw e;
-  }
-  return runner.results;
-};
-
-// ../../src/workspaces/src/index.ts
-import { basename, resolve, posix } from "node:path";
-var asWSConfig = (conf, path) => {
-  assertWSConfig(conf, path);
-  return typeof conf === "string" ? { packages: [conf] } : Array.isArray(conf) ? { packages: conf } : conf;
-};
-var assertWSConfig = (conf, path) => {
-  if (typeof conf === "string") return conf;
-  if (Array.isArray(conf)) {
-    for (const c of conf) {
-      if (typeof c !== "string") {
-        throw error("Invalid workspace definition", {
-          path,
-          found: c,
-          wanted: "string"
-        });
-      }
-    }
-    return;
-  }
-  if (conf && typeof conf === "object") {
-    for (const [group, value] of Object.entries(conf)) {
-      if (typeof value === "string") continue;
-      if (Array.isArray(value)) {
-        for (const c of value) {
-          if (typeof c !== "string") {
-            throw error("Invalid workspace definition", {
-              path,
-              name: group,
-              found: c,
-              wanted: "string"
-            });
-          }
-        }
-        continue;
-      }
-      throw error("Invalid workspace definition", {
-        path,
-        name: group,
-        found: value,
-        wanted: "string | string[]"
-      });
-    }
-    return;
-  }
-  throw error("Invalid workspace definition", {
-    path,
-    found: conf,
-    wanted: "string | string[] | { [group: string]: string | string[] }"
-  });
-};
-var Monorepo = class _Monorepo {
-  /** The project root where vlt-workspaces.json is found */
-  projectRoot;
-  /** Scurry object to cache all filesystem calls (mostly globs) */
-  scurry;
-  // maps both name and path to the workspace objects
-  #workspaces = /* @__PURE__ */ new Map();
-  #groups = /* @__PURE__ */ new Map();
-  #config;
-  packageJson;
-  /**
-   * Number of {@link Workspace} objects loaded in this Monorepo
-   */
-  get size() {
-    return [...this.values()].length;
-  }
-  constructor(projectRoot, options = {}) {
-    this.projectRoot = resolve(projectRoot);
-    this.scurry = options.scurry ?? new PathScurry(projectRoot);
-    this.packageJson = options.packageJson ?? new PackageJson();
-    this.#config = options.config;
-    if (options.load) this.load(options.load);
-  }
-  /**
-   * Load the workspace definitions from vlt-workspaces.json,
-   * canonicalizing the result into the effective `{[group:string]:string[]}`
-   * form.
-   *
-   * Eg:
-   * - `"src/*"` => `{packages:["src/*"]}`
-   * - `{"apps": "src/*"}` => `{apps: ["src/*"]}`
-   */
-  get config() {
-    if (this.#config) return this.#config;
-    const file = resolve(this.projectRoot, "vlt-workspaces.json");
-    let confData;
-    try {
-      confData = readFileSync(file, "utf8");
-    } catch (er) {
-      throw error("Not in a monorepo, no vlt-workspaces.json found", {
-        path: this.projectRoot,
-        cause: er
-      });
-    }
-    let parsed;
-    try {
-      parsed = parse(confData);
-    } catch (er) {
-      throw error("Invalid vlt-workspaces.json file", {
-        path: this.projectRoot,
-        cause: er
-      });
-    }
-    this.#config = asWSConfig(parsed, file);
-    return this.#config;
-  }
-  /**
-   * Iterating the Monorepo object yields the workspace objects, in as close to
-   * topological dependency order as possible.
-   */
-  *[Symbol.iterator]() {
-    const [ws] = [...this.values()];
-    if (!ws) return;
-    for (const workspace of this.runSync(() => {
-    }).keys()) {
-      yield workspace;
-    }
-  }
-  /**
-   * Iterating the Monorepo object yields the workspace objects, in as close to
-   * topological dependency order as possible.
-   */
-  async *[Symbol.asyncIterator]() {
-    const [ws] = [...this.values()];
-    if (!ws) return;
-    for (const workspace of (await this.run(() => {
-    })).keys()) {
-      yield workspace;
-    }
-  }
-  /**
-   * By default, loads all workspaces reachable in the Monorepo.
-   *
-   * If provided with one (`string`)or more (`string[]`) group names in
-   * the {@link LoadQuery#groups} field, then only Workspaces in the named
-   * group(s) will be considered. Note that group names are unique string
-   * matches, not globs.
-   *
-   * If provided with a set of arbitrary path arguments, then only paths
-   * patching the provided pattern(s) will be included.
-   *
-   * These two options intersect, so
-   * `load({groups:'foo', paths:'./foo/[xy]*'})` will only load the workspaces
-   * in the group `foo` that match the paths glob.
-   */
-  load(query = {}) {
-    const paths = new Set(
-      typeof query.paths === "string" ? [query.paths] : query.paths ?? []
-    );
-    const groups = new Set(
-      typeof query.groups === "string" ? [query.groups] : query.groups ?? []
-    );
-    const groupsExpanded = {};
-    for (const [group, pattern] of Object.entries(this.config)) {
-      if (groups.size && !groups.has(group)) continue;
-      groupsExpanded[group] = this.#glob(pattern);
-    }
-    const filter = paths.size ? this.#glob([...paths]) : paths;
-    if (paths.size && !filter.size) return this;
-    for (const [group, matches] of Object.entries(groupsExpanded)) {
-      for (const path of matches) {
-        if (filter.size && !filter.has(path)) continue;
-        this.#loadWS(path, group);
-      }
-    }
-    return this;
-  }
-  // Either load a workspace from disk, or from our internal set,
-  // and assign it to the named group
-  #loadWS(path, group) {
-    const fullpath = resolve(this.projectRoot, path);
-    const loaded = this.#workspaces.get(fullpath);
-    if (loaded) return loaded;
-    const fromCache = workspaceCache.get(fullpath);
-    const manifest = fromCache?.manifest ?? this.packageJson.read(fullpath);
-    const ws = fromCache ?? new Workspace(path, manifest, fullpath);
-    if (group) ws.groups.push(group);
-    this.#workspaces.set(ws.fullpath, ws);
-    this.#workspaces.set(ws.path, ws);
-    this.#workspaces.set(ws.name, ws);
-    for (const name of ws.groups) {
-      const group2 = this.#groups.get(name) ?? /* @__PURE__ */ new Set();
-      group2.add(ws);
-      this.#groups.set(name, group2);
-    }
-    return ws;
-  }
-  // can't be cached, because it's dependent on the matches set
-  // but still worthwhile to have it defined in one place
-  #globOptions(matches) {
-    const inMatches = (p) => {
-      return !!p?.relativePosix() && (matches.has(p.relativePosix()) || inMatches(p.parent));
-    };
-    return {
-      root: this.projectRoot,
-      cwd: this.projectRoot,
-      posix: true,
-      scurry: this.scurry,
-      withFileTypes: false,
-      ignore: {
-        childrenIgnored: (p) => basename(p.relativePosix()) === "node_modules" || inMatches(p),
-        // ignore if fails to load package.json
-        ignored: (p) => {
-          p.lstatSync();
-          const rel = p.relativePosix();
-          if (!rel) return true;
-          const maybeDelete = [];
-          for (const m of matches) {
-            if (rel.startsWith(m + "/")) return true;
-            if (m.startsWith(rel + "/")) {
-              maybeDelete.push(m);
-            }
-          }
-          if (!p.isDirectory()) return true;
-          const pj = p.resolve("package.json").lstatSync();
-          if (!pj?.isFile()) return true;
-          try {
-            this.packageJson.read(p.fullpath());
-          } catch {
-            return true;
-          }
-          for (const m of maybeDelete) {
-            matches.delete(m);
-          }
-          matches.add(rel);
-          return false;
-        }
-      }
-    };
-  }
-  #glob(pattern) {
-    const matches = /* @__PURE__ */ new Set();
-    globSync(pattern, this.#globOptions(matches));
-    return matches;
-  }
-  /**
-   * Return the array of workspace dependencies that are found in
-   * the loaded set, for use in calculating dependency graph order for
-   * build operations.
-   *
-   * This does *not* get the full set of dependencies, or expand any
-   * `workspace:` dependencies that are not loaded.
-   *
-   * Call with the `forceLoad` param set to `true` to attempt a full
-   * load if any deps are not currently loaded.
-   */
-  getDeps(ws, forceLoad = false) {
-    const { manifest } = ws;
-    const depWorkspaces = [];
-    let didForceLoad = false;
-    for (const depType of [
-      "dependencies",
-      "devDependencies",
-      "optionalDependencies",
-      "peerDependencies"
-    ]) {
-      const deps = manifest[depType];
-      if (!deps) continue;
-      for (const [dep, spec] of Object.entries(deps)) {
-        if (spec.startsWith("workspace:")) {
-          let depWS = this.#workspaces.get(dep);
-          if (!depWS) {
-            if (!forceLoad) continue;
-            if (didForceLoad) continue;
-            didForceLoad = true;
-            this.load();
-            depWS = this.#workspaces.get(dep);
-            if (!depWS) continue;
-          }
-          depWorkspaces.push(depWS);
-        }
-      }
-    }
-    return depWorkspaces;
-  }
-  onCycle(_ws, _cycle, _depPath) {
-  }
-  /**
-   * Return the set of workspaces in the named group.
-   * If the group is not one we know about, then undefined is returned.
-   */
-  group(group) {
-    return this.#groups.get(group);
-  }
-  /**
-   * Get a loaded workspace by path or name.
-   *
-   * Note that this can only return workspaces that were ingested via a
-   * previous call to {@link Monorepo#load}.
-   */
-  get(nameOrPath) {
-    return this.#workspaces.get(nameOrPath);
-  }
-  /**
-   * get the list of all loaded workspace names used as keys
-   */
-  *names() {
-    for (const [key, ws] of this.#workspaces) {
-      if (key === ws.name) yield key;
-    }
-  }
-  /**
-   * get the list of all loaded workspace paths used as keys
-   */
-  *paths() {
-    for (const [key, ws] of this.#workspaces) {
-      if (key === ws.path) yield key;
-    }
-  }
-  /**
-   * get the workspace objects in no particular order.
-   * this is ever so slightly faster than iterating, because it doesn't
-   * explore the graph to yield results in topological dependency order,
-   * and should be used instead when order doesn't matter.
-   */
-  *values() {
-    const seen = /* @__PURE__ */ new Set();
-    for (const ws of this.#workspaces.values()) {
-      if (seen.has(ws.fullpath)) continue;
-      seen.add(ws.fullpath);
-      yield ws;
-    }
-  }
-  /**
-   * Get all the keys (package names and paths) for loaded workspaces.
-   * Union of {@link Monorepo#names} and {@link Monorepo#paths}
-   */
-  *keys() {
-    for (const ws of this.values()) {
-      yield ws.path;
-      if (ws.name !== ws.path) yield ws.name;
-    }
-  }
-  /**
-   * Filter the monorepo object yielding the workspace objects that matches
-   * either of the {@link WorkspacesLoadedConfig} options provided, in as close
-   * to topological dependency order as possible.
-   */
-  *filter({
-    workspace: namesOrPaths,
-    "workspace-group": groupName
-  }) {
-    const globPatternChecks = namesOrPaths?.map(
-      (glob) => minimatch.filter(posix.join(glob))
-    );
-    for (const ws of this) {
-      if (groupName?.some((i) => ws.groups.includes(i))) {
-        yield ws;
-        continue;
-      }
-      if (namesOrPaths?.map((i) => posix.join(i)).some((i) => ws.keys.includes(i))) {
-        yield ws;
-        continue;
-      }
-      if (ws.keys.some((key) => globPatternChecks?.some((fn) => fn(key)))) {
-        yield ws;
-      }
-    }
-  }
-  /**
-   * Run an operation asynchronously over all loaded workspaces
-   *
-   * If the `forceLoad` param is true, then it will attempt to do a full load
-   * when encountering a `workspace:` dependency that isn't loaded.
-   *
-   * Note that because the return type appears in the parameters of the
-   * operation function, it must be set explicitly either in the operation
-   * function signature or by calling `run<MyType>` or it'll fall back to
-   * `unknown`, similar to `Array.reduce()`, and for the same reason.
-   */
-  async run(operation, forceLoad = false) {
-    const [ws, ...rest] = [...this.#workspaces.values()];
-    if (!ws) {
-      throw error("No workspaces loaded", void 0, this.run);
-    }
-    return graphRun({
-      graph: [ws, ...rest],
-      getDeps: (ws2) => this.getDeps(ws2, forceLoad),
-      visit: async (ws2, signal, _, depResults) => await operation(ws2, signal, depResults),
-      onCycle: (ws2, cycle, path) => this.onCycle(ws2, cycle, path)
-    });
-  }
-  /**
-   * Run an operation synchronously over all loaded workspaces
-   *
-   * If the `forceLoad` param is true, then it will attempt to do a full load
-   * when encountering a `workspace:` dependency that isn't loaded.
-   *
-   * Note that because the return type appears in the parameters of the
-   * operation function, it must be set explicitly either in the operation
-   * function signature or by calling `runSync<MyType>` or it'll fall back to
-   * `unknown`, similar to `Array.reduce()`, and for the same reason.
-   */
-  runSync(operation, forceLoad = false) {
-    const [ws, ...rest] = [...this.#workspaces.values()];
-    if (!ws) {
-      throw error("No workspaces loaded", void 0, this.run);
-    }
-    return graphRunSync({
-      graph: [ws, ...rest],
-      getDeps: (ws2) => this.getDeps(ws2, forceLoad),
-      visit: (ws2, signal, _, depResults) => operation(ws2, signal, depResults),
-      onCycle: (ws2, cycle, path) => this.onCycle(ws2, cycle, path)
-    });
-  }
-  /**
-   * Convenience method to instantiate and load in one call.
-   * Returns undefined if the project is not a monorepo workspaces
-   * root, otherwise returns the loaded Monorepo.
-   */
-  static maybeLoad(projectRoot, options = { load: {} }) {
-    try {
-      if (!statSync(
-        resolve(projectRoot, "vlt-workspaces.json")
-      ).isFile()) {
-        return;
-      }
-    } catch {
-      return;
-    }
-    const { load = {} } = options;
-    return new _Monorepo(projectRoot, { ...options, load });
-  }
-  /**
-   * Convenience method to instantiate and load in one call.
-   * Throws if called on a directory that is not a workspaces root.
-   */
-  static load(projectRoot, options = { load: {} }) {
-    const { load = {} } = options;
-    return new _Monorepo(projectRoot, { ...options, load });
-  }
-};
-var workspaceCache = /* @__PURE__ */ new Map();
-var Workspace = class {
-  id;
-  path;
-  fullpath;
-  manifest;
-  groups = [];
-  name;
-  #keys;
-  constructor(path, manifest, fullpath) {
-    this.id = joinDepIDTuple(["workspace", path]);
-    workspaceCache.set(fullpath, this);
-    this.path = path;
-    this.fullpath = fullpath;
-    this.manifest = manifest;
-    this.name = manifest.name ?? path;
-  }
-  get keys() {
-    if (this.#keys) {
-      return this.#keys;
-    }
-    this.#keys = [this.name, this.path, this.fullpath];
-    return this.#keys;
-  }
-};
-
-// ../../node_modules/.pnpm/walk-up-path@4.0.0/node_modules/walk-up-path/dist/esm/index.js
-import { dirname, resolve as resolve2 } from "node:path";
-var walkUp = function* (path) {
-  for (path = resolve2(path); path; ) {
-    yield path;
-    const pp = dirname(path);
-    if (pp === path) {
-      break;
-    } else {
-      path = pp;
-    }
-  }
-};
-
-export {
-  asDepID,
-  joinDepIDTuple,
-  splitDepID,
-  hydrate,
-  hydrateTuple,
-  getId,
-  graphRun,
-  Monorepo,
-  walkUp
-};
-//# sourceMappingURL=chunk-JMGSFQ32.js.map