pyfig 0.7.0 → 0.7.1

package/dist/cjs/sync-resolver.js

@@ -1,1342 +0,0 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  if (mod && typeof mod === "object" || typeof mod === "function") {
-    for (let key of __getOwnPropNames(mod))
-      if (!__hasOwnProp.call(to, key))
-        __defProp(to, key, {
-          get: __accessProp.bind(mod, key),
-          enumerable: true
-        });
-  }
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
-// src/sync-resolver.ts
-var import_node_fs4 = require("node:fs");
-
-// src/provision.ts
-var import_node_crypto2 = require("node:crypto");
-var import_node_fs3 = require("node:fs");
-var import_promises2 = require("node:fs/promises");
-var import_node_os = __toESM(require("node:os"), 1);
-var import_node_path6 = __toESM(require("node:path"), 1);
-var import_node_stream = require("node:stream");
-var import_promises3 = require("node:stream/promises");
-var import_fflate = require("fflate");
-var tar = __toESM(require("tar"), 1);
-var import_undici = require("undici");
-
-// src/config.ts
-var import_node_path2 = __toESM(require("node:path"), 1);
-var envPaths = __toESM(require("env-paths"), 1);
-
-// src/pep440.ts
-var import_pep440 = require("@renovatebot/pep440");
-function isValidPep440Specifier(specifier) {
-  return import_pep440.validRange(specifier);
-}
-function normalizePep440Version(version) {
-  return import_pep440.valid(version);
-}
-function pep440VersionSatisfies(version, specifier) {
-  return import_pep440.filter([version], specifier).length === 1;
-}
-function maxPep440Version(versions, specifier) {
-  return import_pep440.maxSatisfying([...versions], specifier);
-}
-
-// src/project-root.ts
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-function resolveProjectRoot(startDirectory = process.cwd()) {
-  const start = import_node_path.default.resolve(startDirectory);
-  for (const directory of ancestors(start)) {
-    if (import_node_fs.default.existsSync(import_node_path.default.join(directory, ".git")))
-      return directory;
-  }
-  return start;
-}
-function* ancestors(startDirectory) {
-  let directory = startDirectory;
-  while (true) {
-    yield directory;
-    const parent = import_node_path.default.dirname(directory);
-    if (parent === directory)
-      return;
-    directory = parent;
-  }
-}
-
-// src/config.ts
-var DEFAULT_REQUIRES_PYTHON = ">=3.10,<4";
-var DEFAULT_MANAGED_PYTHON = "3.12";
-var DEFAULT_REQUIRES_UV = ">=0.10,<1";
-var DEFAULT_PROBE_TIMEOUT_MS = 1e4;
-var DEFAULT_INSTALL_TIMEOUT_MS = 10 * 60000;
-var DEFAULT_DOWNLOAD_TIMEOUT_MS = 5 * 60000;
-var envPathsFunction = (() => {
-  const imported = envPaths.default;
-  const implementation = typeof imported === "function" ? imported : imported.default;
-  if (!implementation)
-    throw new TypeError("env-paths did not expose its default function.");
-  return implementation;
-})();
-function resolveOptions(options = {}) {
-  const env = { ...options.env ?? process.env };
-  const requiresPython = options.requiresPython ?? env["PYFIG_REQUIRES_PYTHON"] ?? DEFAULT_REQUIRES_PYTHON;
-  const requiresUv = options.requiresUv ?? env["PYFIG_REQUIRES_UV"] ?? DEFAULT_REQUIRES_UV;
-  assertPep440Specifier("requires-python", requiresPython);
-  assertPep440Specifier("requires-uv", requiresUv);
-  const managedPython = options.managedPython ?? env["PYFIG_MANAGED_PYTHON"] ?? DEFAULT_MANAGED_PYTHON;
-  assertManagedPythonRequest(managedPython, requiresPython);
-  const probeTimeoutMs = resolveDuration("probeTimeoutMs", options.probeTimeoutMs, env["PYFIG_PROBE_TIMEOUT_MS"], DEFAULT_PROBE_TIMEOUT_MS);
-  const installTimeoutMs = resolveDuration("installTimeoutMs", options.installTimeoutMs, env["PYFIG_INSTALL_TIMEOUT_MS"], DEFAULT_INSTALL_TIMEOUT_MS);
-  const downloadTimeoutMs = resolveDuration("downloadTimeoutMs", options.downloadTimeoutMs, env["PYFIG_DOWNLOAD_TIMEOUT_MS"], DEFAULT_DOWNLOAD_TIMEOUT_MS);
-  const coordinationTimeoutMs = resolveDuration("coordinationTimeoutMs", options.coordinationTimeoutMs, env["PYFIG_COORDINATION_TIMEOUT_MS"], installTimeoutMs + downloadTimeoutMs + 60000);
-  const configuredHome = options.cacheDir ?? env["PYFIG_HOME"];
-  const cacheDir = configuredHome ? import_node_path2.default.resolve(configuredHome) : envPathsFunction("pyfig", { suffix: "" }).cache;
-  const configuredProjectRoot = options.projectRoot ?? env["PYFIG_PROJECT_ROOT"];
-  const projectRoot = configuredProjectRoot ? import_node_path2.default.resolve(configuredProjectRoot) : resolveProjectRoot(env["INIT_CWD"] ?? process.cwd());
-  const autoInstall = options.autoInstall ?? parseBoolean(env["PYFIG_AUTO_INSTALL"], true);
-  const dependencies = normalizeDependencies(options.dependencies ?? []);
-  const requirements = normalizeRequirements(options.requirements ?? [], projectRoot);
-  return {
-    dependencies,
-    requirements,
-    python: options.python ?? env["PYFIG_PYTHON"] ?? "",
-    requiresPython,
-    managedPython,
-    requiresUv,
-    requireEmbedding: options.requireEmbedding ?? parseBoolean(env["PYFIG_REQUIRE_EMBEDDING"], false),
-    requireGil: options.requireGil ?? parseBoolean(env["PYFIG_REQUIRE_GIL"], false),
-    autoInstall,
-    installPython: options.installPython ?? parseBoolean(env["PYFIG_INSTALL_PYTHON"], autoInstall),
-    installUv: options.installUv ?? parseBoolean(env["PYFIG_INSTALL_UV"], autoInstall),
-    createVirtualEnvironment: options.createVirtualEnvironment ?? parseBoolean(env["PYFIG_CREATE_VIRTUAL_ENVIRONMENT"], autoInstall),
-    cacheDir,
-    projectRoot,
-    probeTimeoutMs,
-    installTimeoutMs,
-    downloadTimeoutMs,
-    coordinationTimeoutMs,
-    env
-  };
-}
-function hasRuntimeRequirements(options) {
-  return options.dependencies.length > 0 || options.requirements.length > 0;
-}
-function uvProcessEnvironment(options) {
-  return {
-    ...options.env,
-    UV_PYTHON_INSTALL_DIR: import_node_path2.default.join(options.cacheDir, "python"),
-    UV_CACHE_DIR: import_node_path2.default.join(options.cacheDir, "uv-cache"),
-    UV_PYTHON_PREFERENCE: "system",
-    UV_NO_CONFIG: "1"
-  };
-}
-function assertPep440Specifier(name, specifier) {
-  if (!isValidPep440Specifier(specifier)) {
-    throw new TypeError(`Invalid ${name} PEP 440 specifier: ${specifier}`);
-  }
-}
-function assertManagedPythonRequest(request, requiresPython) {
-  if (!request || /[\\/\0\r\n]/u.test(request) || request.includes("..")) {
-    throw new TypeError(`Invalid managed Python request: ${request}`);
-  }
-  if (/^\d+\.\d+(?:\.\d+)?$/u.test(request)) {
-    const normalized = request.split(".").length === 2 ? `${request}.0` : request;
-    if (!pep440VersionSatisfies(normalized, requiresPython)) {
-      throw new TypeError(`Managed Python ${request} cannot satisfy requires-python ${requiresPython}.`);
-    }
-  }
-}
-function resolveDuration(name, explicit, environment, fallback, allowZero = false) {
-  const value = explicit ?? (environment === undefined ? fallback : Number(environment));
-  const minimum = allowZero ? 0 : 1;
-  if (!Number.isSafeInteger(value) || value < minimum) {
-    throw new TypeError(`${name} must be ${allowZero ? "a non-negative" : "a positive"} integer.`);
-  }
-  return value;
-}
-function parseBoolean(value, fallback) {
-  if (value === undefined)
-    return fallback;
-  if (/^(1|true|yes|on)$/iu.test(value))
-    return true;
-  if (/^(0|false|no|off)$/iu.test(value))
-    return false;
-  throw new TypeError(`Invalid boolean value: ${value}`);
-}
-function normalizeDependencies(dependencies) {
-  const normalized = dependencies.map((dependency) => dependency.trim());
-  for (const dependency of normalized) {
-    if (!dependency || /[\0\r\n]/u.test(dependency)) {
-      throw new TypeError(`Invalid runtime dependency: ${JSON.stringify(dependency)}`);
-    }
-  }
-  return normalized;
-}
-function normalizeRequirements(requirements, projectRoot) {
-  const normalized = [];
-  for (const requirement of requirements) {
-    const candidate = requirement.trim();
-    if (!candidate || /[\0\r\n]/u.test(candidate)) {
-      throw new TypeError(`Invalid requirements file path: ${JSON.stringify(candidate)}`);
-    }
-    const absolute = import_node_path2.default.resolve(projectRoot, candidate);
-    const basename = import_node_path2.default.basename(absolute).toLowerCase();
-    if (isPythonProjectFile(basename)) {
-      throw new TypeError(`Expected a requirements file, not Python project metadata: ${absolute}`);
-    }
-    normalized.push(absolute);
-  }
-  return normalized;
-}
-var PYTHON_PROJECT_FILES = new Set([
-  "pdm.lock",
-  "pipfile",
-  "pipfile.lock",
-  "poetry.lock",
-  "pyproject.toml",
-  "setup.cfg",
-  "setup.py",
-  "uv.lock"
-]);
-function isPythonProjectFile(basename) {
-  return PYTHON_PROJECT_FILES.has(basename) || /^pylock(?:\.[^.]+)?\.toml$/u.test(basename);
-}
-
-// src/venv-identity.ts
-var import_node_crypto = require("node:crypto");
-var import_promises = require("node:fs/promises");
-var import_node_path4 = __toESM(require("node:path"), 1);
-
-// src/python-venv.ts
-var import_node_fs2 = __toESM(require("node:fs"), 1);
-var import_node_path3 = __toESM(require("node:path"), 1);
-var VIRTUAL_ENV_ROOT_NAME = import_node_path3.default.join("node_modules", ".pyfig", "venvs");
-function pythonVenvRoot(projectRoot) {
-  return import_node_path3.default.join(projectRoot, VIRTUAL_ENV_ROOT_NAME);
-}
-function pythonVenvDirectory(projectRoot, venvDirectory) {
-  return import_node_path3.default.join(pythonVenvRoot(projectRoot), venvDirectory);
-}
-function externalPythonVenvDirectories(projectRoot, env) {
-  const candidates = [env["VIRTUAL_ENV"], import_node_path3.default.join(projectRoot, ".venv")].filter((value) => Boolean(value)).map((value) => import_node_path3.default.resolve(value));
-  return [...new Map(candidates.map((value) => [canonicalPath(value), value])).values()];
-}
-function pythonVenvExecutable(pythonVenv) {
-  return import_node_path3.default.join(pythonVenv, process.platform === "win32" ? "Scripts" : "bin", process.platform === "win32" ? "python.exe" : "python");
-}
-function activatePythonVenv(env, pythonVenv, pythonExecutable) {
-  const activated = { ...env };
-  const pathEntry = Object.keys(activated).find((key) => key.toUpperCase() === "PATH");
-  const existingPath = pathEntry ? activated[pathEntry] : undefined;
-  for (const key of Object.keys(activated)) {
-    const normalized = key.toUpperCase();
-    if (normalized === "PATH" || normalized === "PYTHONHOME" || normalized === "VIRTUAL_ENV") {
-      delete activated[key];
-    }
-  }
-  activated["PATH"] = [import_node_path3.default.dirname(pythonExecutable), existingPath].filter((value) => Boolean(value)).join(import_node_path3.default.delimiter);
-  activated["VIRTUAL_ENV"] = pythonVenv;
-  return activated;
-}
-function pathsEqual(left, right) {
-  return canonicalPath(left) === canonicalPath(right);
-}
-function canonicalPath(value) {
-  const resolved = import_node_path3.default.resolve(value);
-  let canonical = resolved;
-  try {
-    canonical = import_node_fs2.default.realpathSync.native(resolved);
-  } catch {}
-  return process.platform === "win32" ? canonical.toLowerCase() : canonical;
-}
-
-// src/venv-identity.ts
-var VENV_SCHEMA = 1;
-var VENV_METADATA = ".pyfig-venv.json";
-function createVenvIdentity(python, requirementsSha256) {
-  const contract = {
-    schema: VENV_SCHEMA,
-    runtime: {
-      architecture: process.arch,
-      platform: process.platform
-    },
-    python: {
-      architecture: python.architecture,
-      baseExecutable: canonicalPath(python.executable),
-      basePrefix: canonicalPath(python.basePrefix),
-      embeddingHeader: python.embedding ? canonicalPath(python.embedding.headerPath) : null,
-      embeddingLibrary: python.embedding ? canonicalPath(python.embedding.libraryPath) : null,
-      gilDisabled: python.gilDisabled,
-      implementation: python.implementation,
-      pointerBits: python.pointerBits,
-      version: python.version
-    },
-    requirementsSha256
-  };
-  const id = sha256(JSON.stringify(contract));
-  const implementation = safePathSegment(python.implementation);
-  const version = safePathSegment(python.version);
-  return {
-    contract,
-    directoryName: `${implementation}-${version}-${id.slice(0, 20)}`,
-    id
-  };
-}
-function requirementsDigest(content) {
-  return sha256(content);
-}
-function venvMetadataFile(directory) {
-  return import_node_path4.default.join(directory, VENV_METADATA);
-}
-async function venvMatches(directory, venv) {
-  try {
-    const parsed = JSON.parse(await import_promises.readFile(venvMetadataFile(directory), "utf8"));
-    return parsed.venvId === venv.id && JSON.stringify(parsed.contract) === JSON.stringify(venv.contract);
-  } catch {
-    return false;
-  }
-}
-async function writeVenvMetadata(directory, venv) {
-  await import_promises.mkdir(directory, { recursive: true });
-  const file = venvMetadataFile(directory);
-  const staged = `${file}.${process.pid}.${import_node_crypto.randomUUID()}.tmp`;
-  const metadata = {
-    contract: venv.contract,
-    venvId: venv.id
-  };
-  try {
-    await import_promises.writeFile(staged, `${JSON.stringify(metadata, null, 2)}
-`, {
-      encoding: "utf8",
-      flag: "wx"
-    });
-    await import_promises.rename(staged, file);
-  } finally {
-    await import_promises.rm(staged, { force: true });
-  }
-}
-function safePathSegment(value) {
-  return value.toLowerCase().replace(/[^a-z0-9.-]+/gu, "-").replace(/^-+|-+$/gu, "") || "python";
-}
-function sha256(value) {
-  return import_node_crypto.createHash("sha256").update(value).digest("hex");
-}
-
-// src/provision-lock.ts
-var import_loqkit = require("loqkit");
-async function withProvisioningLock(options) {
-  let existing;
-  const result = await import_loqkit.withLock({ resource: options.key }, options.mutate, {
-    key: options.key,
-    name: "Pyfig provisioning",
-    namespace: "pyfig",
-    timeout: options.timeoutMs,
-    predicate: async () => {
-      const value = await options.check();
-      if (value === null)
-        return true;
-      existing = { value };
-      return false;
-    }
-  });
-  if (result.context.state === "executed")
-    return result.value;
-  if (existing)
-    return existing.value;
-  throw new Error(`Provisioning check for ${options.key} did not produce a resource.`);
-}
-
-// src/package-target.ts
-var TARGET_OPTIONS = new Set([
-  "--active",
-  "--config-file",
-  "--directory",
-  "--isolated",
-  "--prefix",
-  "--project",
-  "--python",
-  "--root",
-  "--system",
-  "--target",
-  "--user"
-]);
-var TARGET_ENVIRONMENT_VARIABLES = new Set([
-  "CONDA_PREFIX",
-  "PIP_PREFIX",
-  "PIP_PYTHON",
-  "PIP_ROOT",
-  "PIP_TARGET",
-  "PIP_USER",
-  "PYTHONHOME",
-  "PYTHONUSERBASE",
-  "UV_CONFIG_FILE",
-  "UV_PROJECT",
-  "UV_PROJECT_ENVIRONMENT",
-  "UV_PYTHON",
-  "UV_PREFIX",
-  "UV_ROOT",
-  "UV_SYSTEM_PYTHON",
-  "UV_TARGET"
-]);
-function uvCommandNeedsPython(args) {
-  return args[0] === "pip" || args[0] === "run";
-}
-function targetUvArguments(args, python) {
-  if (!python.virtualEnvironment) {
-    throw new Error("Targeted uv commands require a virtual environment.");
-  }
-  assertNoTargetOverride(args);
-  if (args[0] === "run") {
-    return ["run", "--no-project", "--python", python.executable, ...args.slice(1)];
-  }
-  if (args[0] === "pip" && args[1]) {
-    return ["pip", args[1], "--python", python.executable, ...args.slice(2)];
-  }
-  return [...args];
-}
-function uvCommandProcessEnvironment(env, python) {
-  const sanitized = sanitizeUvProcessEnvironment(env);
-  if (!python?.virtualEnvironment)
-    return sanitized;
-  return {
-    ...activatePythonVenv(sanitized, python.virtualEnvironment, python.executable),
-    UV_PYTHON: python.executable
-  };
-}
-function sanitizeUvProcessEnvironment(env) {
-  const sanitized = { ...env };
-  for (const key of Object.keys(sanitized)) {
-    if (TARGET_ENVIRONMENT_VARIABLES.has(key.toUpperCase()))
-      delete sanitized[key];
-  }
-  return sanitized;
-}
-function assertNoTargetOverride(args) {
-  for (const argument of args.slice(1)) {
-    if (argument === "--")
-      return;
-    const [name] = argument.split("=", 1);
-    if (name && TARGET_OPTIONS.has(name)) {
-      throw new Error(`${name} cannot override the environment selected by Pyfig.`);
-    }
-    if (argument === "-p" || argument.startsWith("-p=") || /^-p[^-]/u.test(argument)) {
-      throw new Error("-p cannot override the environment selected by Pyfig.");
-    }
-  }
-}
-
-// src/process.ts
-var import_node_child_process = require("node:child_process");
-var import_node_path5 = __toESM(require("node:path"), 1);
-var import_which = __toESM(require("which"), 1);
-async function resolveExecutable(value, env) {
-  if (!value)
-    return null;
-  if (import_node_path5.default.isAbsolute(value)) {
-    return await import_which.default(value, { nothrow: true, path: env["PATH"], pathExt: env["PATHEXT"] });
-  }
-  if (!/^[A-Za-z0-9_.-]+$/u.test(value))
-    return null;
-  return await import_which.default(value, { nothrow: true, path: env["PATH"], pathExt: env["PATHEXT"] });
-}
-function run(executable, args, env, timeoutMs) {
-  const result = import_node_child_process.spawnSync(executable, args, {
-    encoding: "utf8",
-    env,
-    timeout: timeoutMs,
-    maxBuffer: 4 * 1024 * 1024,
-    windowsHide: true
-  });
-  if (result.status !== 0 || result.error) {
-    const detail = result.stderr?.trim() || result.error?.message || `exit ${result.status}`;
-    throw new Error(`${import_node_path5.default.basename(executable)} ${args.slice(0, 3).join(" ")} failed: ${detail}`);
-  }
-  return { stdout: result.stdout, stderr: result.stderr };
-}
-async function runAsync(executable, args, env, timeoutMs, signal, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = import_node_child_process.spawn(executable, args, {
-      env,
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true
-    });
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    const finish = (error, result) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      signal?.removeEventListener("abort", abort);
-      if (error)
-        reject(error);
-      else if (result)
-        resolve(result);
-    };
-    const abort = () => {
-      child.kill();
-      const reason = signal?.reason;
-      finish(reason instanceof Error ? reason : new Error(`${import_node_path5.default.basename(executable)} was aborted.`));
-    };
-    const timer = setTimeout(() => {
-      child.kill();
-      finish(new Error(`${import_node_path5.default.basename(executable)} timed out after ${timeoutMs}ms.`));
-    }, timeoutMs);
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-      if (stdout.length > 4 * 1024 * 1024) {
-        child.kill();
-        finish(new Error(`${import_node_path5.default.basename(executable)} exceeded the output limit.`));
-      }
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-      if (stderr.length > 4 * 1024 * 1024) {
-        child.kill();
-        finish(new Error(`${import_node_path5.default.basename(executable)} exceeded the error-output limit.`));
-      }
-    });
-    child.once("error", (error) => finish(error));
-    child.once("close", (code, childSignal) => {
-      if (code !== 0) {
-        const detail = stderr.trim() || (childSignal ? `signal ${childSignal}` : `exit ${code}`);
-        finish(new Error(`${import_node_path5.default.basename(executable)} ${args.slice(0, 3).join(" ")} failed: ${detail}`));
-        return;
-      }
-      finish(undefined, { stdout, stderr });
-    });
-    if (signal?.aborted)
-      abort();
-    else
-      signal?.addEventListener("abort", abort, { once: true });
-  });
-}
-
-// src/probes.ts
-var PYTHON_PROBE = `
-import json
-import os
-import platform
-import struct
-import sys
-import sysconfig
-
-base_prefix = getattr(sys, "base_prefix", sys.prefix)
-include_directory = sysconfig.get_path("include") or ""
-header_path = os.path.join(include_directory, "Python.h") if include_directory else ""
-library_candidates = []
-stable_abi_library_candidates = []
-if os.name == "nt":
-    library_directory = sysconfig.get_config_var("LIBDIR") or os.path.join(base_prefix, "libs")
-    configured_library = sysconfig.get_config_var("LDLIBRARY") or ""
-    if configured_library:
-        library_candidates.append(os.path.join(library_directory, os.path.splitext(configured_library)[0] + ".lib"))
-    library_candidates.append(os.path.join(library_directory, f"python{sys.version_info.major}{sys.version_info.minor}.lib"))
-    stable_abi_library_candidates.append(os.path.join(library_directory, "python3.lib"))
-else:
-    library_directories = [
-        sysconfig.get_config_var("LIBDIR"),
-        sysconfig.get_config_var("LIBPL"),
-        os.path.join(base_prefix, "lib"),
-    ]
-    library_names = [
-        sysconfig.get_config_var("LDLIBRARY"),
-        sysconfig.get_config_var("LIBRARY"),
-    ]
-    for directory in library_directories:
-        for name in library_names:
-            if directory and name:
-                library_candidates.append(os.path.join(directory, name))
-        if directory:
-            stable_abi_library_candidates.extend([
-                os.path.join(directory, "libpython3.so"),
-                os.path.join(directory, "libpython3.dylib"),
-            ])
-
-library_path = next((candidate for candidate in library_candidates if os.path.isfile(candidate)), "")
-stable_abi_library_path = next(
-    (candidate for candidate in stable_abi_library_candidates if os.path.isfile(candidate)),
-    None,
-)
-embedding = None
-if os.path.isfile(header_path) and library_path:
-    library_name = os.path.basename(library_path)
-    library_kind = "import" if os.name == "nt" else ("static" if library_name.endswith(".a") else "shared")
-    embedding = {
-        "includeDirectory": include_directory,
-        "headerPath": header_path,
-        "libraryPath": library_path,
-        "libraryDirectory": os.path.dirname(library_path),
-        "libraryName": library_name,
-        "libraryKind": library_kind,
-        "stableAbiLibraryPath": stable_abi_library_path,
-    }
-
-release_level = sys.version_info.releaselevel
-release_suffixes = {
-    "alpha": "a",
-    "beta": "b",
-    "candidate": "rc",
-    "final": "",
-}
-release_suffix = release_suffixes[release_level]
-if release_suffix:
-    release_suffix += str(sys.version_info.serial)
-
-print(json.dumps({
-    "executable": sys.executable,
-    "baseExecutable": getattr(sys, "_base_executable", sys.executable),
-    "version": ".".join(map(str, sys.version_info[:3])) + release_suffix,
-    "major": sys.version_info.major,
-    "minor": sys.version_info.minor,
-    "patch": sys.version_info.micro,
-    "releaseLevel": release_level,
-    "implementation": sys.implementation.name,
-    "architecture": platform.machine().lower(),
-    "pointerBits": struct.calcsize("P") * 8,
-    "prefix": sys.prefix,
-    "basePrefix": base_prefix,
-    "virtualEnvironment": sys.prefix if sys.prefix != base_prefix else None,
-    "gilDisabled": bool(sysconfig.get_config_var("Py_GIL_DISABLED")),
-    "embedding": embedding,
-}))
-`;
-function pythonSatisfiesPolicy(python, options) {
-  return pep440VersionSatisfies(python.version, options.requiresPython) && (!options.requireEmbedding || python.implementation === "cpython" && python.embedding !== null && pythonArchitectureMatchesRuntime(python)) && (!options.requireGil || !python.gilDisabled);
-}
-async function probePython(candidate, options) {
-  const executable = await resolveExecutable(candidate.executable, options.env);
-  if (!executable)
-    return null;
-  try {
-    const { stdout } = run(executable, [...candidate.args, "-c", PYTHON_PROBE], options.env, options.probeTimeoutMs);
-    const info = JSON.parse(stdout.trim());
-    return normalizePep440Version(info.version) ? info : null;
-  } catch {
-    return null;
-  }
-}
-async function findUv(options) {
-  const configured = options.env["PYFIG_UV"] ?? "uv";
-  const executable = await resolveExecutable(configured, options.env);
-  const uv = executable ? probeUv(executable, options) : null;
-  return uv && pep440VersionSatisfies(uv.version, options.requiresUv) ? uv : null;
-}
-function probeUv(executable, options) {
-  try {
-    const { stdout } = run(executable, ["--version"], options.env, options.probeTimeoutMs);
-    const version = normalizeVersion(stdout.match(/^uv\s+(\S+)/iu)?.[1]);
-    return version ? { executable, version } : null;
-  } catch {
-    return null;
-  }
-}
-function normalizeVersion(value) {
-  if (!value)
-    return null;
-  return normalizePep440Version(value);
-}
-function pythonArchitectureMatchesRuntime(python) {
-  const architecture = python.architecture.toLowerCase();
-  if (python.pointerBits !== (process.arch === "ia32" ? 32 : 64))
-    return false;
-  if (process.arch === "x64")
-    return architecture === "x86_64" || architecture === "amd64";
-  if (process.arch === "arm64")
-    return architecture === "aarch64" || architecture === "arm64";
-  if (process.arch === "ia32") {
-    return architecture === "x86" || architecture === "i386" || architecture === "i686";
-  }
-  return architecture === process.arch;
-}
-
-// src/provision.ts
-async function ensureUv(options = {}) {
-  return ensureUvResolved(resolveOptions(options));
-}
-async function ensurePython(options = {}) {
-  const resolved = resolveOptions(options);
-  await validateRequirementsFiles(resolved.requirements);
-  const uv = await ensureUvResolved(resolved);
-  if (!hasRuntimeRequirements(resolved)) {
-    const external = await findReusableExternalPythonVenv(resolved);
-    if (external) {
-      return { managed: false, python: external, uv, venvId: null };
-    }
-  }
-  const basePython = await ensureBasePythonResolved(uv, resolved);
-  const resolution = await resolveRuntimeDependencies(uv, basePython, resolved);
-  const venv = createVenvIdentity(basePython, resolution.sha256);
-  const python = await ensureManagedPythonVenv(uv, basePython, venv, resolution, resolved);
-  return { managed: true, python, uv, venvId: venv.id };
-}
-async function ensureManagedPythonVenv(uv, basePython, venv, resolution, options) {
-  const directory = pythonVenvDirectory(options.projectRoot, venv.directoryName);
-  const check = async () => {
-    if (!await venvMatches(directory, venv))
-      return null;
-    const candidate = await inspectPythonVenv(directory, options);
-    return candidate && pythonSatisfiesPolicy(candidate, options) ? candidate : null;
-  };
-  const existing = await check();
-  if (existing)
-    return existing;
-  if (!options.createVirtualEnvironment) {
-    throw new Error(`No compatible environment is available and creation is disabled. ` + `Pyfig would create ${directory}.`);
-  }
-  return withProvisioningLock({
-    key: `venv:${canonicalPath(directory)}`,
-    timeoutMs: options.coordinationTimeoutMs,
-    check,
-    mutate: async () => {
-      await import_promises2.rm(directory, { recursive: true, force: true });
-      await import_promises2.mkdir(import_node_path6.default.dirname(directory), { recursive: true });
-      try {
-        await runAsync(uv.executable, [
-          "venv",
-          "--no-project",
-          "--no-config",
-          "--no-python-downloads",
-          "--python",
-          basePython.executable,
-          directory
-        ], isolatedUvProcessEnvironment(options), options.installTimeoutMs);
-        const created = await inspectPythonVenv(directory, options);
-        if (!created || !pythonSatisfiesPolicy(created, options)) {
-          throw new Error(`uv created ${directory}, but its Python does not satisfy the requested capabilities.`);
-        }
-        await installResolvedDependencies(uv, created, resolution, options);
-        await writeVenvMetadata(directory, venv);
-        const installed = await check();
-        if (!installed)
-          throw new Error(`Pyfig could not validate environment ${directory}.`);
-        return installed;
-      } catch (error) {
-        await import_promises2.rm(directory, { recursive: true, force: true });
-        throw error;
-      }
-    }
-  });
-}
-async function findReusableExternalPythonVenv(options) {
-  if (options.python) {
-    const configured = await probePython({ executable: options.python, args: [] }, options);
-    if (!configured || !pythonSatisfiesPolicy(configured, options)) {
-      throw incompatibleConfiguredPython(options);
-    }
-    if (configured.virtualEnvironment)
-      return configured;
-  }
-  for (const directory of externalPythonVenvDirectories(options.projectRoot, options.env)) {
-    const info = await inspectPythonVenv(directory, options);
-    if (info && pythonSatisfiesPolicy(info, options))
-      return info;
-  }
-  return null;
-}
-async function ensureBasePythonResolved(uv, options) {
-  if (options.python) {
-    const configured = await probePython({ executable: options.python, args: [] }, options);
-    if (!configured || !pythonSatisfiesPolicy(configured, options)) {
-      throw incompatibleConfiguredPython(options);
-    }
-    if (!configured.virtualEnvironment)
-      return configured;
-    const base = await probePython({ executable: configured.baseExecutable, args: [] }, options);
-    if (base && pythonSatisfiesPolicy(base, options))
-      return base;
-    throw incompatibleConfiguredPython(options);
-  }
-  const externalBase = await findExternalBasePython(options);
-  if (externalBase)
-    return externalBase;
-  const system = await findPythonWithUv(uv, options, "system");
-  if (system)
-    return system;
-  const cachedManaged = await findPythonWithUv(uv, options, "managed");
-  if (cachedManaged)
-    return cachedManaged;
-  if (!options.installPython) {
-    throw new Error(missingPythonMessage(options, "managed Python installation is disabled"));
-  }
-  return withProvisioningLock({
-    key: `python:${canonicalPath(import_node_path6.default.join(options.cacheDir, "python"))}`,
-    timeoutMs: options.coordinationTimeoutMs,
-    check: () => findPythonWithUv(uv, options, "managed"),
-    mutate: async () => {
-      await runAsync(uv.executable, ["python", "install", "--no-config", options.managedPython], isolatedUvProcessEnvironment(options), options.installTimeoutMs);
-      const installed = await findPythonWithUv(uv, options, "managed");
-      if (!installed) {
-        throw new Error(missingPythonMessage(options, `uv installed ${options.managedPython}, but it remains incompatible`));
-      }
-      return installed;
-    }
-  });
-}
-async function findExternalBasePython(options) {
-  for (const directory of externalPythonVenvDirectories(options.projectRoot, options.env)) {
-    const environment = await inspectPythonVenv(directory, options);
-    if (!environment || !pythonSatisfiesPolicy(environment, options))
-      continue;
-    const base = await probePython({ executable: environment.baseExecutable, args: [] }, options);
-    if (base && !base.virtualEnvironment && pythonSatisfiesPolicy(base, options))
-      return base;
-  }
-  return null;
-}
-async function findPythonWithUv(uv, options, source) {
-  for (const request of ["", options.managedPython]) {
-    const args = [
-      "python",
-      "find",
-      "--no-project",
-      "--no-config",
-      "--no-python-downloads",
-      source === "system" ? "--system" : "--managed-python"
-    ];
-    if (request)
-      args.push(request);
-    try {
-      const { stdout } = await runAsync(uv.executable, args, explicitPythonSourceProcessEnvironment(options), options.probeTimeoutMs);
-      const info = await probePython({ executable: stdout.trim(), args: [] }, options);
-      if (info && pythonSatisfiesPolicy(info, options))
-        return info;
-    } catch {}
-  }
-  try {
-    const { stdout } = await runAsync(uv.executable, [
-      "python",
-      "list",
-      "--no-config",
-      "--no-python-downloads",
-      "--only-installed",
-      "--output-format",
-      "json",
-      source === "system" ? "--no-managed-python" : "--managed-python"
-    ], explicitPythonSourceProcessEnvironment(options), options.probeTimeoutMs);
-    const candidates = installedPythonPaths(stdout);
-    for (const executable of candidates) {
-      const info = await probePython({ executable, args: [] }, options);
-      if (info && !info.virtualEnvironment && pythonSatisfiesPolicy(info, options)) {
-        return info;
-      }
-    }
-  } catch {}
-  return null;
-}
-function installedPythonPaths(output) {
-  const parsed = JSON.parse(output);
-  if (!Array.isArray(parsed))
-    return [];
-  const paths = parsed.flatMap((entry) => {
-    if (!entry || typeof entry !== "object" || !("path" in entry))
-      return [];
-    const candidate = entry.path;
-    return typeof candidate === "string" && candidate ? [candidate] : [];
-  });
-  return [...new Map(paths.map((candidate) => [canonicalPath(candidate), candidate])).values()];
-}
-async function inspectPythonVenv(directory, options) {
-  const executable = pythonVenvExecutable(directory);
-  const info = await probePython({ executable, args: [] }, options);
-  return info?.virtualEnvironment && pathsEqual(info.virtualEnvironment, directory) ? info : null;
-}
-async function resolveRuntimeDependencies(uv, python, options) {
-  if (!hasRuntimeRequirements(options)) {
-    return { content: "", sha256: requirementsDigest("") };
-  }
-  const temporary = await import_promises2.mkdtemp(import_node_path6.default.join(import_node_os.default.tmpdir(), "pyfig-resolution-"));
-  try {
-    const additions = import_node_path6.default.join(temporary, "runtime-dependencies.txt");
-    const output = import_node_path6.default.join(temporary, "resolved-dependencies.txt");
-    const sources = [...options.requirements];
-    if (options.dependencies.length > 0) {
-      await import_promises2.writeFile(additions, `${options.dependencies.join(`
-`)}
-`, "utf8");
-      sources.push(additions);
-    }
-    await runAsync(uv.executable, [
-      "pip",
-      "compile",
-      "--no-config",
-      "--no-header",
-      "--no-annotate",
-      "--generate-hashes",
-      "--python",
-      python.executable,
-      ...sources,
-      "--output-file",
-      output
-    ], isolatedUvProcessEnvironment(options), options.installTimeoutMs, undefined, options.projectRoot);
-    const content = normalizeResolution(await import_promises2.readFile(output, "utf8"));
-    return { content, sha256: requirementsDigest(content) };
-  } finally {
-    await import_promises2.rm(temporary, { recursive: true, force: true });
-  }
-}
-async function validateRequirementsFiles(requirements) {
-  for (const requirement of requirements) {
-    let information;
-    try {
-      information = await import_promises2.stat(requirement);
-    } catch (error) {
-      throw new Error(`Requirements file is unavailable: ${requirement}`, { cause: error });
-    }
-    if (!information.isFile()) {
-      throw new Error(`Requirements path is not a file: ${requirement}`);
-    }
-  }
-}
-async function installResolvedDependencies(uv, python, resolution, options) {
-  if (!resolution.content)
-    return;
-  if (!python.virtualEnvironment) {
-    throw new Error("Runtime dependency installation requires a virtual environment.");
-  }
-  const temporary = await import_promises2.mkdtemp(import_node_path6.default.join(import_node_os.default.tmpdir(), "pyfig-install-"));
-  try {
-    const requirements = import_node_path6.default.join(temporary, "resolved-dependencies.txt");
-    await import_promises2.writeFile(requirements, resolution.content, { encoding: "utf8", flag: "wx" });
-    await runAsync(uv.executable, ["pip", "install", "--no-config", "--python", python.executable, "-r", requirements], targetUvProcessEnvironment(options, python), options.installTimeoutMs, undefined, options.projectRoot);
-    await runAsync(uv.executable, ["pip", "check", "--no-config", "--python", python.executable], targetUvProcessEnvironment(options, python), options.installTimeoutMs, undefined, options.projectRoot);
-  } finally {
-    await import_promises2.rm(temporary, { recursive: true, force: true });
-  }
-}
-function normalizeResolution(content) {
-  const normalized = content.replace(/\r\n/gu, `
-`).trimEnd();
-  return normalized ? `${normalized}
-` : "";
-}
-async function ensureUvResolved(options) {
-  const existing = await findAvailableUv(options);
-  if (existing)
-    return existing;
-  if (!options.installUv) {
-    throw new Error(`Compatible uv is unavailable (requires-uv ${options.requiresUv}), and uv installation is disabled.`);
-  }
-  const policyKey = import_node_crypto2.createHash("sha256").update(options.requiresUv).digest("hex");
-  return withProvisioningLock({
-    key: `uv-policy:${canonicalPath(uvInstallRoot(options))}:${policyKey}`,
-    timeoutMs: options.coordinationTimeoutMs,
-    check: () => findAvailableUv(options),
-    mutate: async () => {
-      const release = await resolveUvRelease(options);
-      const installDir = uvInstallDirectory(options, release.version);
-      const executable = uvExecutable(options, release.version);
-      return withProvisioningLock({
-        key: `uv-release:${canonicalPath(installDir)}`,
-        timeoutMs: options.coordinationTimeoutMs,
-        check: () => findAvailableUv(options),
-        mutate: async () => {
-          await installUv(installDir, release, options);
-          const result = probeUv(executable, options);
-          if (!result || result.version !== release.version) {
-            throw new Error(`Expected managed uv ${release.version}, but the installed executable did not match.`);
-          }
-          return result;
-        }
-      });
-    }
-  });
-}
-async function findAvailableUv(options) {
-  const external = await findUv(options);
-  if (external)
-    return external;
-  return findManagedUv(options);
-}
-async function findManagedUv(options) {
-  const entries = await import_promises2.readdir(uvInstallRoot(options), { withFileTypes: true }).catch(() => []);
-  let versions = entries.filter((entry) => entry.isDirectory() && normalizePep440Version(entry.name) === entry.name).map((entry) => entry.name);
-  while (versions.length > 0) {
-    const selected = maxPep440Version(versions, options.requiresUv);
-    if (!selected)
-      return null;
-    const candidate = probeUv(uvExecutable(options, selected), options);
-    if (candidate?.version === selected)
-      return candidate;
-    versions = versions.filter((version) => version !== selected);
-  }
-  return null;
-}
-function isolatedUvProcessEnvironment(options) {
-  return sanitizeUvProcessEnvironment(uvProcessEnvironment(options));
-}
-function explicitPythonSourceProcessEnvironment(options) {
-  const env = isolatedUvProcessEnvironment(options);
-  delete env["UV_PYTHON_PREFERENCE"];
-  return env;
-}
-function targetUvProcessEnvironment(options, python) {
-  return uvCommandProcessEnvironment(uvProcessEnvironment(options), python);
-}
-function incompatibleConfiguredPython(options) {
-  return new Error(`Configured Python ${options.python} is unavailable or does not satisfy ` + `requires-python ${options.requiresPython}` + `${options.requireEmbedding ? " with CPython embedding files" : ""}.`);
-}
-function missingPythonMessage(options, reason) {
-  const embedding = options.requireEmbedding ? " with compatible CPython headers, library, architecture, and GIL ABI" : "";
-  return `No Python satisfies requires-python ${options.requiresPython}${embedding}; ${reason}.`;
-}
-var UV_RELEASE_PAGE_SIZE = 100;
-var UV_RELEASE_MAX_PAGES = 20;
-var UV_RELEASE_METADATA_TTL_MS = 24 * 60 * 60000;
-async function resolveUvRelease(options) {
-  const catalog = await ensureUvReleaseCatalog(options);
-  const asset = uvAsset();
-  const releases = catalog.releases.filter((release) => release.assets.includes(asset) && release.assets.includes(`${asset}.sha256`));
-  const version = maxPep440Version(releases.map((release) => release.version), options.requiresUv);
-  const release = releases.find((candidate) => candidate.version === version);
-  if (!release) {
-    throw new Error(`No published uv release satisfies requires-uv ${options.requiresUv}.`);
-  }
-  return release;
-}
-async function ensureUvReleaseCatalog(options) {
-  const file = uvReleaseMetadataFile(options);
-  const stale = await readUvReleaseCatalog(file);
-  try {
-    return await withProvisioningLock({
-      key: `uv-metadata:${canonicalPath(file)}`,
-      timeoutMs: options.coordinationTimeoutMs,
-      check: () => readFreshUvReleaseCatalog(file),
-      mutate: async () => {
-        const catalog = await fetchUvReleaseCatalog(options);
-        await writeUvReleaseCatalog(file, catalog);
-        return catalog;
-      }
-    });
-  } catch (error) {
-    const fallback = await readUvReleaseCatalog(file) ?? stale;
-    if (fallback)
-      return fallback;
-    throw error;
-  }
-}
-async function fetchUvReleaseCatalog(options) {
-  const dispatcher = proxyDispatcher(options.env);
-  const releases = new Map;
-  let exhausted = false;
-  try {
-    for (let page = 1;page <= UV_RELEASE_MAX_PAGES; page += 1) {
-      const text = await downloadText(`https://api.github.com/repos/astral-sh/uv/releases?per_page=${UV_RELEASE_PAGE_SIZE}&page=${page}`, options.downloadTimeoutMs, dispatcher, githubApiHeaders(options.env));
-      const payload = JSON.parse(text);
-      if (!Array.isArray(payload)) {
-        throw new Error("GitHub returned invalid uv release metadata.");
-      }
-      for (const candidate of payload) {
-        if (!candidate || typeof candidate !== "object")
-          continue;
-        const release = candidate;
-        if (release.draft === true || typeof release.tag_name !== "string")
-          continue;
-        const assetNames = releaseAssetNames(release.assets);
-        const version = normalizePep440Version(release.tag_name);
-        if (version) {
-          releases.set(version, { assets: assetNames, tag: release.tag_name, version });
-        }
-      }
-      if (payload.length < UV_RELEASE_PAGE_SIZE) {
-        exhausted = true;
-        break;
-      }
-    }
-  } finally {
-    await dispatcher?.close();
-  }
-  if (!exhausted) {
-    throw new Error(`uv release catalog exceeded ${UV_RELEASE_MAX_PAGES} pages.`);
-  }
-  if (releases.size === 0) {
-    throw new Error("GitHub returned no usable uv releases.");
-  }
-  return { fetchedAt: Date.now(), releases: [...releases.values()] };
-}
-function githubApiHeaders(env) {
-  const token = [env["GITHUB_TOKEN"], env["GH_TOKEN"]].find((value) => typeof value === "string" && value.trim().length > 0);
-  if (token && /[\r\n]/u.test(token)) {
-    throw new TypeError("GitHub API token must not contain line breaks.");
-  }
-  return {
-    Accept: "application/vnd.github+json",
-    "User-Agent": "pyfig",
-    "X-GitHub-Api-Version": "2022-11-28",
-    ...token ? { Authorization: `Bearer ${token}` } : {}
-  };
-}
-async function readFreshUvReleaseCatalog(file) {
-  const catalog = await readUvReleaseCatalog(file);
-  if (!catalog)
-    return null;
-  const age = Date.now() - catalog.fetchedAt;
-  return age >= 0 && age < UV_RELEASE_METADATA_TTL_MS ? catalog : null;
-}
-async function readUvReleaseCatalog(file) {
-  try {
-    return parseUvReleaseCatalog(JSON.parse(await import_promises2.readFile(file, "utf8")));
-  } catch {
-    return null;
-  }
-}
-function parseUvReleaseCatalog(value) {
-  if (!value || typeof value !== "object")
-    return null;
-  const catalog = value;
-  if (!Number.isSafeInteger(catalog.fetchedAt) || catalog.fetchedAt < 0 || !Array.isArray(catalog.releases)) {
-    return null;
-  }
-  const releases = [];
-  for (const value of catalog.releases) {
-    if (!value || typeof value !== "object")
-      return null;
-    const release = value;
-    if (!Array.isArray(release.assets) || !release.assets.every((asset) => typeof asset === "string") || typeof release.tag !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._+-]*$/u.test(release.tag) || typeof release.version !== "string" || normalizePep440Version(release.version) !== release.version) {
-      return null;
-    }
-    releases.push({
-      assets: release.assets,
-      tag: release.tag,
-      version: release.version
-    });
-  }
-  return { fetchedAt: catalog.fetchedAt, releases };
-}
-async function writeUvReleaseCatalog(file, catalog) {
-  await import_promises2.mkdir(import_node_path6.default.dirname(file), { recursive: true });
-  const staged = import_node_path6.default.join(import_node_path6.default.dirname(file), `.${import_node_path6.default.basename(file)}.${process.pid}.${import_node_crypto2.randomUUID()}.tmp`);
-  try {
-    await import_promises2.writeFile(staged, `${JSON.stringify(catalog)}
-`, { encoding: "utf8", flag: "wx" });
-    if (process.platform === "win32")
-      await import_promises2.rm(file, { force: true });
-    await import_promises2.rename(staged, file);
-  } finally {
-    await import_promises2.rm(staged, { force: true });
-  }
-}
-function uvReleaseMetadataFile(options) {
-  return import_node_path6.default.join(options.cacheDir, "metadata", "uv-releases.json");
-}
-function releaseAssetNames(value) {
-  if (!Array.isArray(value))
-    return [];
-  return value.flatMap((entry) => {
-    if (!entry || typeof entry !== "object")
-      return [];
-    const name = entry.name;
-    return typeof name === "string" ? [name] : [];
-  });
-}
-function uvInstallRoot(options) {
-  return import_node_path6.default.join(options.cacheDir, "tools", "uv");
-}
-function uvInstallDirectory(options, version) {
-  return import_node_path6.default.join(uvInstallRoot(options), version);
-}
-function uvExecutable(options, version) {
-  return import_node_path6.default.join(uvInstallDirectory(options, version), process.platform === "win32" ? "uv.exe" : "uv");
-}
-async function installUv(installDir, release, options) {
-  const asset = uvAsset();
-  const baseUrl = `https://github.com/astral-sh/uv/releases/download/${release.tag}`;
-  const temporary = await import_promises2.mkdtemp(import_node_path6.default.join(import_node_os.default.tmpdir(), "pyfig-uv-"));
-  const dispatcher = proxyDispatcher(options.env);
-  try {
-    const archive = import_node_path6.default.join(temporary, asset);
-    await download(`${baseUrl}/${asset}`, archive, options.downloadTimeoutMs, dispatcher);
-    const expected = (await downloadText(`${baseUrl}/${asset}.sha256`, options.downloadTimeoutMs, dispatcher)).trim().split(/\s+/u)[0];
-    const actual = await sha256File(archive);
-    if (!expected || expected.toLowerCase() !== actual.toLowerCase()) {
-      throw new Error(`uv archive checksum mismatch for ${asset}`);
-    }
-    const extracted = import_node_path6.default.join(temporary, "extracted");
-    await import_promises2.mkdir(extracted, { recursive: true });
-    const source = await extractUvExecutable(archive, asset, extracted);
-    if (!source)
-      throw new Error(`uv archive did not contain the expected executable: ${asset}`);
-    await publishUvAtomically(source, installDir, release.version, options);
-  } finally {
-    await dispatcher?.close();
-    await import_promises2.rm(temporary, { recursive: true, force: true });
-  }
-}
-async function extractUvExecutable(archive, asset, destination) {
-  const executableName = process.platform === "win32" ? "uv.exe" : "uv";
-  if (!asset.endsWith(".zip")) {
-    await tar.x({ file: archive, cwd: destination, strict: true });
-    return findFile(destination, executableName);
-  }
-  const entries = import_fflate.unzipSync(await import_promises2.readFile(archive), {
-    filter: ({ name }) => import_node_path6.default.posix.basename(name.replaceAll("\\", "/")) === executableName
-  });
-  const matches = Object.entries(entries).filter(([name]) => import_node_path6.default.posix.basename(name.replaceAll("\\", "/")) === executableName);
-  if (matches.length !== 1 || !matches[0])
-    return null;
-  const source = import_node_path6.default.join(destination, executableName);
-  await import_promises2.writeFile(source, matches[0][1], { flag: "wx" });
-  return source;
-}
-async function publishUvAtomically(source, installDir, version, options) {
-  await import_promises2.mkdir(installDir, { recursive: true });
-  const executable = uvExecutable(options, version);
-  const staged = import_node_path6.default.join(installDir, `.${import_node_path6.default.basename(executable)}.${process.pid}.${import_node_crypto2.randomUUID()}.tmp`);
-  try {
-    await import_promises2.copyFile(source, staged);
-    if (process.platform !== "win32")
-      await import_promises2.chmod(staged, 493);
-    const stagedUv = probeUv(staged, options);
-    if (!stagedUv || stagedUv.version !== version) {
-      throw new Error(`Downloaded uv executable is not version ${version}.`);
-    }
-    if (process.platform === "win32")
-      await import_promises2.rm(executable, { force: true });
-    await import_promises2.rename(staged, executable);
-  } finally {
-    await import_promises2.rm(staged, { force: true });
-  }
-}
-function uvAsset() {
-  const architecture = process.arch === "x64" ? "x86_64" : process.arch === "arm64" ? "aarch64" : null;
-  if (!architecture)
-    throw new Error(`uv bootstrap does not support architecture ${process.arch}.`);
-  if (process.platform === "win32")
-    return `uv-${architecture}-pc-windows-msvc.zip`;
-  if (process.platform === "darwin")
-    return `uv-${architecture}-apple-darwin.tar.gz`;
-  if (process.platform === "linux")
-    return `uv-${architecture}-unknown-linux-musl.tar.gz`;
-  throw new Error(`uv bootstrap does not support platform ${process.platform}.`);
-}
-async function download(url, destination, timeoutMs, dispatcher) {
-  const response = await import_undici.fetch(url, {
-    dispatcher,
-    redirect: "follow",
-    signal: AbortSignal.timeout(timeoutMs)
-  });
-  if (!response.ok || !response.body) {
-    await response.body?.cancel();
-    throw new Error(`Could not download ${url}: HTTP ${response.status}`);
-  }
-  await import_promises3.pipeline(import_node_stream.Readable.fromWeb(response.body), import_node_fs3.createWriteStream(destination, { flags: "wx" }));
-}
-async function downloadText(url, timeoutMs, dispatcher, headers) {
-  const response = await import_undici.fetch(url, {
-    dispatcher,
-    headers,
-    redirect: "follow",
-    signal: AbortSignal.timeout(timeoutMs)
-  });
-  if (!response.ok) {
-    await response.body?.cancel();
-    throw new Error(`Could not download ${url}: HTTP ${response.status}`);
-  }
-  return response.text();
-}
-function proxyDispatcher(env) {
-  const httpProxy = processEnvironmentValue(env, "http_proxy", "HTTP_PROXY");
-  const httpsProxy = processEnvironmentValue(env, "https_proxy", "HTTPS_PROXY");
-  if (!httpProxy && !httpsProxy)
-    return;
-  return new import_undici.EnvHttpProxyAgent({
-    httpProxy,
-    httpsProxy,
-    noProxy: processEnvironmentValue(env, "no_proxy", "NO_PROXY")
-  });
-}
-function processEnvironmentValue(env, lowercase, uppercase) {
-  return env[lowercase] ?? env[uppercase];
-}
-async function sha256File(file) {
-  const hash = import_node_crypto2.createHash("sha256");
-  for await (const chunk of import_node_fs3.createReadStream(file))
-    hash.update(chunk);
-  return hash.digest("hex");
-}
-async function findFile(directory, name) {
-  for (const entry of await import_promises2.readdir(directory, { withFileTypes: true })) {
-    const target = import_node_path6.default.join(directory, entry.name);
-    if (entry.isFile() && entry.name === name)
-      return target;
-    if (entry.isDirectory()) {
-      const nested = await findFile(target, name);
-      if (nested)
-        return nested;
-    }
-  }
-  return null;
-}
-
-// src/sync-resolver.ts
-async function main() {
-  const request = JSON.parse(import_node_fs4.readFileSync(0, "utf8"));
-  const result = request.target === "uv" ? await ensureUv(request.options) : await ensurePython(request.options);
-  process.stdout.write(JSON.stringify(result));
-}
-main().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  process.stderr.write(message);
-  process.exitCode = 1;
-});
-
-//# debugId=0726BCDBF58AF5C064756E2164756E21