Image

[jsjgdh]

No description provided.

[gemini-code-assist]

Code Review

This pull request refactors the font and resource loading system by introducing a backend-driven asynchronous resource resolution system using a new network message handler and client. Text nodes are updated to use font resources via ResourceId instead of passing Font structs directly, and support is added for importing embedded SVG images. The review feedback suggests optimizing SVG image dimension extraction by reading only the image headers instead of decoding full pixel data, and resolving already-cached resources synchronously to avoid spawning redundant asynchronous network requests.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

Decoding the entire image using ::image::load_from_memory_with_format just to retrieve its dimensions is highly inefficient, especially for large embedded SVG images. Consider using ::image::Reader with into_dimensions() to parse only the image header and extract the width and height without decoding the full pixel data.

Suggested change

	let decoded_image = match ::image::load_from_memory_with_format(image_data, format) {
	Ok(img) => img,
	Err(e) => {
	log::warn!("Failed to decode SVG image data: {:?}", e);
	return;
	}
	};
	let width = decoded_image.width();
	let height = decoded_image.height();
	let (width, height) = match ::image::Reader::with_format(std::io::Cursor::new(image_data), format).into_dimensions() {
	Ok(dim) => dim,
	Err(e) => {
	log::warn!("Failed to parse SVG image dimensions: {:?}", e);
	return;
	}
	};

[gemini-code-assist]

When resolving a resource, if the resource is already cached locally (i.e., fonts.cached_hash(&font) returns Some(hash)), we can resolve it synchronously and return immediately. This avoids the overhead of spawning an asynchronous network request and dispatching a client call for already-cached resources.

				let sources = info
					.sources
					.iter()
					.map(|source| match source {
						DataSource::Font { family, style } => {
							let font = match style {
								Some(style) => Font::new(family.clone(), style.clone()),
								None => Font::new_with_default_style(family.clone()),
							};
							let hash = fonts.cached_hash(&font);
							(source.clone(), hash)
						}
						source => (source.clone(), None),
					})
					.collect::<Vec<(DataSource, Option<ResourceHash>)>>();

				if let Some((source, Some(hash))) = sources.iter().find(|(_, hash)| hash.is_some()) {
					responses.add(ResourceMessage::Resolved { resource_id, source: source.clone(), hash: *hash });
					return;
				}

				self.pending_resolves.insert(resource_id);

				let font_catalog = fonts.font_catalog.clone();