vercel 59.14.0 → 59.15.0

package/dist/chunks/vlt-builder-importer-USCFHWPL.js

@@ -1,322 +0,0 @@
-import { createRequire as __createRequire } from 'node:module';
-import { fileURLToPath as __fileURLToPath } from 'node:url';
-import { dirname as __dirname_ } from 'node:path';
-const require = __createRequire(import.meta.url);
-const __filename = __fileURLToPath(import.meta.url);
-const __dirname = __dirname_(__filename);
-import "./chunk-TZ2YI2VH.js";
-
-// src/builders/vlt-builder-importer.ts
-import { createHash, randomBytes } from "crypto";
-import {
-  link,
-  lstat,
-  mkdir,
-  open,
-  readFile,
-  rename,
-  rm,
-  unlink,
-  writeFile
-} from "fs/promises";
-import { join } from "path";
-import { install } from "@vltpkg/graph";
-import { PackageInfoClient } from "@vltpkg/package-info";
-import { PackageJson } from "@vltpkg/package-json";
-import { getCachePath } from "@vercel/cli-config";
-import { PathScurry } from "path-scurry";
-var LOCK_RETRY_MS = 50;
-var LOCK_WAIT_MS = 5 * 60 * 1e3;
-var LOCK_EMPTY_GRACE_MS = 1e3;
-var TARBALL_FETCH_TIMEOUT_MS = 2 * 60 * 1e3;
-var activeInstallations = /* @__PURE__ */ new Map();
-function compareKeys(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-function canonicalize(value) {
-  if (Array.isArray(value))
-    return value.map(canonicalize);
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).sort(([a], [b]) => compareKeys(a, b)).map(([key, child]) => [key, canonicalize(child)])
-    );
-  }
-  return value;
-}
-function validateGraph(graph) {
-  const { hash, ...contents } = graph;
-  const actual = createHash("sha256").update(JSON.stringify(canonicalize(contents))).digest("hex");
-  if (actual !== hash) {
-    throw new Error(
-      `The embedded vlt Builder graph for ${graph.name} is invalid.`
-    );
-  }
-}
-async function wait(ms) {
-  await new Promise((resolve) => setTimeout(resolve, ms));
-}
-function hasErrorCode(error, code) {
-  return error instanceof Error && "code" in error && error.code === code;
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return hasErrorCode(error, "EPERM");
-  }
-}
-async function isLockHolderAlive(path) {
-  try {
-    const pid = Number.parseInt((await readFile(path, "utf8")).trim(), 10);
-    return Number.isInteger(pid) && pid > 0 && isProcessAlive(pid);
-  } catch {
-    return false;
-  }
-}
-async function tryStealStaleLock(path, emptyGraceMs) {
-  let first;
-  try {
-    first = await lstat(path);
-  } catch {
-    return true;
-  }
-  if (first.size === 0 && Date.now() - first.mtimeMs < emptyGraceMs) {
-    return false;
-  }
-  if (await isLockHolderAlive(path))
-    return false;
-  let second;
-  try {
-    second = await lstat(path);
-  } catch {
-    return true;
-  }
-  if (second.dev !== first.dev || second.ino !== first.ino || second.mtimeMs !== first.mtimeMs || second.size !== first.size) {
-    return false;
-  }
-  try {
-    await unlink(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function acquireLock(path, {
-  waitMs = LOCK_WAIT_MS,
-  emptyGraceMs = LOCK_EMPTY_GRACE_MS
-} = {}) {
-  await mkdir(join(path, ".."), { recursive: true });
-  const startedAt = Date.now();
-  while (true) {
-    const tmp = `${path}.${process.pid}-${randomBytes(6).toString("hex")}`;
-    await writeFile(tmp, `${process.pid}
-`, { flag: "wx" });
-    try {
-      await link(tmp, path);
-      await unlink(tmp).catch(() => void 0);
-      return await open(path, "r");
-    } catch (error) {
-      await unlink(tmp).catch(() => void 0);
-      if (!hasErrorCode(error, "EEXIST"))
-        throw error;
-      if (await tryStealStaleLock(path, emptyGraceMs))
-        continue;
-      if (Date.now() - startedAt > waitMs) {
-        throw new Error(`Timed out waiting for vlt Builder lock "${path}".`);
-      }
-      await wait(LOCK_RETRY_MS);
-    }
-  }
-}
-async function installationComplete(root, graph) {
-  try {
-    return (await readFile(join(root, ".vercel-builder-graph"), "utf8")).trim() === graph.hash;
-  } catch {
-    return false;
-  }
-}
-var EmbeddedPackageInfoClient = class extends PackageInfoClient {
-  constructor(options, fetchTimeoutMs = TARBALL_FETCH_TIMEOUT_MS) {
-    super(options);
-    this.fetchTimeoutMs = fetchTimeoutMs;
-  }
-  async extract(...args) {
-    const [rawSpec, target, rawOptions = {}] = args;
-    const spec = rawSpec;
-    const options = rawOptions;
-    if (spec.final?.type === "remote" && options.resolved) {
-      if (!options.integrity) {
-        throw new Error(
-          `Missing integrity for remote Builder dependency ${options.resolved}`
-        );
-      }
-      let response;
-      try {
-        response = await fetch(options.resolved, {
-          signal: AbortSignal.timeout(this.fetchTimeoutMs)
-        });
-      } catch (error) {
-        const aborted = error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError");
-        if (aborted) {
-          throw new Error(
-            `Timed out downloading remote Builder dependency ${options.resolved}`
-          );
-        }
-        throw error;
-      }
-      if (!response.ok) {
-        throw new Error(
-          `Could not download remote Builder dependency ${options.resolved}: ${response.status}`
-        );
-      }
-      const bytes = Buffer.from(await response.arrayBuffer());
-      const integrity = `sha512-${createHash("sha512").update(new Uint8Array(bytes)).digest("base64")}`;
-      if (options.integrity !== integrity) {
-        throw new Error(
-          `Integrity check failed for remote Builder dependency ${options.resolved}`
-        );
-      }
-      const prototype = PackageInfoClient.prototype;
-      await (await prototype.getTarPool.call(this)).unpack(
-        new Uint8Array(bytes),
-        target
-      );
-      return { resolved: options.resolved, integrity, spec: rawSpec };
-    }
-    return super.extract(...args);
-  }
-};
-async function reifyGraph(root, graph, packageInfoFactory) {
-  const packageJson = new PackageJson();
-  const packageInfo = packageInfoFactory({
-    ...graph.lockfile.options,
-    projectRoot: root,
-    packageJson
-  });
-  await install({
-    ...graph.lockfile.options,
-    projectRoot: root,
-    packageJson,
-    packageInfo,
-    scurry: new PathScurry(root),
-    allowScripts: ":not(*)",
-    frozenLockfile: true,
-    cleanInstall: true
-  });
-}
-async function ensureGraph(graph, cacheRoot, packageInfoFactory) {
-  validateGraph(graph);
-  const root = join(cacheRoot, graph.hash);
-  const active = activeInstallations.get(root);
-  if (active)
-    return active;
-  const installation = (async () => {
-    if (await installationComplete(root, graph))
-      return root;
-    const lockPath = join(cacheRoot, "locks", `${graph.hash}.lock`);
-    const lock = await acquireLock(lockPath);
-    let temporaryRoot;
-    try {
-      if (await installationComplete(root, graph))
-        return root;
-      await rm(root, { recursive: true, force: true });
-      temporaryRoot = process.platform === "win32" ? root : join(
-        cacheRoot,
-        "tmp",
-        `${graph.hash}-${process.pid}-${randomBytes(6).toString("hex")}`
-      );
-      await mkdir(temporaryRoot, { recursive: true });
-      await writeFile(
-        join(temporaryRoot, "package.json"),
-        `${JSON.stringify(graph.manifest, null, 2)}
-`
-      );
-      await writeFile(
-        join(temporaryRoot, "vlt-lock.json"),
-        `${JSON.stringify(graph.lockfile, null, 2)}
-`
-      );
-      await reifyGraph(temporaryRoot, graph, packageInfoFactory);
-      await writeFile(
-        join(temporaryRoot, ".vercel-builder-graph"),
-        `${graph.hash}
-`
-      );
-      if (temporaryRoot !== root) {
-        await mkdir(join(root, ".."), { recursive: true });
-        await rename(temporaryRoot, root);
-      }
-      temporaryRoot = void 0;
-      return root;
-    } finally {
-      await lock.close();
-      await unlink(lockPath).catch(() => void 0);
-      if (temporaryRoot)
-        await rm(temporaryRoot, { recursive: true, force: true });
-    }
-  })();
-  activeInstallations.set(root, installation);
-  const clearInstallation = () => {
-    if (activeInstallations.get(root) === installation) {
-      activeInstallations.delete(root);
-    }
-  };
-  void installation.then(clearInstallation, clearInstallation);
-  return installation;
-}
-function createVltBuilderImporter({
-  graphs,
-  loadGraphs = async () => graphs,
-  require: require2,
-  cacheRoot = join(getCachePath(), "builders-vlt"),
-  packageInfoFactory = (options) => new EmbeddedPackageInfoClient(options),
-  debug = () => void 0
-}) {
-  return async function importVltBuilders(specs) {
-    if (specs.size === 0)
-      return /* @__PURE__ */ new Map();
-    const loadedGraphs = await loadGraphs();
-    if (loadedGraphs.schemaVersion !== 1) {
-      throw new Error("The embedded vlt Builder graph index is invalid.");
-    }
-    const builders = /* @__PURE__ */ new Map();
-    await Promise.all(
-      [...specs].map(async ([spec, name]) => {
-        const graph = loadedGraphs.builders[name];
-        if (!graph)
-          throw new Error(`No pinned vlt graph exists for ${name}.`);
-        const root = await ensureGraph(graph, cacheRoot, packageInfoFactory);
-        const pkgPath = require2.resolve(`${name}/package.json`, {
-          paths: [root]
-        });
-        const pkg = JSON.parse(
-          await readFile(pkgPath, "utf8")
-        );
-        if (pkg.name !== name || pkg.version !== graph.version) {
-          throw new Error(
-            `The vlt Builder graph materialized ${String(pkg.name)}@${String(
-              pkg.version
-            )} instead of ${name}@${graph.version}.`
-          );
-        }
-        const path = require2.resolve(name, { paths: [root] });
-        debug(`Resolved ${name}@${graph.version} with vlt from ${root}`);
-        builders.set(spec, {
-          path,
-          pkgPath,
-          pkg: { ...pkg, name },
-          builder: require2(path),
-          dynamicallyInstalled: true
-        });
-      })
-    );
-    return builders;
-  };
-}
-export {
-  EmbeddedPackageInfoClient,
-  TARBALL_FETCH_TIMEOUT_MS,
-  acquireLock,
-  createVltBuilderImporter
-};