pyfig 0.7.0 → 0.7.1

package/dist/cjs/index.js

@@ -65,1018 +65,184 @@ var __export = (target, all) => {
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
-  DEFAULT_MANAGED_PYTHON: () => DEFAULT_MANAGED_PYTHON,
-  DEFAULT_REQUIRES_PYTHON: () => DEFAULT_REQUIRES_PYTHON,
-  DEFAULT_REQUIRES_UV: () => DEFAULT_REQUIRES_UV,
-  Python: () => Python,
-  ensurePython: () => ensurePython,
-  ensureUv: () => ensureUv,
-  resolveProjectRoot: () => resolveProjectRoot,
-  uvSpawn: () => uvSpawn,
-  uvSpawnSync: () => uvSpawnSync
+  PythonContext: () => PythonContext,
+  pyfig: () => pyfig
 });
 module.exports = __toCommonJS(exports_src);
 
-// 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/client.ts
-var import_loqkit2 = require("loqkit");
-
-// 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/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);
+// src/pyfig.ts
+var import_node_child_process2 = require("node:child_process");
 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.");
-    }
-  }
-}
+var import_pep4402 = require("@renovatebot/pep440");
 
 // src/process.ts
 var import_node_child_process = require("node:child_process");
-var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_path = __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
+var OUTPUT_LIMIT = 1024 * 1024;
+async function findExecutable(requested, cwd, env) {
+  const candidate = import_node_path.default.isAbsolute(requested) || /[\\/]/u.test(requested) ? import_node_path.default.resolve(cwd, requested) : requested;
+  const resolved = await import_which.default(candidate, {
+    nothrow: true,
+    path: environmentValue(env, "PATH"),
+    pathExt: environmentValue(env, "PATHEXT")
   });
-  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 };
+  return resolved ? import_node_path.default.resolve(cwd, resolved) : null;
 }
-async function runAsync(executable, args, env, timeoutMs, signal, cwd) {
+async function capture(executable, args, cwd, env) {
   return new Promise((resolve, reject) => {
     const child = import_node_child_process.spawn(executable, args, {
-      env,
       cwd,
+      env,
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true
     });
     let stdout = "";
     let stderr = "";
     let settled = false;
-    const finish = (error, result) => {
+    const finish = (error) => {
       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.`));
+      else
+        resolve(stdout);
     };
-    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) {
+      if (stdout.length > OUTPUT_LIMIT) {
         child.kill();
-        finish(new Error(`${import_node_path5.default.basename(executable)} exceeded the output limit.`));
+        finish(new Error(`${import_node_path.default.basename(executable)} exceeded its stdout limit.`));
       }
     });
     child.stderr.on("data", (chunk) => {
       stderr += chunk;
-      if (stderr.length > 4 * 1024 * 1024) {
+      if (stderr.length > OUTPUT_LIMIT) {
         child.kill();
-        finish(new Error(`${import_node_path5.default.basename(executable)} exceeded the error-output limit.`));
+        finish(new Error(`${import_node_path.default.basename(executable)} exceeded its stderr 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}`));
+    child.once("close", (code, signal) => {
+      if (code === 0) {
+        finish();
         return;
       }
-      finish(undefined, { stdout, stderr });
+      const detail = stderr.trim() || (signal ? `signal ${signal}` : `exit ${code}`);
+      finish(new Error(`${import_node_path.default.basename(executable)} ${args.slice(0, 3).join(" ")} failed: ${detail}`));
     });
-    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": "",
+function environmentValue(env, name) {
+  if (env[name] !== undefined || process.platform !== "win32")
+    return env[name];
+  const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+  return key ? env[key] : undefined;
 }
-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;
+// src/uv.ts
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_stream = require("node:stream");
+var import_promises2 = require("node:stream/promises");
+var import_pep440 = require("@renovatebot/pep440");
+var import_fflate = require("fflate");
+var import_loqkit = require("loqkit");
+var tar = __toESM(require("tar"), 1);
+var import_undici = require("undici");
+var RELEASE_PAGE_SIZE = 100;
+var RELEASE_MAX_PAGES = 20;
+var RELEASE_METADATA_TTL_MS = 24 * 60 * 60000;
+var METADATA_TIMEOUT_MS = 30000;
+var DOWNLOAD_TIMEOUT_MS = 5 * 60000;
+var COORDINATION_TIMEOUT_MS = 15 * 60000;
+async function resolveUv(specifier, cwd, env) {
+  const context = {
+    cache: uvCacheDirectory(env),
+    cwd,
+    env,
+    specifier
   };
-  const existing = await check();
+  const existing = await findAvailableUv(context);
   if (existing)
     return existing;
-  if (!options.createVirtualEnvironment) {
-    throw new Error(`No compatible environment is available and creation is disabled. ` + `Pyfig would create ${directory}.`);
-  }
+  const policy = import_node_crypto.createHash("sha256").update(specifier).digest("hex");
   return withProvisioningLock({
-    key: `venv:${canonicalPath(directory)}`,
-    timeoutMs: options.coordinationTimeoutMs,
-    check,
+    key: `uv-policy:${canonicalPath(context.cache)}:${policy}`,
+    check: () => findAvailableUv(context),
     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);
+      const release = await resolveUvRelease(context);
+      const destination = uvInstallDirectory(context, release.version);
       return withProvisioningLock({
-        key: `uv-release:${canonicalPath(installDir)}`,
-        timeoutMs: options.coordinationTimeoutMs,
-        check: () => findAvailableUv(options),
+        key: `uv-release:${canonicalPath(destination)}`,
+        check: () => probeUv(uvExecutable(context, release.version), context, release.version),
         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.`);
+          await installUv(release, context);
+          const installed = await probeUv(uvExecutable(context, release.version), context, release.version);
+          if (!installed) {
+            throw new Error(`Managed uv ${release.version} failed its post-install probe.`);
           }
-          return result;
+          return installed;
         }
       });
     }
   });
 }
