Add tooltip documentation to web request and brush related nodes (#3427)

* Add tooltip documentation to web request, text, and brush nodes

  - Add descriptive tooltips to web request nodes (GET/POST, string/image conversion, resource loading, image decoding)
  - Add tooltip to GPU rasterization node explaining footprint usage
  - Improve text node tooltip with clearer per_glyph_instances parameter explanation
  - Add tooltips to brush stamp generator and blit operations explaining their internal roles
  - Fix typos in tooltip and variable names (it's→its, perview→preview, instnace→instance)

* Fixed 2 issues with previous changes. Reversed order of documentation about per_glyph_instances. Can it be 3 lines?

* Improve post_request node documentation

Change doc comment to describe the node's purpose rather than focusing
only on the "Discard Result" parameter. Now clearly states this is an
HTTP POST operation with optional async behavior.

* Fix post_request documentation error

Corrected doc comment to say "HTTP POST" instead of "HTTP GET" since
this function performs POST requests with binary data.

* Review changes

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>

node-graph/nodes/brush/src/brush.rs

@@ -57,6 +57,9 @@ impl<P: Pixel + Alpha> Sample for BrushStampGenerator<P> {
 	}
 }
 
+/// Controls the brush shape with diameter and hardness, plus color and opacity (via flow).
+/// The feather exponent is calculated from hardness to determine edge softness.
+/// Used internally to create the brush texture before stamping it repeatedly along a stroke path.
 #[node_macro::node(skip_impl)]
 fn brush_stamp_generator(#[unit(" px")] diameter: f64, color: Color, hardness: f64, flow: f64) -> BrushStampGenerator<Color> {
 	// Diameter
@@ -76,6 +79,7 @@ fn brush_stamp_generator(#[unit(" px")] diameter: f64, color: Color, hardness: f
 	BrushStampGenerator { color, feather_exponent, transform }
 }
 
+/// Used to efficiently paint brush strokes. Applies the same texture repeatedly at different positions with proper blending and boundary handling.
 #[node_macro::node(skip_impl)]
 fn blit<BlendFn>(mut target: Table<Raster<CPU>>, texture: Raster<CPU>, positions: Vec<DVec2>, blend_mode: BlendFn) -> Table<Raster<CPU>>
 where

node-graph/nodes/gstd/src/wasm_application_io.rs

@@ -27,14 +27,24 @@ use wasm_bindgen::JsCast;
 #[cfg(target_family = "wasm")]
 use web_sys::{CanvasRenderingContext2d, HtmlCanvasElement};
 
+/// Allocates GPU memory and a rendering context for vector-to-raster conversion.
 #[cfg(feature = "wgpu")]
 #[node_macro::node(category("Debug: GPU"))]
 async fn create_surface<'a: 'n>(_: impl Ctx, editor: &'a WasmEditorApi) -> Arc<WasmSurfaceHandle> {
 	Arc::new(editor.application_io.as_ref().unwrap().create_window())
 }
 
+/// Sends an HTTP GET request to a specified URL and optionally waits for the response (unless discarded) which is output as a string.
 #[node_macro::node(category("Web Request"))]
-async fn get_request(_: impl Ctx, _primary: (), #[name("URL")] url: String, discard_result: bool) -> String {
+async fn get_request(
+	_: impl Ctx,
+	_primary: (),
+	/// The web address to send the GET request to.
+	#[name("URL")]
+	url: String,
+	/// Makes the request run in the background without waiting on a response. This is useful for triggering webhooks without blocking the continued execution of the graph.
+	discard_result: bool,
+) -> String {
 	#[cfg(target_family = "wasm")]
 	{
 		if discard_result {
@@ -63,8 +73,19 @@ async fn get_request(_: impl Ctx, _primary: (), #[name("URL")] url: String, disc
 	response.text().await.ok().unwrap_or_default()
 }
 
+/// Sends an HTTP POST request to a specified URL with the provided binary data and optionally waits for the response (unless discarded) which is output as a string.
 #[node_macro::node(category("Web Request"))]
-async fn post_request(_: impl Ctx, _primary: (), #[name("URL")] url: String, body: Vec<u8>, discard_result: bool) -> String {
+async fn post_request(
+	_: impl Ctx,
+	_primary: (),
+	/// The web address to send the POST request to.
+	#[name("URL")]
+	url: String,
+	/// The binary data to include in the body of the POST request.
+	body: Vec<u8>,
+	/// Makes the request run in the background without waiting on a response. This is useful for triggering webhooks without blocking the continued execution of the graph.
+	discard_result: bool,
+) -> String {
 	#[cfg(target_family = "wasm")]
 	{
 		if discard_result {
@@ -97,20 +118,23 @@ async fn post_request(_: impl Ctx, _primary: (), #[name("URL")] url: String, bod
 	response.text().await.ok().unwrap_or_default()
 }
 
+/// Converts a text string to raw binary data. Useful for transmission over HTTP or writing to files.
 #[node_macro::node(category("Web Request"), name("String to Bytes"))]
 fn string_to_bytes(_: impl Ctx, string: String) -> Vec<u8> {
 	string.into_bytes()
 }
 
+/// Converts extracted raw RGBA pixel data from an input image. Each pixel becomes 4 sequential bytes. Useful for transmission over HTTP or writing to files.
 #[node_macro::node(category("Web Request"), name("Image to Bytes"))]
 fn image_to_bytes(_: impl Ctx, image: Table<Raster<CPU>>) -> Vec<u8> {
 	let Some(image) = image.iter().next() else { return vec![] };
 	image.element.data.iter().flat_map(|color| color.to_rgb8_srgb().into_iter()).collect::<Vec<u8>>()
 }
 
+/// Loads binary from URLs and local asset paths. Returns a transparent placeholder if the resource fails to load, allowing workflows to continue.
 #[node_macro::node(category("Web Request"))]
-async fn load_resource<'a: 'n>(_: impl Ctx, _primary: (), #[scope("editor-api")] editor: &'a WasmEditorApi, #[name("URL")] url: String) -> Arc<[u8]> {
-	let Some(api) = editor.application_io.as_ref() else {
+async fn load_resource<'a: 'n>(_: impl Ctx, _primary: (), #[scope("editor-api")] editor_resources: &'a WasmEditorApi, #[name("URL")] url: String) -> Arc<[u8]> {
+	let Some(api) = editor_resources.application_io.as_ref() else {
 		return Arc::from(include_bytes!("../../../graph-craft/src/null.png").to_vec());
 	};
 	let Ok(data) = api.load_resource(url) else {
@@ -123,6 +147,9 @@ async fn load_resource<'a: 'n>(_: impl Ctx, _primary: (), #[scope("editor-api")]
 	data
 }
 
+/// Converts raw binary data to a raster image.
+///
+/// Works with standard image format (PNG, JPEG, WebP, etc.). Automatically converts the color space to linear sRGB for accurate compositing.
 #[node_macro::node(category("Web Request"))]
 fn decode_image(_: impl Ctx, data: Arc<[u8]>) -> Table<Raster<CPU>> {
 	let Some(image) = image::load_from_memory(data.as_ref()).ok() else {
@@ -142,6 +169,7 @@ fn decode_image(_: impl Ctx, data: Arc<[u8]>) -> Table<Raster<CPU>> {
 	Table::new_from_element(Raster::new_cpu(image))
 }
 
+/// Renders a view of the input graphic within an area defined by the *Footprint*.
 #[cfg(target_family = "wasm")]
 #[node_macro::node(category(""))]
 async fn rasterize<T: WasmNotSend + 'n>(

node-graph/nodes/path-bool/src/lib.rs

@@ -14,7 +14,7 @@ use std::ops::Mul;
 // Import specta so derive macros can find it
 use core_types::specta;
 
-// TODO: Fix boolean ops to work by removing .transform() and .one_instnace_*() calls,
+// TODO: Fix boolean ops to work by removing .transform() and .one_instance_*() calls,
 // TODO: since before we used a Vec of single-row tables and now we use a single table
 // TODO: with multiple rows while still assuming a single row for the boolean operations.