-async function findAvailableUv(options) {
-  const external = await findUv(options);
-  if (external)
+async function findAvailableUv(context) {
+  const external = await findExecutable("uv", context.cwd, context.env);
+  if (external && await probeUv(external, context))
     return external;
-  return findManagedUv(options);
+  return findCachedUv(context);
 }
-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);
+async function findCachedUv(context) {
+  const root = uvInstallRoot(context);
+  const entries = await import_promises.readdir(root, { withFileTypes: true }).catch(() => []);
+  let versions = entries.filter((entry) => entry.isDirectory() && import_pep440.valid(entry.name) === entry.name).map((entry) => entry.name);
   while (versions.length > 0) {
-    const selected = maxPep440Version(versions, options.requiresUv);
-    if (!selected)
+    const version = import_pep440.maxSatisfying(versions, context.specifier);
+    if (!version)
       return null;
-    const candidate = probeUv(uvExecutable(options, selected), options);
-    if (candidate?.version === selected)
-      return candidate;
-    versions = versions.filter((version) => version !== selected);
+    const executable = await probeUv(uvExecutable(context, version), context, version);
+    if (executable)
+      return executable;
+    versions = versions.filter((candidate) => candidate !== version);
   }
   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}.`;
+async function probeUv(executable, context, expectedVersion) {
+  try {
+    const output = await capture(executable, ["--version"], context.cwd, context.env);
+    const version = import_pep440.valid(output.match(/^uv\s+(\S+)/iu)?.[1] ?? "");
+    return version && (!expectedVersion || version === expectedVersion) && import_pep440.maxSatisfying([version], context.specifier) ? executable : null;
+  } catch {
+    return null;
+  }
 }
-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);
+async function resolveUvRelease(context) {
+  const catalog = await ensureUvReleaseCatalog(context);
   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}.`);
-  }
+  const candidates = catalog.releases.filter((release) => release.assets.includes(asset) && release.assets.includes(`${asset}.sha256`));
+  const version = import_pep440.maxSatisfying(candidates.map((release) => release.version), context.specifier);
+  const release = candidates.find((candidate) => candidate.version === version);
+  if (!release)
+    throw new Error(`No published uv release satisfies ${context.specifier}.`);
   return release;
 }
-async function ensureUvReleaseCatalog(options) {
-  const file = uvReleaseMetadataFile(options);
+async function ensureUvReleaseCatalog(context) {
+  const file = uvReleaseMetadataFile(context);
   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);
+        const catalog = await fetchUvReleaseCatalog(context.env);
         await writeUvReleaseCatalog(file, catalog);
         return catalog;
       }
@@ -1088,30 +254,32 @@ async function ensureUvReleaseCatalog(options) {
     throw error;
   }
 }
-async function fetchUvReleaseCatalog(options) {
-  const dispatcher = proxyDispatcher(options.env);
+async function fetchUvReleaseCatalog(env) {
+  const dispatcher = proxyDispatcher(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));
+    for (let page = 1;page <= RELEASE_MAX_PAGES; page += 1) {
+      const text = await downloadText(`https://api.github.com/repos/astral-sh/uv/releases?per_page=${RELEASE_PAGE_SIZE}&page=${page}`, METADATA_TIMEOUT_MS, dispatcher, githubApiHeaders(env));
       const payload = JSON.parse(text);
-      if (!Array.isArray(payload)) {
+      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")
+        const value = candidate;
+        if (value.draft === true || typeof value.tag_name !== "string")
           continue;
-        const assetNames = releaseAssetNames(release.assets);
-        const version = normalizePep440Version(release.tag_name);
+        const version = import_pep440.valid(value.tag_name);
         if (version) {
-          releases.set(version, { assets: assetNames, tag: release.tag_name, version });
+          releases.set(version, {
+            assets: releaseAssetNames(value.assets),
+            tag: value.tag_name,
+            version
+          });
         }
       }
-      if (payload.length < UV_RELEASE_PAGE_SIZE) {
+      if (payload.length < RELEASE_PAGE_SIZE) {
         exhausted = true;
         break;
       }
@@ -1119,16 +287,14 @@ async function fetchUvReleaseCatalog(options) {
   } finally {
     await dispatcher?.close();
   }
-  if (!exhausted) {
-    throw new Error(`uv release catalog exceeded ${UV_RELEASE_MAX_PAGES} pages.`);
-  }
-  if (releases.size === 0) {
+  if (!exhausted)
+    throw new Error(`uv release catalog exceeded ${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);
+  const token = [environmentValue(env, "GITHUB_TOKEN"), environmentValue(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.");
   }
@@ -1144,11 +310,11 @@ async function readFreshUvReleaseCatalog(file) {
   if (!catalog)
     return null;
   const age = Date.now() - catalog.fetchedAt;
-  return age >= 0 && age < UV_RELEASE_METADATA_TTL_MS ? catalog : null;
+  return age >= 0 && age < RELEASE_METADATA_TTL_MS ? catalog : null;
 }
 async function readUvReleaseCatalog(file) {
   try {
-    return parseUvReleaseCatalog(JSON.parse(await import_promises2.readFile(file, "utf8")));
+    return parseUvReleaseCatalog(JSON.parse(await import_promises.readFile(file, "utf8")));
   } catch {
     return null;
   }
@@ -1157,17 +323,15 @@ 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)) {
+  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")
+  for (const candidate of catalog.releases) {
+    if (!candidate || typeof candidate !== "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) {
+    const release = candidate;
+    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" || import_pep440.valid(release.version) !== release.version)
       return null;
-    }
     releases.push({
       assets: release.assets,
       tag: release.tag,
@@ -1177,62 +341,40 @@ function parseUvReleaseCatalog(value) {
   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`);
+  await import_promises.mkdir(import_node_path2.default.dirname(file), { recursive: true });
+  const staged = import_node_path2.default.join(import_node_path2.default.dirname(file), `.${import_node_path2.default.basename(file)}.${uniqueSuffix()}.tmp`);
   try {
-    await import_promises2.writeFile(staged, `${JSON.stringify(catalog)}
+    await import_promises.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);
+      await import_promises.rm(file, { force: true });
+    await import_promises.rename(staged, file);
   } finally {
-    await import_promises2.rm(staged, { force: true });
+    await import_promises.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) {
+async function installUv(release, context) {
   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);
+  const temporary = await import_promises.mkdtemp(import_node_path2.default.join(import_node_os.default.tmpdir(), "pyfig-uv-"));
+  const dispatcher = proxyDispatcher(context.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 archive = import_node_path2.default.join(temporary, asset);
+    await download(`${baseUrl}/${asset}`, archive, dispatcher);
+    const expected = (await downloadText(`${baseUrl}/${asset}.sha256`, DOWNLOAD_TIMEOUT_MS, 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}`);
+      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 extracted = import_node_path2.default.join(temporary, "extracted");
+    await import_promises.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);
+      throw new Error(`uv archive did not contain the expected executable: ${asset}.`);
+    await publishUv(source, release.version, context);
   } finally {
     await dispatcher?.close();
-    await import_promises2.rm(temporary, { recursive: true, force: true });
+    await import_promises.rm(temporary, { recursive: true, force: true });
   }
 }
 async function extractUvExecutable(archive, asset, destination) {
@@ -1241,58 +383,46 @@ async function extractUvExecutable(archive, asset, destination) {
     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 entries = import_fflate.unzipSync(await import_promises.readFile(archive), {
+    filter: ({ name }) => import_node_path2.default.posix.basename(name.replaceAll("\\", "/")) === executableName
   });
-  const matches = Object.entries(entries).filter(([name]) => import_node_path6.default.posix.basename(name.replaceAll("\\", "/")) === executableName);
+  const matches = Object.entries(entries).filter(([name]) => import_node_path2.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" });
+  const source = import_node_path2.default.join(destination, executableName);
+  await import_promises.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`);
+async function publishUv(source, version, context) {
+  const installDirectory = uvInstallDirectory(context, version);
+  await import_promises.mkdir(installDirectory, { recursive: true });
+  const executable = uvExecutable(context, version);
+  const staged = import_node_path2.default.join(installDirectory, `.${import_node_path2.default.basename(executable)}.${uniqueSuffix()}.tmp`);
   try {
-    await import_promises2.copyFile(source, staged);
+    await import_promises.copyFile(source, staged);
     if (process.platform !== "win32")
-      await import_promises2.chmod(staged, 493);
-    const stagedUv = probeUv(staged, options);
-    if (!stagedUv || stagedUv.version !== version) {
+      await import_promises.chmod(staged, 493);
+    if (!await probeUv(staged, { ...context, specifier: `==${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);
+      await import_promises.rm(executable, { force: true });
+    await import_promises.rename(staged, executable);
   } finally {
-    await import_promises2.rm(staged, { force: true });
+    await import_promises.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) {
+async function download(url, destination, dispatcher) {
   const response = await import_undici.fetch(url, {
     dispatcher,
     redirect: "follow",
-    signal: AbortSignal.timeout(timeoutMs)
+    signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)
   });
   if (!response.ok || !response.body) {
     await response.body?.cancel();
-    throw new Error(`Could not download ${url}: HTTP ${response.status}`);
+    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" }));
+  await import_promises2.pipeline(import_node_stream.Readable.fromWeb(response.body), import_node_fs.createWriteStream(destination, { flags: "wx" }));
 }
 async function downloadText(url, timeoutMs, dispatcher, headers) {
   const response = await import_undici.fetch(url, {
@@ -1303,33 +433,30 @@ async function downloadText(url, timeoutMs, dispatcher, headers) {
   });
   if (!response.ok) {
     await response.body?.cancel();
-    throw new Error(`Could not download ${url}: HTTP ${response.status}`);
+    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");
+  const httpProxy = environmentValue(env, "http_proxy") ?? environmentValue(env, "HTTP_PROXY");
+  const httpsProxy = environmentValue(env, "https_proxy") ?? environmentValue(env, "HTTPS_PROXY");
   if (!httpProxy && !httpsProxy)
     return;
   return new import_undici.EnvHttpProxyAgent({
     httpProxy,
     httpsProxy,
-    noProxy: processEnvironmentValue(env, "no_proxy", "NO_PROXY")
+    noProxy: environmentValue(env, "no_proxy") ?? environmentValue(env, "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))
+  const hash = import_node_crypto.createHash("sha256");
+  for await (const chunk of import_node_fs.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);
+  for (const entry of await import_promises.readdir(directory, { withFileTypes: true })) {
+    const target = import_node_path2.default.join(directory, entry.name);
     if (entry.isFile() && entry.name === name)
       return target;
     if (entry.isDirectory()) {
@@ -1340,108 +467,332 @@ async function findFile(directory, name) {
   }
   return null;
 }
-
-// src/runners.ts
-var import_node_child_process2 = require("node:child_process");
-
-// src/runtime-files.ts
-var import_node_fs4 = __toESM(require("node:fs"), 1);
-var import_node_path7 = __toESM(require("node:path"), 1);
-function runtimeFile(name) {
-  const moduleDirectory = __dirname;
-  const compiled = import_node_path7.default.join(moduleDirectory, `${name}.js`);
-  return import_node_fs4.default.existsSync(compiled) ? compiled : import_node_path7.default.join(moduleDirectory, `${name}.ts`);
-}
-
-// src/runners.ts
-async function uvSpawn(args = [], spawnOptions = {}, pyfigOptions = {}) {
-  const options = optionsForInvocation(pyfigOptions, spawnOptions.env);
-  const resolved = resolveOptions(options);
-  const python = uvCommandNeedsPython(args) ? await ensurePython(resolved) : undefined;
-  const uv = python?.uv ?? await ensureUv(resolved);
-  const command = buildUvCommand(uv, args, resolved, python?.python);
-  return import_node_child_process2.spawn(command.executable, command.args, {
-    ...spawnOptions,
-    env: command.env
+async function withProvisioningLock(options) {
+  let existing;
+  const result = await import_loqkit.withLock({ resource: options.key }, options.mutate, {
+    key: options.key,
+    name: "Pyfig uv setup",
+    namespace: "pyfig",
+    timeout: COORDINATION_TIMEOUT_MS,
+    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 uv.`);
+}
+function uvCacheDirectory(env) {
+  const home = environmentValue(env, process.platform === "win32" ? "USERPROFILE" : "HOME") ?? import_node_os.default.homedir();
+  const root = process.platform === "win32" ? environmentValue(env, "LOCALAPPDATA") ?? import_node_path2.default.join(home, "AppData", "Local") : process.platform === "darwin" ? import_node_path2.default.join(home, "Library", "Caches") : environmentValue(env, "XDG_CACHE_HOME") ?? import_node_path2.default.join(home, ".cache");
+  return import_node_path2.default.resolve(root, "pyfig");
 }
-function uvSpawnSync(args = [], spawnOptions = {}, pyfigOptions = {}) {
-  const options = optionsForInvocation(pyfigOptions, spawnOptions.env);
-  const resolved = resolveOptions(options);
-  const python = uvCommandNeedsPython(args) ? resolveSynchronously("python", resolved) : undefined;
-  const uv = python?.uv ?? resolveSynchronously("uv", resolved);
-  const command = buildUvCommand(uv, args, resolved, python?.python);
-  return import_node_child_process2.spawnSync(command.executable, command.args, {
-    ...spawnOptions,
-    env: command.env
+function uvInstallRoot(context) {
+  return import_node_path2.default.join(context.cache, "tools", "uv");
+}
+function uvInstallDirectory(context, version) {
+  return import_node_path2.default.join(uvInstallRoot(context), version);
+}
+function uvExecutable(context, version) {
+  return import_node_path2.default.join(uvInstallDirectory(context, version), process.platform === "win32" ? "uv.exe" : "uv");
+}
+function uvReleaseMetadataFile(context) {
+  return import_node_path2.default.join(context.cache, "metadata", "uv-releases.json");
+}
+function uvAsset() {
+  const architecture = process.arch === "x64" ? "x86_64" : process.arch === "arm64" ? "aarch64" : null;
+  if (!architecture)
+    throw new Error(`uv setup 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 setup does not support platform ${process.platform}.`);
+}
+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 buildUvCommand(uv, args, options, python) {
-  return {
-    executable: uv.executable,
-    args: python ? targetUvArguments(args, python) : [...args],
-    env: uvCommandProcessEnvironment(uvProcessEnvironment(options), python)
-  };
+function canonicalPath(value) {
+  const normalized = import_node_path2.default.resolve(value);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function uniqueSuffix() {
+  return `${process.pid}.${import_node_crypto.randomUUID()}`;
 }
-function optionsForInvocation(pyfigOptions, spawnEnv) {
-  return spawnEnv === undefined ? pyfigOptions : { ...pyfigOptions, env: spawnEnv };
+
+// src/pyfig.ts
+var DEFAULT_UV = ">=0.10,<1";
+var PYTHON_PROBE = String.raw`
+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 = []
+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"))
+else:
+    for directory in [
+        sysconfig.get_config_var("LIBDIR"),
+        sysconfig.get_config_var("LIBPL"),
+        os.path.join(base_prefix, "lib"),
+    ]:
+        for name in [sysconfig.get_config_var("LDLIBRARY"), sysconfig.get_config_var("LIBRARY")]:
+            if directory and name:
+                library_candidates.append(os.path.join(directory, name))
+
+release_suffix = {"alpha": "a", "beta": "b", "candidate": "rc", "final": ""}[sys.version_info.releaselevel]
+if release_suffix:
+    release_suffix += str(sys.version_info.serial)
+
+print(json.dumps({
+    "executable": sys.executable,
+    "version": ".".join(map(str, sys.version_info[:3])) + release_suffix,
+    "implementation": sys.implementation.name,
+    "architecture": platform.machine().lower(),
+    "pointerBits": struct.calcsize("P") * 8,
+    "gilDisabled": bool(sysconfig.get_config_var("Py_GIL_DISABLED")),
+    "embedding": os.path.isfile(header_path) and any(os.path.isfile(path) for path in library_candidates),
+}))
+`;
+
+class PythonContext {
+  #cwd;
+  #env;
+  uv;
+  python;
+  constructor(uvPath, pythonPath, cwd = process.cwd(), env = process.env) {
+    this.#cwd = cwd;
+    this.#env = { ...env };
+    this.uv = uvPath;
+    this.python = pythonPath;
+    Object.freeze(this);
+  }
+  run(...input) {
+    const { args, spawnOptions } = splitRunInput(input);
+    return import_node_child_process2.spawn(this.uv, buildRunArgs(this.python, args), {
+      cwd: this.#cwd,
+      env: this.#env,
+      stdio: "inherit",
+      windowsHide: true,
+      ...spawnOptions
+    });
+  }
 }
-function resolveSynchronously(target, options) {
-  const resolved = resolveOptions(options);
-  const request = { target, options: resolved };
-  const result = import_node_child_process2.spawnSync(process.execPath, [runtimeFile("sync-resolver")], {
-    input: JSON.stringify(request),
-    encoding: "utf8",
-    env: resolved.env,
-    timeout: synchronousResolutionTimeout(resolved),
-    maxBuffer: 4 * 1024 * 1024,
-    windowsHide: true
+async function pyfig(options = {}) {
+  const {
+    uv: uvRequest = DEFAULT_UV,
+    python: pythonRequest,
+    requireEmbedding = false,
+    requireGil = false,
+    cwd = process.cwd(),
+    env: suppliedEnvironment
+  } = options;
+  const env = mergeEnvironment(suppliedEnvironment);
+  const workingDirectory = import_node_path3.default.resolve(cwd);
+  const uvPath = await selectUv(uvRequest, workingDirectory, env);
+  const selectedPythonPath = await selectPython({
+    cwd: workingDirectory,
+    env,
+    pythonRequest,
+    requireEmbedding,
+    requireGil,
+    uvPath
   });
-  if (result.status !== 0 || result.error) {
-    const detail = result.stderr.trim() || result.error?.message || `exit ${result.status}`;
-    throw new Error(`Could not resolve ${target} synchronously: ${detail}`);
+  return new PythonContext(uvPath, selectedPythonPath, workingDirectory, env);
+}
+function buildRunArgs(pythonPath, args) {
+  const separator = args.indexOf("--");
+  if (separator < 0) {
+    return ["run", "--python", pythonPath, "--", ...args];
+  }
+  const uvArgs = args.slice(0, separator);
+  const command = args.slice(separator + 1);
+  if (uvArgs.some((argument) => argument === "--python" || argument.startsWith("--python="))) {
+    throw new TypeError("run() does not accept --python before --; Python is selected by pyfig().");
+  }
+  uvArgs.push("--python", pythonPath);
+  return ["run", ...uvArgs, "--", ...command];
+}
+function splitRunInput(input) {
+  const values = [...input];
+  const last = values.at(-1);
+  const spawnOptions = typeof last === "object" && last !== null && !Array.isArray(last) ? values.pop() : {};
+  if (!values.every((value) => typeof value === "string")) {
+    throw new TypeError("uv run arguments must be strings with an optional SpawnOptions object last.");
+  }
+  return { args: values, spawnOptions };
+}
+async function selectUv(request, cwd, env) {
+  const selection = await executableOrSpecifier("uv", request, cwd, env);
+  if (selection.executable)
+    return selection.executable;
+  const specifier = selection.specifier;
+  if (!specifier)
+    throw new Error("uv selection did not contain a version specifier.");
+  return resolveUv(specifier, cwd, env);
+}
+async function selectPython(options) {
+  if (options.pythonRequest !== undefined) {
+    const selection = await executableOrSpecifier("python", options.pythonRequest, options.cwd, options.env);
+    if (selection.executable) {
+      const explicit = await probePython(selection.executable, options.cwd, options.env);
+      validatePythonCapabilities(explicit, options);
+      return explicit.executable;
+    }
+    if (!selection.specifier)
+      throw new Error("Python selection did not contain a version specifier.");
+    return selectDiscoveredPython(selection.specifier, options);
+  }
+  return selectDiscoveredPython(null, options);
+}
+async function selectDiscoveredPython(specifier, options) {
+  const request = specifier ? [specifier] : [];
+  let systemFailure;
+  try {
+    const systemPath = await findPython(options.uvPath, ["--system", "--no-managed-python", ...request], options);
+    const system = await probePython(systemPath, options.cwd, options.env);
+    validatePythonVersion(system, specifier);
+    validatePythonCapabilities(system, options);
+    return system.executable;
+  } catch (error) {
+    systemFailure = error;
   }
   try {
-    return JSON.parse(result.stdout);
+    const managedPath = await findPython(options.uvPath, ["--managed-python", ...request], options);
+    const managed = await probePython(managedPath, options.cwd, options.env);
+    validatePythonVersion(managed, specifier);
+    validatePythonCapabilities(managed, options);
+    return managed.executable;
   } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    throw new Error(`Could not parse synchronous ${target} resolution: ${detail}`);
+    throw new Error(`No compatible Python was found. System: ${errorMessage(systemFailure)} Managed: ${errorMessage(error)}`, { cause: error });
   }
 }
-function synchronousResolutionTimeout(options) {
-  return options.coordinationTimeoutMs + options.downloadTimeoutMs + 2 * options.installTimeoutMs + 4 * options.probeTimeoutMs + 60000;
+async function findPython(uvPath, args, options) {
+  const output = await capture(uvPath, ["python", "find", ...args], options.cwd, options.env);
+  const executable = output.trim().split(/\r?\n/u).at(-1) ?? "";
+  if (!import_node_path3.default.isAbsolute(executable)) {
+    throw new Error(`uv did not report an absolute Python path: ${executable || "<empty>"}`);
+  }
+  return import_node_path3.default.normalize(executable);
 }
-
-// src/client.ts
-class Python {
-  #options;
-  #python;
-  #uvInfo;
-  constructor(options = {}) {
-    this.#options = {
-      ...options,
-      dependencies: options.dependencies ? [...options.dependencies] : undefined,
-      requirements: options.requirements ? [...options.requirements] : undefined,
-      env: options.env ? { ...options.env } : undefined
-    };
-    this.#python = import_loqkit2.memoize(() => ensurePython(this.#options));
-    this.#uvInfo = import_loqkit2.memoize(() => ensureUv(this.#options));
+async function probePython(executable, cwd, env) {
+  const output = await capture(executable, ["-I", "-S", "-c", PYTHON_PROBE], cwd, env);
+  const line = output.trim().split(/\r?\n/u).at(-1) ?? "";
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch (error) {
+    throw new Error(`${JSON.stringify(executable)} did not return valid Python metadata.`, {
+      cause: error
+    });
+  }
+  if (!isPythonProbe(value)) {
+    throw new Error(`${JSON.stringify(executable)} returned incomplete Python metadata.`);
   }
-  prepare() {
-    return this.#python();
+  if (!import_node_path3.default.isAbsolute(value.executable)) {
+    throw new Error(`${JSON.stringify(executable)} reported a non-absolute executable path.`);
   }
-  async pythonInfo() {
-    return (await this.#python()).python;
+  return { ...value, executable: import_node_path3.default.normalize(value.executable) };
+}
+function validatePythonVersion(python, specifier) {
+  if (!specifier)
+    return;
+  const version = import_pep4402.valid(python.version);
+  if (!version)
+    throw new Error(`Python ${python.executable} reported invalid version ${python.version}.`);
+  if (import_pep4402.filter([version], specifier).length !== 1) {
+    throw new Error(`Python ${version} does not satisfy ${specifier}.`);
+  }
+}
+function validatePythonCapabilities(python, options) {
+  if (options.requireEmbedding) {
+    if (python.implementation !== "cpython") {
+      throw new Error(`Python embedding requires CPython, received ${python.implementation}.`);
+    }
+    if (!python.embedding) {
+      throw new Error(`Python ${python.executable} does not provide embedding headers and a library.`);
+    }
+    if (!pythonArchitectureMatchesRuntime(python)) {
+      throw new Error(`Python ${python.executable} does not match the JavaScript runtime architecture.`);
+    }
   }
-  uvInfo() {
-    return this.#uvInfo();
+  if (options.requireGil && python.gilDisabled) {
+    throw new Error(`Python ${python.executable} is free-threaded but requireGil is enabled.`);
   }
-  uv(args = [], options = {}) {
-    return uvSpawn(args, options, this.#options);
+}
+function pythonArchitectureMatchesRuntime(python) {
+  if (python.pointerBits !== (process.arch === "ia32" ? 32 : 64))
+    return false;
+  if (process.arch === "x64")
+    return python.architecture === "x86_64" || python.architecture === "amd64";
+  if (process.arch === "arm64")
+    return python.architecture === "aarch64" || python.architecture === "arm64";
+  if (process.arch === "ia32") {
+    return python.architecture === "x86" || python.architecture === "i386" || python.architecture === "i686";
   }
-  uvSync(args, options) {
-    return uvSpawnSync(args, options, this.#options);
+  return python.architecture === process.arch;
+}
+async function executableOrSpecifier(name, value, cwd, env) {
+  assertNonempty(name, value);
+  const executable = await findExecutable(value, cwd, env);
+  if (executable)
+    return { executable, specifier: null };
+  if (import_pep4402.validRange(value))
+    return { executable: null, specifier: value };
+  throw new TypeError(`${name} must resolve to an executable or be a valid PEP 440 specifier, received ${JSON.stringify(value)}.`);
+}
+function isPythonProbe(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const probe = value;
+  return typeof probe["architecture"] === "string" && typeof probe["embedding"] === "boolean" && typeof probe["executable"] === "string" && typeof probe["gilDisabled"] === "boolean" && typeof probe["implementation"] === "string" && typeof probe["pointerBits"] === "number" && typeof probe["version"] === "string";
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function mergeEnvironment(supplied) {
+  const environment = { ...process.env };
+  for (const [key, value] of Object.entries(supplied ?? {})) {
+    if (process.platform === "win32") {
+      const existing = Object.keys(environment).find((candidate) => candidate.toLowerCase() === key.toLowerCase());
+      if (existing && existing !== key)
+        delete environment[existing];
+    }
+    if (value === undefined)
+      delete environment[key];
+    else
+      environment[key] = value;
   }
+  return environment;
+}
+function assertNonempty(name, value) {
+  if (value.trim() === "")
+    throw new TypeError(`${name} must not be empty.`);
 }
 
-//# debugId=653756BC4A56AC4F64756E2164756E21
+//# debugId=F23B5C2985518F2764756E2164756E21