π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Move Space post handling into Rust and simplify WASM reads
Manav Rathic610e5676e80
diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rsindex a13d78a961..e92bd42fe8 100644--- a/rust/bindings/wasm/space/src/space.rs+++ b/rust/bindings/wasm/space/src/space.rs@@ -1,7 +1,7 @@use std::collections::BTreeMap;use ente_core::b64;-use ente_space::{AccountSpaceCtx, DecryptedMessage, DecryptedPost, MessagePayload, SpaceLinkCtx};+use ente_space::{AccountSpaceCtx, DecryptedMessage, MessagePayload, SpaceLinkCtx};use serde::{Deserialize, Serialize};use serde_wasm_bindgen as swb;use tsify::Tsify;@@ -178,7 +178,8 @@ pub struct DecryptedSpaceProfile {friends: i64,#[serde(skip_serializing_if = "Option::is_none")]posts: Option<i64>,- profile: String,+ #[serde(skip_serializing_if = "Option::is_none")]+ profile: Option<SpaceProfile>,avatar: Option<ProfileAvatarResponse>,cover: Option<ProfileAvatarResponse>,updated_at: Option<String>,@@ -230,7 +231,9 @@ struct SpaceActorResponse {space_slug: String,public_key: String,key_version: i32,- profile: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ profile: Option<SpaceProfile>,+ #[serde(skip_serializing_if = "Option::is_none")]avatar: Option<ProfileAvatarResponse>,}@@ -242,12 +245,10 @@ pub struct PostResponse {space_slug: String,author: SpaceActorResponse,caption: Option<String>,- encrypted_post_key: String,- key_version: i32,- objects: Vec<PostObjectPayload>,+ photos: Vec<PostPhoto>,+ is_unavailable: bool,created_at: String,viewer_liked: bool,- is_unavailable: bool,}#[derive(Serialize, Tsify)]@@ -302,10 +303,8 @@ struct MessageConversationActivity {#[derive(Serialize, Tsify)]#[serde(rename_all = "camelCase")]-struct PostObjectPayload {- object_key: String,- #[serde(skip_serializing_if = "Option::is_none")]- size: Option<i64>,+struct PostPhoto {+ asset: PostAsset,#[serde(skip_serializing_if = "Option::is_none")]position: Option<i32>,#[serde(skip_serializing_if = "Option::is_none")]@@ -454,16 +453,6 @@ fn decode_b64_field(value: &str) -> Result<Vec<u8>, Error> {.map_err(Into::into)}-fn utf8_field(bytes: Vec<u8>, field: &str) -> Result<String, Error> {- String::from_utf8(bytes).map_err(|err| {- ente_space::Error::InvalidInput(format!("invalid {field} utf8: {err}")).into()- })-}--fn optional_utf8_field(bytes: Option<Vec<u8>>, field: &str) -> Result<Option<String>, Error> {- bytes.map(|value| utf8_field(value, field)).transpose()-}-fn created_space_to_js(value: ente_space::CreatedSpace) -> CreatedSpace {CreatedSpace {space_id: value.space_id,@@ -471,183 +460,171 @@ fn created_space_to_js(value: ente_space::CreatedSpace) -> CreatedSpace {}}-fn profile_to_js(value: ente_space::DecryptedSpaceProfile) -> Result<DecryptedSpaceProfile, Error> {- let profile = String::from_utf8(value.profile).unwrap_or_else(|error| {- log::warn!(- "Space profile {} has invalid UTF-8: {error}",- value.space_id- );- String::new()- });- Ok(DecryptedSpaceProfile {+fn profile_to_js(value: ente_space::DecryptedSpaceProfile) -> DecryptedSpaceProfile {+ DecryptedSpaceProfile {space_id: value.space_id,space_slug: value.space_slug,version: value.version,friends: value.friends,posts: None,- profile,+ profile: value.profile.map(Into::into),avatar: value.avatar.map(Into::into),cover: value.cover.map(Into::into),updated_at: value.updated_at,- })+ }}fn actor_to_js(actor: ente_space::SpaceActorResponse,- profile: Option<Vec<u8>>,-) -> Result<SpaceActorResponse, Error> {- Ok(SpaceActorResponse {+ profile: Option<ente_space::SpaceProfile>,+) -> SpaceActorResponse {+ SpaceActorResponse {space_id: actor.space_id,space_slug: actor.space_slug,public_key: actor.public_key,key_version: actor.key_version,- profile: optional_utf8_field(profile, "actor profile")?,+ profile: profile.map(Into::into),avatar: actor.avatar.map(Into::into),- })+ }}async fn account_actor_to_js(ctx: &AccountSpaceCtx,actor: ente_space::SpaceActorResponse,) -> Result<SpaceActorResponse, Error> {- let fallback = actor.clone();- let converted = match ctx.decrypt_actor_profile(&actor).await {- Ok(profile) => actor_to_js(actor, profile),- Err(error) => Err(error.into()),- };- match converted {- Ok(actor) => Ok(actor),+ match ctx.decrypt_actor_profile(&actor).await.map_err(Error::from) {+ Ok(profile) => Ok(actor_to_js(actor, profile)),Err(error) if error.is_content_error() => {log::warn!("Space profile {} fell back to public fields: {}",- fallback.space_id,+ actor.space_id,error.message());- public_actor_to_js(fallback)+ Ok(public_actor_to_js(actor))}Err(error) => Err(error),}}-fn public_actor_to_js(actor: ente_space::SpaceActorResponse) -> Result<SpaceActorResponse, Error> {+fn public_actor_to_js(actor: ente_space::SpaceActorResponse) -> SpaceActorResponse {actor_to_js(actor, None)}-fn post_object_to_js(- post_key: Option<&[u8]>,- object: ente_space::PostObjectPayload,-) -> Result<PostObjectPayload, Error> {- let metadata = match post_key {- Some(post_key) => ente_space::client::decrypt_post_object_metadata(post_key, &object)?,- None => None,+fn post_to_js(post: ente_space::Post) -> PostResponse {+ let (caption, photos, is_unavailable) = match post.content {+ Ok(content) => (+ content.caption,+ content.photos.into_iter().map(Into::into).collect(),+ false,+ ),+ Err(error) => {+ log::warn!(+ "Space post {} is unavailable: {}",+ post.post_id,+ ente_core::error::chain(&error)+ );+ (None, Vec::new(), true)+ }};- Ok(PostObjectPayload {- object_key: object.object_key,- size: object.size,- position: object.position,- variant: metadata.as_ref().and_then(|value| value.variant.clone()),- blur_hash: metadata.as_ref().and_then(|value| value.blur_hash.clone()),- thumb_hash: metadata.as_ref().and_then(|value| value.thumb_hash.clone()),- width: metadata.as_ref().and_then(|value| value.width),- height: metadata.as_ref().and_then(|value| value.height),- media_type: metadata.and_then(|value| value.media_type),- })-}--fn post_objects_to_js(- post_key: Option<&[u8]>,- objects: Vec<ente_space::PostObjectPayload>,-) -> Result<Vec<PostObjectPayload>, Error> {- objects- .into_iter()- .map(|object| post_object_to_js(post_key, object))- .collect()-}--async fn account_post_to_js(- ctx: &AccountSpaceCtx,- post: ente_space::PostResponse,- decrypted: DecryptedPost,-) -> Result<PostResponse, Error> {- let author = account_actor_to_js(ctx, post.author).await?;- Ok(PostResponse {+ let profile = post.author.profile.unwrap_or_else(|error| {+ log::warn!(+ "Space profile {} fell back to public fields: {}",+ post.author.space_id,+ ente_core::error::chain(&error)+ );+ None+ });+ PostResponse {post_id: post.post_id,space_id: post.space_id,space_slug: post.space_slug,- author,- caption: optional_utf8_field(decrypted.caption_plaintext, "caption")?,- encrypted_post_key: post.encrypted_post_key,- key_version: post.key_version,- objects: post_objects_to_js(Some(&decrypted.post_key), post.objects)?,+ author: SpaceActorResponse {+ space_id: post.author.space_id,+ space_slug: post.author.space_slug,+ public_key: post.author.public_key,+ key_version: post.author.key_version,+ profile: profile.map(Into::into),+ avatar: post.author.avatar.map(Into::into),+ },+ caption,+ photos,+ is_unavailable,created_at: post.created_at,viewer_liked: post.viewer_liked,- is_unavailable: false,- })+ }}-fn unavailable_post_to_js(post: ente_space::PostResponse) -> Result<PostResponse, Error> {- Ok(PostResponse {- post_id: post.post_id,- space_id: post.space_id,- space_slug: post.space_slug,- author: public_actor_to_js(post.author)?,- caption: None,- encrypted_post_key: post.encrypted_post_key,- key_version: post.key_version,- objects: Vec::new(),- created_at: post.created_at,- viewer_liked: post.viewer_liked,- is_unavailable: true,- })+#[derive(Serialize, Tsify)]+#[serde(rename_all = "camelCase")]+struct SpaceProfile {+ #[serde(skip_serializing_if = "Option::is_none")]+ full_name: Option<String>,+ #[serde(skip_serializing_if = "Option::is_none")]+ display_name: Option<String>,}-async fn account_post_page_to_js(- ctx: &AccountSpaceCtx,- page: ente_space::PostPage,-) -> Result<PostPage, Error> {- let mut items = Vec::with_capacity(page.items.len());- for post in page.items {- let fallback = post.clone();- let converted = match ctx.decrypt_post_for_space(&post.space_id, &post).await {- Ok(decrypted) => account_post_to_js(ctx, post, decrypted).await,- Err(error) => Err(error.into()),- };- match converted {- Ok(post) => items.push(post),- Err(error) if error.is_content_error() => {- log::warn!(- "Space post {} is unavailable: {}",- fallback.post_id,- error.message()- );- items.push(unavailable_post_to_js(fallback)?);- }- Err(error) => return Err(error),+impl From<ente_space::SpaceProfile> for SpaceProfile {+ fn from(profile: ente_space::SpaceProfile) -> Self {+ Self {+ full_name: profile.full_name,+ display_name: profile.display_name,}}- Ok(PostPage {- items,- next_cursor: page.next_cursor,- })}-fn link_post_to_js(- post: ente_space::PostResponse,- decrypted: DecryptedPost,-) -> Result<PostResponse, Error> {- Ok(PostResponse {- post_id: post.post_id,- space_id: post.space_id,- space_slug: post.space_slug,- author: public_actor_to_js(post.author)?,- caption: optional_utf8_field(decrypted.caption_plaintext, "caption")?,- encrypted_post_key: post.encrypted_post_key,- key_version: post.key_version,- objects: post_objects_to_js(Some(&decrypted.post_key), post.objects)?,- created_at: post.created_at,- viewer_liked: false,- is_unavailable: false,- })+#[derive(Serialize, Deserialize, Tsify)]+#[serde(rename_all = "camelCase")]+pub struct PostAsset {+ space_id: String,+ post_id: i64,+ object_key: String,+ encrypted_post_key: String,+ key_version: i32,+ #[serde(skip_serializing_if = "Option::is_none")]+ size: Option<i64>,+}++impl From<PostAsset> for ente_space::PostAsset {+ fn from(asset: PostAsset) -> Self {+ Self {+ space_id: asset.space_id,+ post_id: asset.post_id,+ object_key: asset.object_key,+ encrypted_post_key: asset.encrypted_post_key,+ key_version: asset.key_version,+ size: asset.size,+ }+ }+}++impl From<ente_space::PostPhoto> for PostPhoto {+ fn from(photo: ente_space::PostPhoto) -> Self {+ let metadata = photo.metadata.unwrap_or_default();+ Self {+ asset: PostAsset {+ space_id: photo.asset.space_id,+ post_id: photo.asset.post_id,+ object_key: photo.asset.object_key,+ encrypted_post_key: photo.asset.encrypted_post_key,+ key_version: photo.asset.key_version,+ size: photo.asset.size,+ },+ position: photo.position,+ variant: metadata.variant,+ blur_hash: metadata.blur_hash,+ thumb_hash: metadata.thumb_hash,+ width: metadata.width,+ height: metadata.height,+ media_type: metadata.media_type,+ }+ }+}++fn post_page_to_js(page: ente_space::PostPage) -> PostPage {+ PostPage {+ items: page.items.into_iter().map(post_to_js).collect(),+ next_cursor: page.next_cursor,+ }}fn account_message_to_js(@@ -884,7 +861,7 @@ pub struct SpaceLinkCtxHandle {impl SpaceLinkCtxHandle {#[wasm_bindgen(js_name = getProfile)]pub fn get_profile(&self) -> Result<<DecryptedSpaceProfile as Tsify>::JsType, Error> {- let mut profile = profile_to_js(self.inner.profile().clone())?;+ let mut profile = profile_to_js(self.inner.profile().clone());profile.posts = Some(self.inner.posts());profile.into_js().map_err(Into::into)}@@ -892,32 +869,7 @@ impl SpaceLinkCtxHandle {#[wasm_bindgen(js_name = listPosts)]pub async fn list_posts(&self) -> Result<<PostPage as Tsify>::JsType, Error> {let page = self.inner.list_posts().await?;- let mut items = Vec::with_capacity(page.items.len());- for post in page.items {- let fallback = post.clone();- let converted = match self.inner.decrypt_post(&post) {- Ok(decrypted) => link_post_to_js(post, decrypted),- Err(error) => Err(error.into()),- };- match converted {- Ok(post) => items.push(post),- Err(error) if error.is_content_error() => {- log::warn!(- "Space post {} is unavailable: {}",- fallback.post_id,- error.message()- );- items.push(unavailable_post_to_js(fallback)?);- }- Err(error) => return Err(error),- }- }- PostPage {- items,- next_cursor: page.next_cursor,- }- .into_js()- .map_err(Into::into)+ post_page_to_js(page).into_js().map_err(Into::into)}#[wasm_bindgen(js_name = subscribeWebPush)]@@ -944,12 +896,11 @@ impl SpaceLinkCtxHandle {#[wasm_bindgen(js_name = downloadPostAsset)]pub async fn download_post_asset(&self,- encrypted_post_key: String,- key_version: i32,- object_key: String,+ asset: <PostAsset as Tsify>::JsType,) -> Result<Vec<u8>, Error> {+ let asset = PostAsset::from_js(asset)?;self.inner- .download_post_asset(&encrypted_post_key, key_version, &object_key)+ .download_post_asset(&asset.into()).await.map_err(Into::into)}@@ -1028,7 +979,7 @@ impl SpaceAccountCtxHandle {self.inner.get_space_profile_for_display(&space_id, viewer_space_id.as_deref(), None).await?,- )?+ ).into_js().map_err(Into::into)}@@ -1162,10 +1113,7 @@ impl SpaceAccountCtxHandle {limit: Option<i32>,) -> Result<<PostPage as Tsify>::JsType, Error> {let page = self.inner.list_feed(&space_id, cursor, limit).await?;- account_post_page_to_js(&self.inner, page)- .await?- .into_js()- .map_err(Into::into)+ post_page_to_js(page).into_js().map_err(Into::into)}#[wasm_bindgen(js_name = unreadStatus)]@@ -1201,13 +1149,11 @@ impl SpaceAccountCtxHandle {cursor: Option<String>,limit: Option<i32>,) -> Result<<PostPage as Tsify>::JsType, Error> {- account_post_page_to_js(- &self.inner,+ post_page_to_js(self.inner.list_posts(&space_id, viewer_space_id.as_deref(), cursor, limit).await?,)- .await?.into_js().map_err(Into::into)}@@ -1223,14 +1169,7 @@ impl SpaceAccountCtxHandle {.inner.get_post(&space_id, post_id, viewer_space_id.as_deref()).await?;- let decrypted = self- .inner- .decrypt_post_for_viewer(&post.space_id, viewer_space_id.as_deref(), &post)- .await?;- account_post_to_js(&self.inner, post, decrypted)- .await?- .into_js()- .map_err(Into::into)+ post_to_js(post).into_js().map_err(Into::into)}#[wasm_bindgen(js_name = createPhotoPost)]@@ -1282,33 +1221,18 @@ impl SpaceAccountCtxHandle {.inner.get_post(&space_id, post_id, Some(&space_id)).await?;- let decrypted = self- .inner- .decrypt_post_for_viewer(&post.space_id, Some(&space_id), &post)- .await?;- account_post_to_js(&self.inner, post, decrypted)- .await?- .into_js()- .map_err(Into::into)+ post_to_js(post).into_js().map_err(Into::into)}- #[wasm_bindgen(js_name = downloadPostAssetWithKey)]- pub async fn download_post_asset_with_key(+ #[wasm_bindgen(js_name = downloadPostAsset)]+ pub async fn download_post_asset(&self,- space_id: String,- encrypted_post_key: String,- key_version: i32,+ asset: <PostAsset as Tsify>::JsType,viewer_space_id: Option<String>,- object_key: String,) -> Result<Vec<u8>, Error> {+ let asset = PostAsset::from_js(asset)?;self.inner- .download_post_asset_with_key(- &space_id,- &encrypted_post_key,- key_version,- viewer_space_id.as_deref(),- &object_key,- )+ .download_post_asset(&asset.into(), viewer_space_id.as_deref()).await.map_err(Into::into)}@@ -1493,7 +1417,7 @@ impl SpaceAccountCtxHandle {for request in response.pending_requests {pending_requests.push(SpaceFriendRequestResponse {request_id: request.request_id,- requester: public_actor_to_js(request.requester)?,+ requester: public_actor_to_js(request.requester),created_at: request.created_at,});}@@ -1565,21 +1489,8 @@ impl SpaceAccountCtxHandle {post_id: i64,caption: Option<String>,) -> Result<(), Error> {- let post = self- .inner- .get_post(&space_id, post_id, Some(&space_id))- .await?;- let decrypted_post = self- .inner- .decrypt_post_for_viewer(&post.space_id, Some(&space_id), &post)- .await?;self.inner- .update_post_caption(- &space_id,- post_id,- &decrypted_post.post_key,- caption.as_ref().map(String::as_bytes),- )+ .update_post_caption(&space_id, post_id, caption.as_ref().map(String::as_bytes)).await.map_err(Into::into)}@@ -1623,7 +1534,7 @@ impl SpaceAccountCtxHandle {items.push(SpaceFriendRequestResponse {request_id: request.request_id,- requester: public_actor_to_js(request.requester)?,+ requester: public_actor_to_js(request.requester),created_at: request.created_at,}.into_js()?,@@ -1643,7 +1554,7 @@ impl SpaceAccountCtxHandle {items.push(SpaceSentFriendRequestResponse {request_id: request.request_id,- target: public_actor_to_js(request.target)?,+ target: public_actor_to_js(request.target),created_at: request.created_at,}.into_js()?,@@ -1698,25 +1609,6 @@ mod tests {use super::*;- fn post(post_id: i64, encrypted_post_key: String) -> ente_space::PostResponse {- ente_space::PostResponse {- post_id,- space_id: "space-1".into(),- space_slug: "alice".into(),- author: ente_space::SpaceActorResponse {- space_id: "space-1".into(),- space_slug: "alice".into(),- ..Default::default()- },- encrypted_post_key,- caption_cipher: String::new(),- key_version: 1,- objects: Vec::new(),- created_at: format!("2026-08-0{post_id}T00:00:00Z"),- viewer_liked: false,- }- }-fn message(message_id: &str,encrypted_message_key: &str,@@ -1740,54 +1632,6 @@ mod tests {}}- #[tokio::test]- async fn corrupt_post_does_not_reject_account_page() {- let root_key = Key::generate();- let space_key = Key::generate();- let wrapped_space_key = secretbox::encrypt_combined(space_key.as_bytes(), &root_key);- let valid_post_key = secretbox::encrypt_combined(Key::generate().as_bytes(), &space_key);- let ctx = AccountSpaceCtx::open(ente_space::OpenAccountSpaceCtxInput {- base_url: "http://localhost".into(),- space_session_token: None,- space_root_key: root_key.as_bytes().to_vec(),- initial_owned_spaces: Some(vec![ente_space::SpaceKeyResponse {- space_id: "space-1".into(),- space_slug: "alice".into(),- root_wrapped_space_key: b64::encode(&wrapped_space_key),- public_key: String::new(),- encrypted_secret_key: String::new(),- encrypted_profile: String::new(),- key_version: 1,- }]),- user_agent: None,- client_package: None,- client_version: None,- })- .unwrap();- let mut post_with_corrupt_actor_profile = post(1, b64::encode(&valid_post_key));- post_with_corrupt_actor_profile.author.key_version = 1;- post_with_corrupt_actor_profile.author.encrypted_profile = "not-base64".into();- let page = ente_space::PostPage {- items: vec![- post_with_corrupt_actor_profile,- post(2, "not-base64".into()),- post(3, b64::encode(&valid_post_key)),- ],- next_cursor: "next".into(),- };-- let converted = match account_post_page_to_js(&ctx, page).await {- Ok(converted) => converted,- Err(error) => panic!("{error}"),- };-- assert_eq!(converted.items.len(), 3);- assert!(!converted.items[0].is_unavailable);- assert!(converted.items[1].is_unavailable);- assert!(!converted.items[2].is_unavailable);- assert_eq!(converted.next_cursor, "next");- }-fn message_context() -> (AccountSpaceCtx, Key, String) {let root_key = Key::generate();let secret_key = SecretKey::generate();@@ -1968,22 +1812,4 @@ mod tests {assert!(!error.is_content_error());}-- #[test]- fn invalid_profile_utf8_uses_empty_payload() {- let profile = profile_to_js(ente_space::DecryptedSpaceProfile {- space_id: "space-1".into(),- space_slug: "alice".into(),- version: 1,- friends: 2,- profile: vec![0xff],- avatar: None,- cover: None,- updated_at: None,- })- .unwrap_or_else(|error| panic!("{error}"));-- assert!(profile.profile.is_empty());- assert_eq!(profile.space_slug, "alice");- }}diff --git a/rust/crates/space/src/client/keys.rs b/rust/crates/space/src/client/keys.rsindex 765f9c67e3..7bac9446cb 100644--- a/rust/crates/space/src/client/keys.rs+++ b/rust/crates/space/src/client/keys.rs@@ -1,7 +1,7 @@use std::collections::BTreeMap;use super::{AccountSpaceCtx, build_space_key_history_map};-use crate::crypto::{encrypt_secretbox_payload, generate_key};+use crate::crypto::{decrypt_secretbox_payload, encrypt_secretbox_payload, generate_key};use crate::error::{Error, Result};use crate::models::CreatedSpace;use crate::transport::{RotateSpaceKeyRequest, SpaceKeyResponse, SpaceKeyVersionResponse};@@ -80,20 +80,21 @@ impl AccountSpaceCtx {.ok_or_else(|| {Error::InvalidInput(format!("space {space_id} is not owned by the account"))})?;- let current_profile = if profile.is_none() {- Some(- self.get_space_profile_decrypted(space_id, None, None)- .await?,- )- } else {- None- };let next_profile = match profile {Some(value) => value.to_vec(),- None => current_profile- .as_ref()- .map(|value| value.profile.clone())- .ok_or_else(|| Error::InvalidInput("missing current profile".into()))?,+ None => {+ let profile = self.get_space_profile_raw(space_id, None, None).await?;+ let key = self+ .resolve_space_key_for_version(space_id, Some(profile.version))+ .await?+ .ok_or_else(|| Error::InvalidInput("missing current profile key".into()))?;+ // Preserve unknown profile fields during key rotation.+ if profile.encrypted_profile.is_empty() {+ Vec::new()+ } else {+ decrypt_secretbox_payload(&key, &b64::decode(&profile.encrypted_profile)?)?+ }+ }};let next_space_key = generate_key();let space_root_key = self.get_or_create_space_root_key()?;diff --git a/rust/crates/space/src/client/links.rs b/rust/crates/space/src/client/links.rsindex c6db530b3a..1a01683654 100644--- a/rust/crates/space/src/client/links.rs+++ b/rust/crates/space/src/client/links.rs@@ -8,14 +8,15 @@ use ente_core::{use super::{AccountSpaceCtx, build_api, build_space_key_history_map, cache_lock, decrypt_space_profile,+ posts::{decrypt_post, open_post_content, opened_post},space_profile_without_payload,};use crate::{crypto::{decrypt_asset_payload, decrypt_secretbox_payload, encrypt_secretbox_payload},error::{Error, Result},- models::{CreatedSpaceLink, DecryptedPost, DecryptedSpaceProfile, OpenSpaceLinkCtxInput},+ models::{CreatedSpaceLink, DecryptedSpaceProfile, OpenSpaceLinkCtxInput, PostAsset, PostPage},transport::{- AssetDownloadResponse, PostPage, PostResponse, SpaceKeyVersionResponse,+ AssetDownloadResponse, PostPageResponse, SpaceKeyVersionResponse,SpaceLinkBootstrapResponse, SpaceLinkProfileResponse, SpaceLinkStatusResponse,SpaceLinkWriteRequest, WebPushSubscriptionKeys, WebPushSubscriptionRequest,WebPushTargetResponse, WebPushUnsubscriptionRequest,@@ -247,7 +248,7 @@ impl SpaceLinkCtx {}pub async fn list_posts(&self) -> Result<PostPage> {- let page: PostPage = self+ let page: PostPageResponse = self.api.get(&format!("{}/posts", self.prefix())).header(AUTH_HEADER, &self.auth_key)@@ -267,7 +268,21 @@ impl SpaceLinkCtx {"space link changed while posts were being loaded".into(),));}- Ok(page)+ let items = page+ .items+ .into_iter()+ .map(|mut post| {+ let decrypted = self+ .space_key(post.key_version, "post")+ .and_then(|space_key| decrypt_post(&space_key, &post));+ let content = open_post_content(&mut post, decrypted)?;+ Ok(opened_post(post, content, Ok(None)))+ })+ .collect::<Result<Vec<_>>>()?;+ Ok(PostPage {+ items,+ next_cursor: page.next_cursor,+ })}pub async fn subscribe_web_push(@@ -303,33 +318,11 @@ impl SpaceLinkCtx {Ok(())}- pub fn decrypt_post(&self, post: &PostResponse) -> Result<DecryptedPost> {- let space_key = self.space_key(post.key_version, "post")?;+ pub async fn download_post_asset(&self, asset: &PostAsset) -> Result<Vec<u8>> {+ let space_key = self.space_key(asset.key_version, "post")?;let post_key =- decrypt_secretbox_payload(&space_key, &b64::decode(&post.encrypted_post_key)?)?;- let caption_plaintext = if post.caption_cipher.is_empty() {- None- } else {- Some(decrypt_secretbox_payload(- &post_key,- &b64::decode(&post.caption_cipher)?,- )?)- };- Ok(DecryptedPost {- post_key,- caption_plaintext,- })- }-- pub async fn download_post_asset(- &self,- encrypted_post_key: &str,- key_version: i32,- object_key: &str,- ) -> Result<Vec<u8>> {- let space_key = self.space_key(key_version, "post")?;- let post_key = decrypt_secretbox_payload(&space_key, &b64::decode(encrypted_post_key)?)?;- self.download_asset(vec![("objectKey", object_key.to_owned())], &post_key)+ decrypt_secretbox_payload(&space_key, &b64::decode(&asset.encrypted_post_key)?)?;+ self.download_asset(vec![("objectKey", asset.object_key.clone())], &post_key).await}@@ -377,7 +370,7 @@ impl SpaceLinkCtx {format!("/space/public/by-slug/{}/link", self.space_slug)}- fn has_keys_for_posts(&self, page: &PostPage) -> Result<bool> {+ fn has_keys_for_posts(&self, page: &PostPageResponse) -> Result<bool> {let key_history = cache_lock(&self.key_history, "space link key history")?;Ok(page.items@@ -662,12 +655,48 @@ mod tests {.await.unwrap();- assert_eq!(ctx.profile().profile, profile);+ assert_eq!(+ ctx.profile().profile,+ Some(crate::SpaceProfile::from_bytes(profile).unwrap())+ );assert_eq!(ctx.profile().friends, 2);assert_eq!(ctx.posts(), 3);bootstrap.assert_async().await;profile_request.assert_async().await;versions.assert_async().await;+ let post_key = vec![5; Key::BYTES];+ let valid = serde_json::json!({+ "postId": 1, "spaceId": "space-alice", "spaceSlug": "alice",+ "author": { "spaceSlug": "alice" }, "keyVersion": 1,+ "encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &post_key).unwrap()),+ "captionCipher": b64::encode(&encrypt_secretbox_payload(&post_key, b"hello").unwrap()),+ "objects": [{ "objectKey": "photo", "metadataCipher": b64::encode(&encrypt_secretbox_payload(&post_key, br#"{"width":100,"mediaType":"image/webp"}"#).unwrap()) }],+ "createdAt": "2026-07-26T00:00:00Z", "viewerLiked": false,+ });+ let mut corrupt = valid.clone();+ corrupt["postId"] = 2.into();+ corrupt["encryptedPostKey"] = "not-base64".into();+ let posts = server+ .mock("GET", format!("{prefix}/posts").as_str())+ .match_header("x-space-link-auth", auth.as_str())+ .with_body(+ serde_json::json!({ "items": [valid, corrupt], "nextCursor": "next" }).to_string(),+ )+ .create_async()+ .await;++ let page = ctx.list_posts().await.unwrap();+ let content = page.items[0].content.as_ref().unwrap();+ assert_eq!(content.caption.as_deref(), Some("hello"));+ assert_eq!(content.photos[0].asset.object_key, "photo");+ assert_eq!(+ content.photos[0].metadata.as_ref().unwrap().width,+ Some(100)+ );+ assert!(page.items[0].author.profile.as_ref().unwrap().is_none());+ assert!(matches!(page.items[1].content, Err(Error::Base64Decode(_))));+ assert_eq!(page.next_cursor, "next");+ posts.assert_async().await;}#[tokio::test]@@ -708,7 +737,7 @@ mod tests {space_slug: "alice".to_owned(),version: 1,friends: 0,- profile: Vec::new(),+ profile: None,avatar: None,cover: None,updated_at: None,diff --git a/rust/crates/space/src/client/messages.rs b/rust/crates/space/src/client/messages.rsindex 159d4bdbc9..04bf5ee0c3 100644--- a/rust/crates/space/src/client/messages.rs+++ b/rust/crates/space/src/client/messages.rs@@ -176,7 +176,7 @@ impl AccountSpaceCtx {object_key: Option<&str>,) -> Result<MessageResponse> {let post = self- .get_post(post_space_id, post_id, Some(sender_space_id))+ .get_post_raw(post_space_id, post_id, Some(sender_space_id)).await?;if self.resolve_owned_space_access(&post.space_id)diff --git a/rust/crates/space/src/client/mod.rs b/rust/crates/space/src/client/mod.rsindex c3a25b246b..4c8e6a745e 100644--- a/rust/crates/space/src/client/mod.rs+++ b/rust/crates/space/src/client/mod.rs@@ -666,7 +666,7 @@ fn encrypt_post_object_metadata(post_key: &[u8], metadata: &PostObjectMetadata))?))}-pub fn decrypt_post_object_metadata(+fn decrypt_post_object_metadata(post_key: &[u8],object: &PostObjectPayload,) -> Result<Option<PostObjectMetadata>> {@@ -779,7 +779,11 @@ pub(super) fn decrypt_space_profile(space_slug: profile.space_slug.clone(),version: profile.version,friends: profile.friends,- profile: profile_bytes,+ profile: if profile_bytes.is_empty() {+ None+ } else {+ Some(crate::SpaceProfile::from_bytes(&profile_bytes)?)+ },avatar: profile.avatar.clone(),cover: profile.cover.clone(),updated_at: if profile.updated_at.is_empty() {@@ -798,7 +802,7 @@ pub(super) fn space_profile_without_payload(space_slug: profile.space_slug.clone(),version: profile.version,friends: profile.friends,- profile: Vec::new(),+ profile: None,avatar: profile.avatar.clone(),cover: profile.cover.clone(),updated_at: if profile.updated_at.is_empty() {diff --git a/rust/crates/space/src/client/posts.rs b/rust/crates/space/src/client/posts.rsindex f26278dd5a..d8974f7ff9 100644--- a/rust/crates/space/src/client/posts.rs+++ b/rust/crates/space/src/client/posts.rs@@ -1,9 +1,11 @@use super::{AccountSpaceCtx, decrypt_post_object_metadata, ensure_post_objects_are_photos};use crate::crypto::{decrypt_secretbox_payload, encrypt_secretbox_payload, generate_key};use crate::error::{Error, Result};-use crate::models::{DecryptedPost, HydratedKeys, PostObjectMetadata};+use crate::models::{+ HydratedKeys, Post, PostAsset, PostContent, PostPage, PostPhoto, SpaceActor, SpaceProfile,+};use crate::transport::{- CreatePostRequest, CreatePostResponse, LikePostResponse, PostObjectPayload, PostPage,+ CreatePostRequest, CreatePostResponse, LikePostResponse, PostObjectPayload, PostPageResponse,PostResponse, SpaceActorResponse, SpaceUnreadStatusResponse, UpdatePostCaptionRequest,};use ente_core::{b64, http};@@ -80,7 +82,7 @@ impl AccountSpaceCtx {query.push(("limit", value.to_string()));}let path = format!("/spaces/{space_id}/posts");- Ok(self+ let page = self.api().get(&path).query(&query)@@ -88,7 +90,8 @@ impl AccountSpaceCtx {.await?.error_for_status()?.json()- .await?)+ .await?;+ self.open_post_page(page).await}pub async fn list_feed(@@ -120,7 +123,7 @@ impl AccountSpaceCtx {fetch_feed,self.list_decrypted_friend_shares_cached(space_id))?;- Ok(page)+ self.open_post_page(page).await}pub async fn unread_status(&self, space_id: &str) -> Result<SpaceUnreadStatusResponse> {@@ -165,6 +168,50 @@ impl AccountSpaceCtx {space_id: &str,post_id: i64,viewer_space_id: Option<&str>,+ ) -> Result<Post> {+ let post = self+ .get_post_raw(space_id, post_id, viewer_space_id)+ .await?;+ let post = self.open_post(post, viewer_space_id).await?;+ Ok(Post {+ content: Ok(post.content?),+ ..post+ })+ }++ async fn open_post_page(&self, page: PostPageResponse) -> Result<PostPage> {+ let mut items = Vec::with_capacity(page.items.len());+ for post in page.items {+ items.push(self.open_post(post, None).await?);+ }+ Ok(PostPage {+ items,+ next_cursor: page.next_cursor,+ })+ }++ async fn open_post(+ &self,+ mut post: PostResponse,+ viewer_space_id: Option<&str>,+ ) -> Result<Post> {+ let decrypted = self+ .decrypt_post_for_viewer(&post.space_id, viewer_space_id, &post)+ .await;+ let content = open_post_content(&mut post, decrypted)?;+ let profile = if content.is_ok() {+ retain_content_error(self.decrypt_actor_profile(&post.author).await)?+ } else {+ Ok(None)+ };+ Ok(opened_post(post, content, profile))+ }++ pub(super) async fn get_post_raw(+ &self,+ space_id: &str,+ post_id: i64,+ viewer_space_id: Option<&str>,) -> Result<PostResponse> {let path = format!("/spaces/{space_id}/posts/{post_id}");let mut query = Vec::new();@@ -182,52 +229,28 @@ impl AccountSpaceCtx {.await?)}- pub async fn fetch_post_decrypted(- &self,- space_id: &str,- post_id: i64,- viewer_space_id: Option<&str>,- ) -> Result<DecryptedPost> {- let post = self.get_post(space_id, post_id, viewer_space_id).await?;- self.decrypt_post_for_viewer(&post.space_id, viewer_space_id, &post)- .await- }-pub async fn download_post_asset(&self,- space_id: &str,- post_id: i64,+ asset: &PostAsset,viewer_space_id: Option<&str>,- object_key: &str,) -> Result<Vec<u8>> {- let post = self.get_post(space_id, post_id, viewer_space_id).await?;- let decrypted = self- .decrypt_post_for_viewer(&post.space_id, viewer_space_id, &post)+ let post_key = self+ .decrypt_post_key_fields(+ &asset.space_id,+ viewer_space_id,+ &asset.encrypted_post_key,+ asset.key_version,+ ).await?;self.download_decrypted_asset(- &post.space_id,+ &asset.space_id,viewer_space_id,- object_key,- &decrypted.post_key,+ &asset.object_key,+ &post_key,).await}- pub async fn download_post_asset_with_key(- &self,- space_id: &str,- encrypted_post_key: &str,- key_version: i32,- viewer_space_id: Option<&str>,- object_key: &str,- ) -> Result<Vec<u8>> {- let post_key = self- .decrypt_post_key_fields(space_id, viewer_space_id, encrypted_post_key, key_version)- .await?;- self.download_decrypted_asset(space_id, viewer_space_id, object_key, &post_key)- .await- }-pub async fn hydrate_space_keys(&self) -> Result<HydratedKeys> {let space_root_key = self.get_space_root_key()?;let owned_records = self.list_owned_spaces().await?;@@ -251,12 +274,7 @@ impl AccountSpaceCtx {Ok(HydratedKeys { owned, friends })}- pub fn decrypt_post_key(&self, space_key: &[u8], post: &PostResponse) -> Result<Vec<u8>> {- let packed = b64::decode(&post.encrypted_post_key)?;- decrypt_secretbox_payload(space_key, &packed)- }-- pub async fn decrypt_post_key_fields(+ async fn decrypt_post_key_fields(&self,space_id: &str,viewer_space_id: Option<&str>,@@ -271,37 +289,7 @@ impl AccountSpaceCtx {decrypt_secretbox_payload(&space_key, &packed)}- pub fn decrypt_post(&self, space_key: &[u8], post: &PostResponse) -> Result<DecryptedPost> {- let post_key = self.decrypt_post_key(space_key, post)?;- let caption_plaintext = if post.caption_cipher.is_empty() {- None- } else {- let packed = b64::decode(&post.caption_cipher)?;- Some(decrypt_secretbox_payload(&post_key, &packed)?)- };- Ok(DecryptedPost {- post_key,- caption_plaintext,- })- }-- pub fn decrypt_post_object_metadata(- &self,- post_key: &[u8],- object: &PostObjectPayload,- ) -> Result<Option<PostObjectMetadata>> {- decrypt_post_object_metadata(post_key, object)- }-- pub async fn decrypt_post_for_space(- &self,- space_id: &str,- post: &PostResponse,- ) -> Result<DecryptedPost> {- self.decrypt_post_for_viewer(space_id, None, post).await- }-- pub async fn decrypt_post_for_viewer(+ async fn decrypt_post_for_viewer(&self,space_id: &str,viewer_space_id: Option<&str>,@@ -317,13 +305,13 @@ impl AccountSpaceCtx {.ok_or_else(|| {Error::InvalidInput(format!("no space key available for post {}", post.post_id))})?;- self.decrypt_post(&space_key, post)+ decrypt_post(&space_key, post)}pub async fn decrypt_actor_profile(&self,actor: &SpaceActorResponse,- ) -> Result<Option<Vec<u8>>> {+ ) -> Result<Option<SpaceProfile>> {if actor.encrypted_profile.trim().is_empty()|| actor.space_id.trim().is_empty()|| actor.key_version <= 0@@ -336,22 +324,28 @@ impl AccountSpaceCtx {else {return Ok(None);};- Ok(Some(decrypt_secretbox_payload(+ Ok(Some(SpaceProfile::from_bytes(&decrypt_secretbox_payload(&space_key,&b64::decode(&actor.encrypted_profile)?,- )?))+ )?)?))}pub async fn update_post_caption(&self,space_id: &str,post_id: i64,- post_key: &[u8],caption_plaintext: Option<&[u8]>,) -> Result<()> {+ let post = self.get_post_raw(space_id, post_id, Some(space_id)).await?;+ let decrypted = self+ .decrypt_post_for_viewer(&post.space_id, Some(space_id), &post)+ .await?;let request = UpdatePostCaptionRequest {caption_cipher: match caption_plaintext {- Some(value) => Some(b64::encode(&encrypt_secretbox_payload(post_key, value)?)),+ Some(value) => Some(b64::encode(&encrypt_secretbox_payload(+ &decrypted.post_key,+ value,+ )?)),None => None,},};@@ -400,3 +394,289 @@ impl AccountSpaceCtx {}}}++pub(super) struct DecryptedPost {+ post_key: Vec<u8>,+ caption_plaintext: Option<Vec<u8>>,+}++pub(super) fn decrypt_post(space_key: &[u8], post: &PostResponse) -> Result<DecryptedPost> {+ let post_key = decrypt_secretbox_payload(space_key, &b64::decode(&post.encrypted_post_key)?)?;+ let caption_plaintext = if post.caption_cipher.is_empty() {+ None+ } else {+ Some(decrypt_secretbox_payload(+ &post_key,+ &b64::decode(&post.caption_cipher)?,+ )?)+ };+ Ok(DecryptedPost {+ post_key,+ caption_plaintext,+ })+}++fn utf8_field(bytes: Vec<u8>, field: &str) -> Result<String> {+ String::from_utf8(bytes)+ .map_err(|error| Error::InvalidInput(format!("invalid {field} utf8: {error}")))+}++fn retain_content_error<T>(result: Result<T>) -> Result<Result<T>> {+ match result {+ Err(error) if !error.is_content_error() => Err(error),+ result => Ok(result),+ }+}++pub(super) fn open_post_content(+ post: &mut PostResponse,+ decrypted: Result<DecryptedPost>,+) -> Result<Result<PostContent>> {+ retain_content_error(decrypted.and_then(|decrypted| {+ let caption = decrypted+ .caption_plaintext+ .map(|bytes| utf8_field(bytes, "caption"))+ .transpose()?;+ let photos = std::mem::take(&mut post.objects)+ .into_iter()+ .filter(|object| !object.object_key.trim().is_empty())+ .map(|object| {+ let metadata = decrypt_post_object_metadata(&decrypted.post_key, &object)?;+ Ok(PostPhoto {+ asset: PostAsset {+ space_id: post.space_id.clone(),+ post_id: post.post_id,+ object_key: object.object_key,+ encrypted_post_key: post.encrypted_post_key.clone(),+ key_version: post.key_version,+ size: object.size,+ },+ position: object.position,+ metadata,+ })+ })+ .collect::<Result<Vec<_>>>()?;+ if photos.is_empty() {+ return Err(Error::InvalidInput("post has no photos".into()));+ }+ Ok(PostContent { caption, photos })+ }))+}++pub(super) fn opened_post(+ post: PostResponse,+ content: Result<PostContent>,+ profile: Result<Option<SpaceProfile>>,+) -> Post {+ Post {+ post_id: post.post_id,+ space_id: post.space_id,+ space_slug: post.space_slug,+ author: SpaceActor {+ space_id: post.author.space_id,+ space_slug: post.author.space_slug,+ public_key: post.author.public_key,+ key_version: post.author.key_version,+ profile,+ avatar: post.author.avatar,+ },+ content,+ created_at: post.created_at,+ viewer_liked: post.viewer_liked,+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use ente_core::crypto::{Key, secretbox};++ fn post(post_id: i64, encrypted_post_key: String) -> PostResponse {+ PostResponse {+ post_id,+ space_id: "space-1".into(),+ space_slug: "alice".into(),+ author: crate::SpaceActorResponse {+ space_id: "space-1".into(),+ space_slug: "alice".into(),+ ..Default::default()+ },+ encrypted_post_key,+ caption_cipher: String::new(),+ key_version: 1,+ objects: vec![PostObjectPayload {+ object_key: "photo".into(),+ size: None,+ position: None,+ metadata_cipher: None,+ }],+ created_at: format!("2026-08-0{post_id}T00:00:00Z"),+ viewer_liked: false,+ }+ }++ #[tokio::test]+ async fn corrupt_posts_reject_single_reads_but_not_pages() {+ let mut server = mockito::Server::new_async().await;+ let root_key = Key::generate();+ let space_key = Key::generate();+ let wrapped_space_key = secretbox::encrypt_combined(space_key.as_bytes(), &root_key);+ let post_key = Key::generate();+ let valid_post_key = secretbox::encrypt_combined(post_key.as_bytes(), &space_key);+ let ctx = AccountSpaceCtx::open(crate::OpenAccountSpaceCtxInput {+ base_url: server.url(),+ space_session_token: None,+ space_root_key: root_key.as_bytes().to_vec(),+ initial_owned_spaces: Some(vec![crate::SpaceKeyResponse {+ space_id: "space-1".into(),+ space_slug: "alice".into(),+ root_wrapped_space_key: b64::encode(&wrapped_space_key),+ public_key: String::new(),+ encrypted_secret_key: String::new(),+ encrypted_profile: String::new(),+ key_version: 1,+ }]),+ user_agent: None,+ client_package: None,+ client_version: None,+ })+ .unwrap();+ let mut post_with_corrupt_actor_profile = post(1, b64::encode(&valid_post_key));+ post_with_corrupt_actor_profile.author.key_version = 1;+ post_with_corrupt_actor_profile.author.encrypted_profile = "not-base64".into();+ let mut valid_post = post(3, b64::encode(&valid_post_key));+ valid_post.author.key_version = 1;+ valid_post.author.encrypted_profile = b64::encode(&secretbox::encrypt_combined(+ br#"{"fullName":"Alice"}"#,+ &space_key,+ ));+ let mut invalid_caption = post(4, b64::encode(&valid_post_key));+ invalid_caption.caption_cipher =+ b64::encode(&secretbox::encrypt_combined(&[0xff], &post_key));+ let mut invalid_metadata = post(5, b64::encode(&valid_post_key));+ invalid_metadata.objects.push(PostObjectPayload {+ object_key: "photo".into(),+ size: None,+ position: None,+ metadata_cipher: Some("not-base64".into()),+ });+ let mut corrupt_post = post(2, "not-base64".into());+ let mut corrupt_caption = post(6, b64::encode(&valid_post_key));+ corrupt_caption.caption_cipher =+ b64::encode(&secretbox::encrypt_combined(b"caption", &space_key));+ let mut empty_post = post(7, b64::encode(&valid_post_key));+ empty_post.objects.clear();+ let mut blank_photo = post(8, b64::encode(&valid_post_key));+ blank_photo.objects[0].object_key = " ".into();+ for post in [+ &mut empty_post,+ &mut blank_photo,+ &mut corrupt_post,+ &mut invalid_caption,+ &mut invalid_metadata,+ &mut corrupt_caption,+ ] {+ post.author.key_version = 2;+ post.author.encrypted_profile = "not-base64".into();+ }+ let profile_keys = server+ .mock("GET", "/account/space")+ .with_status(503)+ .expect(0)+ .create_async()+ .await;+ let page = PostPageResponse {+ items: vec![+ post_with_corrupt_actor_profile,+ corrupt_post,+ valid_post,+ invalid_caption,+ invalid_metadata,+ corrupt_caption,+ empty_post,+ blank_photo,+ ],+ next_cursor: "next".into(),+ };++ for index in [1, 3, 4, 5, 6, 7] {+ let post = &page.items[index];+ let read = server+ .mock(+ "GET",+ format!("/spaces/space-1/posts/{}", post.post_id).as_str(),+ )+ .with_body(serde_json::to_string(post).unwrap())+ .create_async()+ .await;+ assert!(matches!(+ ctx.get_post("space-1", post.post_id, None).await,+ Err(error) if error.is_content_error()+ ));+ read.assert_async().await;+ }++ let page = ctx.open_post_page(page).await.unwrap();++ assert_eq!(page.items.len(), 8);+ assert!(page.items[0].content.is_ok());+ assert!(matches!(+ page.items[0].author.profile,+ Err(Error::Base64Decode(_))+ ));+ assert!(matches!(page.items[1].content, Err(Error::Base64Decode(_))));+ assert_eq!(page.items[1].post_id, 2);+ assert!(page.items[2].content.is_ok());+ assert_eq!(+ page.items[2]+ .author+ .profile+ .as_ref()+ .unwrap()+ .as_ref()+ .unwrap()+ .full_name+ .as_deref(),+ Some("Alice")+ );+ assert!(+ matches!(&page.items[3].content, Err(Error::InvalidInput(message)) if message.contains("caption utf8"))+ );+ assert!(matches!(page.items[4].content, Err(Error::Base64Decode(_))));+ assert!(matches!(page.items[5].content, Err(Error::Crypto(_))));+ assert!(matches!(page.items[6].content, Err(Error::InvalidInput(_))));+ assert!(matches!(page.items[7].content, Err(Error::InvalidInput(_))));+ for index in [1, 3, 4, 5, 6, 7] {+ assert!(matches!(page.items[index].author.profile, Ok(None)));+ }+ assert_eq!(page.next_cursor, "next");+ profile_keys.assert_async().await;+ }++ #[tokio::test]+ async fn key_fetch_failure_rejects_the_page() {+ let mut server = mockito::Server::new_async().await;+ let ctx = crate::client::test_support::test_account_ctx(&server.url());+ let page = PostPageResponse {+ items: vec![post(1, "not-base64".into())],+ next_cursor: String::new(),+ };+ let posts = server+ .mock("GET", "/spaces/space-1/posts")+ .with_body(serde_json::to_string(&page).unwrap())+ .create_async()+ .await;+ let keys = server+ .mock("GET", "/account/space")+ .with_status(403)+ .create_async()+ .await;++ assert!(matches!(+ ctx.list_posts("space-1", None, None, None).await,+ Err(Error::Http(http::Error::Http { status: 403, .. }))+ ));+ posts.assert_async().await;+ keys.assert_async().await;+ }+}diff --git a/rust/crates/space/src/client/tests.rs b/rust/crates/space/src/client/tests.rsindex d68066ef9e..ba227f36ee 100644--- a/rust/crates/space/src/client/tests.rs+++ b/rust/crates/space/src/client/tests.rs@@ -121,7 +121,8 @@ async fn account_space_key_resolution_is_cached_within_context() {let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());let friend_space_key = generate_key();let encrypted_profile = b64::encode(- &encrypt_secretbox_payload(&friend_space_key, b"friend-profile").expect("profile wrap"),+ &encrypt_secretbox_payload(&friend_space_key, br#"{"fullName":"Friend"}"#)+ .expect("profile wrap"),);let sealed_share =seal_with_public_key(&friend_space_key, &test_public_key(&ctx)).expect("friend share seal");@@ -184,8 +185,8 @@ async fn account_space_key_resolution_is_cached_within_context() {.await.expect("second profile decrypt");- assert_eq!(first.as_deref(), Some(b"friend-profile".as_slice()));- assert_eq!(second.as_deref(), Some(b"friend-profile".as_slice()));+ assert_eq!(first.unwrap().full_name.as_deref(), Some("Friend"));+ assert_eq!(second.unwrap().full_name.as_deref(), Some("Friend"));spaces.assert_async().await;shares.assert_async().await;}@@ -290,8 +291,7 @@ async fn upload_post_photo_asset_attaches_photo_metadata() {assert_eq!(payload.object_key, "photo-object");assert_eq!(payload.position, Some(0));- let metadata = ctx- .decrypt_post_object_metadata(&post_key, &payload)+ let metadata = decrypt_post_object_metadata(&post_key, &payload).expect("metadata should decrypt").expect("metadata should exist");assert_eq!(metadata.width, Some(4032));@@ -1118,8 +1118,9 @@ async fn get_space_profile_decrypted_loads_and_decrypts_profile() {let space_root_key = generate_key();let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());let space_key = generate_key();- let encrypted_profile =- b64::encode(&encrypt_secretbox_payload(&space_key, b"profile-json").expect("profile wrap"));+ let encrypted_profile = b64::encode(+ &encrypt_secretbox_payload(&space_key, br#"{"fullName":"Owner"}"#).expect("profile wrap"),+ );let profile = server.mock("GET", "/spaces/space_owner_main/profile").match_header("x-space-session-token", "space-session-token")@@ -1160,7 +1161,10 @@ async fn get_space_profile_decrypted_loads_and_decrypts_profile() {assert_eq!(decrypted.space_slug, "owner-main");assert_eq!(decrypted.version, 3);assert_eq!(decrypted.friends, 2);- assert_eq!(decrypted.profile, b"profile-json");+ assert_eq!(+ decrypted.profile.unwrap().full_name.as_deref(),+ Some("Owner")+ );profile.assert_async().await;spaces.assert_async().await;}@@ -1264,7 +1268,7 @@ async fn get_space_profile_for_display_keeps_envelope_on_decryption_error() {assert_eq!(decrypted.space_slug, "owner-main");assert_eq!(decrypted.version, 3);assert_eq!(decrypted.friends, 2);- assert!(decrypted.profile.is_empty());+ assert!(decrypted.profile.is_none());profile.assert_async().await;spaces.assert_async().await;}@@ -1317,7 +1321,42 @@ async fn space_status_mutations_accept_empty_server_responses() {#[tokio::test]async fn update_post_caption_uses_caption_endpoint() {let mut server = Server::new_async().await;- let ctx = test_account_ctx(&server.url());+ let root_key = generate_key();+ let space_key = generate_key();+ let post_key = generate_key();+ let ctx = test_account_ctx_with_space_root_key(&server.url(), root_key.clone());+ let spaces = server+ .mock("GET", "/account/space")+ .with_body(owned_space_response(+ &root_key,+ &space_key,+ "space_owner_main",+ "owner",+ 1,+ ))+ .create_async()+ .await;+ let mut post = json!({+ "postId": 42,+ "spaceId": "space_owner_main",+ "spaceSlug": "owner",+ "author": { "spaceSlug": "owner" },+ "encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &post_key).unwrap()),+ "captionCipher": b64::encode(&encrypt_secretbox_payload(&post_key, b"old caption").unwrap()),+ "keyVersion": 1,+ "objects": [],+ "createdAt": "2026-04-16T00:00:00Z",+ "viewerLiked": false,+ });+ let read = server+ .mock("GET", "/spaces/space_owner_main/posts/42")+ .match_query(Matcher::UrlEncoded(+ "viewerSpaceId".into(),+ "space_owner_main".into(),+ ))+ .with_body(post.to_string())+ .create_async()+ .await;let update = server.mock("POST", "/spaces/space_owner_main/posts/42/caption").match_header("x-space-session-token", "space-session-token")@@ -1328,15 +1367,26 @@ async fn update_post_caption_uses_caption_endpoint() {.create_async().await;- ctx.update_post_caption(- "space_owner_main",- 42,- &generate_key(),- Some(b"updated caption".as_slice()),- )- .await- .expect("caption update should succeed");+ ctx.update_post_caption("space_owner_main", 42, Some(b"updated caption".as_slice()))+ .await+ .expect("caption update should succeed");+ spaces.assert_async().await;+ read.assert_async().await;+ read.remove_async().await;+ post["captionCipher"] = "not-base64".into();+ let corrupt = server+ .mock("GET", "/spaces/space_owner_main/posts/42")+ .match_query(Matcher::Any)+ .with_body(post.to_string())+ .create_async()+ .await;+ assert!(matches!(+ ctx.update_post_caption("space_owner_main", 42, Some(b"updated caption"))+ .await,+ Err(Error::Base64Decode(_))+ ));+ corrupt.assert_async().await;update.assert_async().await;}@@ -1831,7 +1881,21 @@ async fn refresh_friend_shares_accepts_empty_server_response() {#[tokio::test]async fn list_feed_uses_feed_endpoint() {let mut server = Server::new_async().await;- let ctx = test_account_ctx(&server.url());+ let root_key = generate_key();+ let space_key = generate_key();+ let ctx = test_account_ctx_with_space_root_key(&server.url(), root_key.clone());+ let spaces = server+ .mock("GET", "/account/space")+ .with_status(200)+ .with_body(owned_space_response(+ &root_key,+ &space_key,+ "space_friend_gallery",+ "gallery",+ 3,+ ))+ .create_async()+ .await;let shares = server.mock("GET", "/spaces/space_owner_main/friends/shares").match_header("x-space-session-token", "space-session-token")@@ -1857,10 +1921,10 @@ async fn list_feed_uses_feed_endpoint() {"spaceId": "space_owner_gallery","spaceSlug": "owner-gallery"},- "encryptedPostKey": "cGFja2Vk",+ "encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &generate_key()).unwrap()),"captionCipher": "","keyVersion": 3,- "objects": [],+ "objects": [{"objectKey": "photo"}],"createdAt": "2026-04-16T00:00:00Z","viewerLiked": true}],@@ -1877,6 +1941,8 @@ async fn list_feed_uses_feed_endpoint() {.expect("feed should load");assert_eq!(page.items.len(), 1);+ assert!(page.items[0].content.is_ok());+ spaces.assert_async().await;assert_eq!(page.items[0].post_id, 42);assert_eq!(page.next_cursor, "cursor-2");shares.assert_async().await;@@ -1886,7 +1952,21 @@ async fn list_feed_uses_feed_endpoint() {#[tokio::test]async fn list_posts_uses_space_posts_page_endpoint() {let mut server = Server::new_async().await;- let ctx = test_account_ctx(&server.url());+ let root_key = generate_key();+ let space_key = generate_key();+ let ctx = test_account_ctx_with_space_root_key(&server.url(), root_key.clone());+ let spaces = server+ .mock("GET", "/account/space")+ .with_status(200)+ .with_body(owned_space_response(+ &root_key,+ &space_key,+ "space_owner_main",+ "gallery",+ 3,+ ))+ .create_async()+ .await;let posts = server.mock("GET", "/spaces/space_owner_gallery/posts").match_header("x-space-session-token", "space-session-token")@@ -1906,10 +1986,10 @@ async fn list_posts_uses_space_posts_page_endpoint() {"spaceId": "space_owner_gallery","spaceSlug": "owner-gallery"},- "encryptedPostKey": "cGFja2Vk",+ "encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &generate_key()).unwrap()),"captionCipher": "","keyVersion": 3,- "objects": [],+ "objects": [{"objectKey": "photo"}],"createdAt": "2026-04-16T00:00:00Z","viewerLiked": true}],@@ -1931,13 +2011,15 @@ async fn list_posts_uses_space_posts_page_endpoint() {.expect("post page should load");assert_eq!(page.items.len(), 1);+ assert!(page.items[0].content.is_ok());+ spaces.assert_async().await;assert_eq!(page.items[0].post_id, 41);assert_eq!(page.next_cursor, "41");posts.assert_async().await;}#[tokio::test]-async fn fetch_post_decrypted_uses_post_by_id_endpoint() {+async fn get_post_returns_decrypted_content() {let mut server = Server::new_async().await;let space_root_key = generate_key();let ctx = test_account_ctx_with_space_root_key(&server.url(), space_root_key.clone());@@ -1977,7 +2059,7 @@ async fn fetch_post_decrypted_uses_post_by_id_endpoint() {"encryptedPostKey": b64::encode(&encrypt_secretbox_payload(&space_key, &post_key).expect("post key wrap")),"captionCipher": b64::encode(&encrypt_secretbox_payload(&post_key, caption).expect("caption wrap")),"keyVersion": 3,- "objects": [],+ "objects": [{"objectKey": "photo"}],"createdAt": "2026-04-16T00:00:00Z","viewerLiked": false})@@ -1987,14 +2069,14 @@ async fn fetch_post_decrypted_uses_post_by_id_endpoint() {.await;let decrypted = ctx- .fetch_post_decrypted("space_owner_gallery", 42, None)+ .get_post("space_owner_gallery", 42, None).await.expect("post should decrypt");- assert_eq!(decrypted.post_key, post_key);+ assert_eq!(decrypted.post_id, 42);assert_eq!(- decrypted.caption_plaintext.as_deref(),- Some(caption.as_slice())+ decrypted.content.unwrap().caption.as_deref(),+ Some("hello from post"));spaces.assert_async().await;post.assert_async().await;diff --git a/rust/crates/space/src/lib.rs b/rust/crates/space/src/lib.rsindex c6b5c61693..d90a72f5e6 100644--- a/rust/crates/space/src/lib.rs+++ b/rust/crates/space/src/lib.rs@@ -13,16 +13,16 @@ pub use client::{};pub use error::{Error, Result};pub use models::{- CreatedSpace, CreatedSpaceLink, DecryptedFriendShare, DecryptedMessage, DecryptedPost,- DecryptedSpaceProfile, HydratedKeys, MessagePayload, OpenAccountSpaceCtxInput,- OpenSpaceLinkCtxInput, PostObjectMetadata,+ CreatedSpace, CreatedSpaceLink, DecryptedFriendShare, DecryptedMessage, DecryptedSpaceProfile,+ HydratedKeys, MessagePayload, OpenAccountSpaceCtxInput, OpenSpaceLinkCtxInput, Post, PostAsset,+ PostContent, PostObjectMetadata, PostPage, PostPhoto, SpaceActor, SpaceProfile,};pub use transport::{ConversationChatSummaryResponse, ConversationsResponse, EntityKeyPayload,FriendRelationshipResponse, FriendShareResponse, FriendStatusResponse, LikeMessageResponse,LikePostResponse, MessageConversationActivity, MessagePage, MessageResponse, PostObjectPayload,- PostPage, PostResponse, PresignUploadResponse, ProfileAvatarPayload, ProfileAvatarResponse,- ProfileCoverPayload, ProfileCoverResponse, SpaceActorResponse, SpaceFriendRequestResponse,- SpaceFriendResponse, SpaceKeyResponse, SpaceKeyVersionResponse, SpaceLookupResponse,- SpaceProfileResponse, SpaceSentFriendRequestResponse, SpaceUnreadStatusResponse,+ PresignUploadResponse, ProfileAvatarPayload, ProfileAvatarResponse, ProfileCoverPayload,+ ProfileCoverResponse, SpaceActorResponse, SpaceFriendRequestResponse, SpaceFriendResponse,+ SpaceKeyResponse, SpaceKeyVersionResponse, SpaceLookupResponse, SpaceProfileResponse,+ SpaceSentFriendRequestResponse, SpaceUnreadStatusResponse,};diff --git a/rust/crates/space/src/models.rs b/rust/crates/space/src/models.rsindex 6bf2c34653..19bbe5e15d 100644--- a/rust/crates/space/src/models.rs+++ b/rust/crates/space/src/models.rs@@ -1,6 +1,7 @@use serde::{Deserialize, Serialize};use zeroize::ZeroizeOnDrop;+use crate::Result;use crate::transport::{ProfileAvatarResponse, ProfileCoverResponse, SpaceKeyResponse};#[derive(Clone)]@@ -47,16 +48,86 @@ pub struct DecryptedSpaceProfile {pub space_slug: String,pub version: i32,pub friends: i64,- pub profile: Vec<u8>,+ pub profile: Option<SpaceProfile>,pub avatar: Option<ProfileAvatarResponse>,pub cover: Option<ProfileCoverResponse>,pub updated_at: Option<String>,}-#[derive(Clone)]-pub struct DecryptedPost {- pub post_key: Vec<u8>,- pub caption_plaintext: Option<Vec<u8>>,+pub struct Post {+ pub post_id: i64,+ pub space_id: String,+ pub space_slug: String,+ pub author: SpaceActor,+ pub content: Result<PostContent>,+ pub created_at: String,+ pub viewer_liked: bool,+}++pub struct SpaceActor {+ pub space_id: String,+ pub space_slug: String,+ pub public_key: String,+ pub key_version: i32,+ pub profile: Result<Option<SpaceProfile>>,+ pub avatar: Option<ProfileAvatarResponse>,+}++pub struct PostContent {+ pub caption: Option<String>,+ pub photos: Vec<PostPhoto>,+}++pub struct PostPhoto {+ pub asset: PostAsset,+ pub position: Option<i32>,+ pub metadata: Option<PostObjectMetadata>,+}++pub struct PostAsset {+ pub space_id: String,+ pub post_id: i64,+ pub object_key: String,+ pub encrypted_post_key: String,+ pub key_version: i32,+ pub size: Option<i64>,+}++#[derive(Debug, Clone, Default, PartialEq, Eq)]+pub struct SpaceProfile {+ pub full_name: Option<String>,+ pub display_name: Option<String>,+}++impl SpaceProfile {+ pub fn from_bytes(bytes: &[u8]) -> Result<Self> {+ if bytes.iter().all(u8::is_ascii_whitespace) {+ return Ok(Self::default());+ }+ let value: serde_json::Value = serde_json::from_slice(bytes).map_err(|error| {+ crate::Error::InvalidInput(format!("invalid profile JSON: {error}"))+ })?;+ let fields = value+ .as_object()+ .ok_or_else(|| crate::Error::InvalidInput("profile must be a JSON object".into()))?;+ let text = |key| {+ fields+ .get(key)+ .and_then(serde_json::Value::as_str)+ .map(str::trim)+ .filter(|value| !value.is_empty())+ .map(str::to_owned)+ };+ Ok(Self {+ full_name: text("fullName"),+ display_name: text("displayName"),+ })+ }+}++pub struct PostPage {+ pub items: Vec<Post>,+ pub next_cursor: String,}#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]@@ -106,3 +177,35 @@ pub struct HydratedKeys {pub owned: Vec<(String, Vec<u8>)>,pub friends: Vec<DecryptedFriendShare>,}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn profile_names_are_optional_trimmed_strings() {+ let profile = SpaceProfile::from_bytes(+ br#"{"fullName":" Alice ","displayName":" A ","bio":"hello"}"#,+ )+ .unwrap();+ assert_eq!(profile.full_name.as_deref(), Some("Alice"));+ assert_eq!(profile.display_name.as_deref(), Some("A"));+ for bytes in [b" ".as_slice(), br#"{"fullName":42,"displayName":" "}"#] {+ assert_eq!(+ SpaceProfile::from_bytes(bytes).unwrap(),+ SpaceProfile::default()+ );+ }+ }++ #[test]+ fn invalid_profile_payload_is_a_content_error() {+ for bytes in [b"{".as_slice(), b"null", b"[]", &[0xff]] {+ assert!(+ SpaceProfile::from_bytes(bytes)+ .unwrap_err()+ .is_content_error()+ );+ }+ }+}diff --git a/rust/crates/space/src/transport.rs b/rust/crates/space/src/transport.rsindex f23cee8c62..995d8b1311 100644--- a/rust/crates/space/src/transport.rs+++ b/rust/crates/space/src/transport.rs@@ -254,7 +254,7 @@ pub struct PostResponse {#[derive(Debug, Clone, Serialize, Deserialize)]#[serde(rename_all = "camelCase")]-pub struct PostPage {+pub struct PostPageResponse {pub items: Vec<PostResponse>,#[serde(default)]pub next_cursor: String,diff --git a/rust/crates/space/tests/space.rs b/rust/crates/space/tests/space.rsindex d5e0c5ae4f..2e6886e2fb 100644--- a/rust/crates/space/tests/space.rs+++ b/rust/crates/space/tests/space.rs@@ -94,7 +94,10 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {.get_space_profile_decrypted(&owner_space.space_id, None, None).await.expect("owner should decrypt profile");- assert_eq!(decrypted_profile.profile, owner_profile);+ assert_eq!(+ decrypted_profile.profile,+ Some(ente_space::SpaceProfile::from_bytes(&owner_profile).unwrap())+ );assert_eq!(decrypted_profile.space_slug, owner_slug);space::assert_http_status(@@ -146,12 +149,13 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {.await.expect("post creation should succeed");let owner_post = owner_ctx- .fetch_post_decrypted(&owner_space.space_id, post_id, None)+ .get_post(&owner_space.space_id, post_id, None).await.expect("owner should decrypt post");+ let owner_content = owner_post.content.as_ref().expect("owner post content");assert_eq!(- owner_post.caption_plaintext.as_deref(),- Some(br#"{"caption":"hello world"}"#.as_slice())+ owner_content.caption.as_deref(),+ Some(r#"{"caption":"hello world"}"#));let owner_feed = owner_ctx.list_feed(&owner_space.space_id, None, Some(10))@@ -159,14 +163,11 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {.expect("owner feed should load");assert_eq!(owner_feed.items.len(), 1);assert_eq!(owner_feed.items[0].post_id, post_id);- let own_feed_post = owner_ctx- .decrypt_post_for_space(&owner_space.space_id, &owner_feed.items[0])- .await+ let own_feed_post = owner_feed.items[0]+ .content+ .as_ref().expect("own feed post should decrypt");- assert_eq!(- own_feed_post.caption_plaintext,- owner_post.caption_plaintext- );+ assert_eq!(own_feed_post.caption, owner_content.caption);space::assert_http_status(owner_ctx@@ -214,14 +215,20 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {.get_space_profile_decrypted(&owner_space.space_id, Some(&friend_space.space_id), None).await.expect("approved friend should decrypt profile");- assert_eq!(friend_profile.profile, updated_profile);+ assert_eq!(+ friend_profile.profile,+ Some(ente_space::SpaceProfile::from_bytes(&updated_profile).unwrap())+ );assert_eq!(friend_profile.space_slug, updated_slug);let owner_view_of_friend = owner_ctx.get_space_profile_decrypted(&friend_space.space_id, Some(&owner_space.space_id), None).await.expect("approved owner should decrypt friend profile");- assert_eq!(owner_view_of_friend.profile, friend_profile_payload);+ assert_eq!(+ owner_view_of_friend.profile,+ Some(ente_space::SpaceProfile::from_bytes(&friend_profile_payload).unwrap())+ );assert_eq!(owner_view_of_friend.space_slug, friend_slug);let friend_feed = friend_ctx@@ -232,22 +239,20 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {assert_eq!(friend_feed.items[0].post_id, post_id);assert_eq!(friend_feed.items[0].author.space_id, owner_space.space_id);assert_eq!(friend_feed.items[0].author.space_slug, updated_slug);- let feed_post_author_profile = friend_ctx- .decrypt_actor_profile(&friend_feed.items[0].author)- .await+ let feed_post_author_profile = friend_feed.items[0]+ .author+ .profile+ .as_ref().expect("friend should decrypt feed post author profile");assert_eq!(- feed_post_author_profile.as_deref(),- Some(updated_profile.as_slice())+ feed_post_author_profile.as_ref(),+ Some(&ente_space::SpaceProfile::from_bytes(&updated_profile).unwrap()));- let friend_feed_post = friend_ctx- .decrypt_post_for_space(&owner_space.space_id, &friend_feed.items[0])- .await+ let friend_feed_post = friend_feed.items[0]+ .content+ .as_ref().expect("friend feed post should decrypt");- assert_eq!(- friend_feed_post.caption_plaintext,- owner_post.caption_plaintext- );+ assert_eq!(friend_feed_post.caption, owner_content.caption);let liked = friend_ctx.like_post(&friend_space.space_id, post_id, true)@@ -276,7 +281,7 @@ async fn space_bootstrap_posts_and_friend_share_suite(endpoint: &str) {space::assert_http_status(outsider_ctx- .fetch_post_decrypted(&owner_space.space_id, post_id, None)+ .get_post(&owner_space.space_id, post_id, None).await,403,);@@ -340,12 +345,18 @@ async fn space_unfriend_revokes_reciprocal_account_access_suite(endpoint: &str).get_space_profile_decrypted(&owner_space.space_id, Some(&friend_space.space_id), None).await.expect("friend should decrypt owner profile before unfriend");- assert_eq!(friend_owner_profile.profile, owner_profile);+ assert_eq!(+ friend_owner_profile.profile,+ Some(ente_space::SpaceProfile::from_bytes(&owner_profile).unwrap())+ );let owner_friend_profile = owner_ctx.get_space_profile_decrypted(&friend_space.space_id, Some(&owner_space.space_id), None).await.expect("owner should decrypt friend profile before unfriend");- assert_eq!(owner_friend_profile.profile, friend_profile);+ assert_eq!(+ owner_friend_profile.profile,+ Some(ente_space::SpaceProfile::from_bytes(&friend_profile).unwrap())+ );let friend_feed = friend_ctx.list_feed(&friend_space.space_id, None, Some(10)).await@@ -503,7 +514,7 @@ async fn space_unfriend_revokes_reciprocal_account_access_suite(endpoint: &str));space::assert_http_status(friend_ctx- .fetch_post_decrypted(&owner_space.space_id, post_id, Some(&friend_space.space_id))+ .get_post(&owner_space.space_id, post_id, Some(&friend_space.space_id)).await,403,);diff --git a/web/apps/space/src/services/media-cache.ts b/web/apps/space/src/services/media-cache.tsindex 258cf555d1..c43d1389f1 100644--- a/web/apps/space/src/services/media-cache.ts+++ b/web/apps/space/src/services/media-cache.ts@@ -2,7 +2,6 @@ import { savedPartialLocalUser } from "ente-accounts/services/accounts-db";import { blobCache, clearBlobCache } from "ente-base/blob-cache";import log from "ente-base/log";import { apiOrigin } from "ente-base/origins";-import { blobPartForBytes } from "services/profile-payload";const maxSpaceMediaCacheEntries = 128;const spaceMediaURLCache = new Map<string, Promise<string>>();@@ -30,7 +29,7 @@ const trimSpaceMediaURLCache = () => {};const blobForBytes = (bytes: Uint8Array, mediaType?: string) =>- new Blob([blobPartForBytes(bytes)], { type: mediaType || undefined });+ new Blob([new Uint8Array(bytes).buffer], { type: mediaType || undefined });const sha256Hex = async (value: string) => {const digest = await crypto.subtle.digest(diff --git a/web/apps/space/src/services/profile-payload.ts b/web/apps/space/src/services/profile-payload.tsdeleted file mode 100644index 730895a712..0000000000--- a/web/apps/space/src/services/profile-payload.ts+++ /dev/null@@ -1,32 +0,0 @@-import log from "ente-base/log";--export interface SpaceProfilePayload {- displayName?: unknown;- fullName?: unknown;- username?: unknown;-}--export const parseSpaceProfilePayload = (- profile: string,-): SpaceProfilePayload => {- const trimmed = profile.trim();- if (!trimmed) return {};- try {- const parsed: unknown = JSON.parse(trimmed);- if (parsed && typeof parsed == "object" && !Array.isArray(parsed)) {- return parsed;- }- } catch (error) {- log.warn("Failed to decode Space profile JSON", error);- }- return {};-};--export const spaceProfileTextField = (value: unknown) =>- typeof value == "string" ? value.trim() : "";--export const blobPartForBytes = (bytes: Uint8Array): ArrayBuffer => {- const copy = new Uint8Array(bytes.byteLength);- copy.set(bytes);- return copy.buffer;-};diff --git a/web/apps/space/src/services/profile.ts b/web/apps/space/src/services/profile.tsindex 6ffa4d8a21..f95c60f913 100644--- a/web/apps/space/src/services/profile.ts+++ b/web/apps/space/src/services/profile.ts@@ -28,10 +28,6 @@ import {saveSpaceOwnedSpaces,saveSpaceProfileAvatar,} from "services/persistent-session";-import {- parseSpaceProfilePayload,- spaceProfileTextField,-} from "services/profile-payload";import { spaceRootKeyFromSpaceSession } from "services/secure-session-storage";const usernamePattern = /^[a-z0-9][a-z0-9._]*$/;@@ -255,11 +251,9 @@ const coverURLForRemoteCover = async (const profileFromDecryptedSpaceProfile = (spaceProfile: DecryptedSpaceProfile,): SetupProfile => {- const payload = parseSpaceProfilePayload(spaceProfile.profile);+ const payload = spaceProfile.profile;const fullName =- spaceProfileTextField(payload.fullName) ||- spaceProfileTextField(payload.displayName) ||- spaceProfile.spaceSlug;+ payload?.fullName || payload?.displayName || spaceProfile.spaceSlug;return {avatarKeyVersion: spaceProfile.avatar?.keyVersion,diff --git a/web/apps/space/src/services/space.ts b/web/apps/space/src/services/space.tsindex dd73e100cd..9f6ed59ca5 100644--- a/web/apps/space/src/services/space.ts+++ b/web/apps/space/src/services/space.ts@@ -8,8 +8,9 @@ import {type DecryptedSpaceProfile,type MessageConversationActivity,type MessageResponse,- type PostObjectPayload,+ type PostAsset,type PostPage,+ type PostPhoto,type PostResponse,type ProfileAvatarResponse,type SpaceAccountCtxHandle,@@ -38,10 +39,6 @@ import {persistCurrentOwnedSpaces,releaseCurrentSpaceContext,} from "services/profile";-import {- parseSpaceProfilePayload,- spaceProfileTextField,-} from "services/profile-payload";import { normalizeSpaceMessageText } from "utils/message-limits";import { spacePostDeletedEvent } from "utils/post-events";import { postQuoteErrorState, postQuotePhotoIndex } from "utils/post-quote";@@ -72,14 +69,7 @@ interface SpacePostBase {isUnavailable?: boolean;}-export interface SpacePostAsset {- encryptedPostKey: string;- keyVersion: number;- mediaType?: string;- objectKey: string;- postId: number;- spaceId: string;-}+export type SpacePostAsset = PostAsset & { mediaType?: string };export interface SpacePostPhoto {height?: number;@@ -262,11 +252,9 @@ const messageActorForSpace = (};const actorProfile = (actor: SpaceActorResponse): FriendProfile => {- const payload = parseSpaceProfilePayload(actor.profile ?? "");+ const payload = actor.profile;const fullName =- spaceProfileTextField(payload.fullName) ||- spaceProfileTextField(payload.displayName) ||- actor.spaceSlug;+ payload?.fullName || payload?.displayName || actor.spaceSlug;const username = actor.spaceSlug;return {@@ -287,11 +275,9 @@ const actorProfile = (actor: SpaceActorResponse): FriendProfile => {const profileFromSpaceProfile = (spaceProfile: DecryptedSpaceProfile,): FriendProfile => {- const payload = parseSpaceProfilePayload(spaceProfile.profile);+ const payload = spaceProfile.profile;const fullName =- spaceProfileTextField(payload.fullName) ||- spaceProfileTextField(payload.displayName) ||- spaceProfile.spaceSlug;+ payload?.fullName || payload?.displayName || spaceProfile.spaceSlug;return {avatarKeyVersion: spaceProfile.avatar?.keyVersion,@@ -387,16 +373,9 @@ const cachedAccountAvatarURLIfPresent = async ();};-const postAssetFrom = (- post: PostResponse,- object: PostObjectPayload,-): SpacePostAsset => ({- encryptedPostKey: post.encryptedPostKey,- keyVersion: post.keyVersion,- mediaType: object.mediaType,- objectKey: object.objectKey,- postId: post.postId,- spaceId: post.spaceId,+const postAssetFrom = (photo: PostPhoto): SpacePostAsset => ({+ ...photo.asset,+ mediaType: photo.mediaType,});const postAssetCacheKey = (asset: SpacePostAsset) =>@@ -409,47 +388,27 @@ const accountPostAssetURLFromAsset = () =>cachedSpaceMediaBlobURL(postAssetCacheKey(asset),- () =>- ctx.downloadPostAssetWithKey(- asset.spaceId,- asset.encryptedPostKey,- asset.keyVersion,- viewerSpaceId ?? null,- asset.objectKey,- ),+ () => ctx.downloadPostAsset(asset, viewerSpaceId ?? null),asset.mediaType,);const accountPostAssetURL = (ctx: SpaceAccountCtxHandle,- post: PostResponse,- object: PostObjectPayload,+ photo: PostPhoto,viewerSpaceId?: string,-) =>- accountPostAssetURLFromAsset(- ctx,- postAssetFrom(post, object),- viewerSpaceId,- );+) => accountPostAssetURLFromAsset(ctx, postAssetFrom(photo), viewerSpaceId);-const cacheAccountPostAssetURL = async (- post: PostResponse,- object: PostObjectPayload,- blob: Blob,-) => {- const key = postAssetCacheKey(postAssetFrom(post, object));+const cacheAccountPostAssetURL = async (photo: PostPhoto, blob: Blob) => {+ const key = postAssetCacheKey(postAssetFrom(photo));await rememberCachedSpaceMediaBlobURL(key, blob);};-const firstObject = (post: PostResponse) =>- post.objects.find((object) => object.objectKey.trim()) ?? null;-const postPhotosFromResponse = (post: PostResponse): SpacePostPhoto[] =>- post.objects.map((object) => ({- height: object.height,- imageAsset: postAssetFrom(post, object),- thumbHash: object.thumbHash,- width: object.width,+ post.photos.map((photo) => ({+ height: photo.height,+ imageAsset: postAssetFrom(photo),+ thumbHash: photo.thumbHash,+ width: photo.width,}));const postBaseFromResponse = (@@ -478,12 +437,12 @@ const postFromAccountPost = async (loadMedia = true,viewerSpaceId?: string,): Promise<SpacePost> => {- const object = firstObject(post);const author = actorProfile(post.author);const base = postBaseFromResponse(post, author);- if (post.isUnavailable || !object) {+ if (post.isUnavailable) {return { ...base, isUnavailable: true };}+ const photo = post.photos[0]!;if (loadMedia) {author.avatarUrl = await accountAvatarURL(ctx,@@ -494,35 +453,35 @@ const postFromAccountPost = async (}const imageUrl = loadMedia- ? await accountPostAssetURL(ctx, post, object, viewerSpaceId)+ ? await accountPostAssetURL(ctx, photo, viewerSpaceId): undefined;return {...base,avatarUrl: author.avatarUrl,- height: object.height,- imageAsset: postAssetFrom(post, object),+ height: photo.height,+ imageAsset: postAssetFrom(photo),imageUrl,photos: postPhotosFromResponse(post),- thumbHash: object.thumbHash,- width: object.width,+ thumbHash: photo.thumbHash,+ width: photo.width,};};const profilePostFromPost = (post: PostResponse): SpaceProfilePost => {- const object = firstObject(post);const author = actorProfile(post.author);const base = postBaseFromResponse(post, author);- if (post.isUnavailable || !object) {+ if (post.isUnavailable) {return { ...base, avatarUrl: null, isUnavailable: true };}+ const photo = post.photos[0]!;return {...base,avatarUrl: null,- height: object.height,- imageAsset: postAssetFrom(post, object),+ height: photo.height,+ imageAsset: postAssetFrom(photo),photos: postPhotosFromResponse(post),- thumbHash: object.thumbHash,- width: object.width,+ thumbHash: photo.thumbHash,+ width: photo.width,};};@@ -576,12 +535,7 @@ export const openPublicSpaceLink = async (loadPostImage: (asset) =>cachedSpaceMediaBlobURL(postAssetCacheKey(asset),- () =>- ctx.downloadPostAsset(- asset.encryptedPostKey,- asset.keyVersion,- asset.objectKey,- ),+ () => ctx.downloadPostAsset(asset),asset.mediaType,),loadProfileMedia: async () => {@@ -635,24 +589,22 @@ const messageQuoteFromPostResponse = async (viewerSpaceId?: string,objectKey?: string,): Promise<SpaceMessageQuote> => {- const photoIndex = postQuotePhotoIndex(post.objects, objectKey);- const object = post.objects[photoIndex];+ const photoIndex = postQuotePhotoIndex(+ post.photos.map((photo) => photo.asset),+ objectKey,+ );+ const photo = post.photos[photoIndex];const quote: SpaceMessageQuote = {objectKey,- photoCount: post.objects.length,+ photoCount: post.photos.length,postId: post.postId,spaceId: post.spaceId,};- if (!object || post.isUnavailable) return { ...quote, isUnavailable: true };+ if (!photo || post.isUnavailable) return { ...quote, isUnavailable: true };if (!includeImage) return quote;try {- const imageUrl = await accountPostAssetURL(- ctx,- post,- object,- viewerSpaceId,- );+ const imageUrl = await accountPostAssetURL(ctx, photo, viewerSpaceId);if (!imageUrl) {quote.isUnavailable = true;return quote;@@ -1180,8 +1132,8 @@ export const createCurrentPhotoPost = async ({caption?.trim() || null,);await Promise.all(- created.objects.map((object, index) =>- cacheAccountPostAssetURL(created, object, images[index]!.file),+ created.photos.map((photo, index) =>+ cacheAccountPostAssetURL(photo, images[index]!.file),),);const post = await postFromAccountPost(ctx, created, true, spaceId);diff --git a/web/apps/space/tests/post-upload.test.ts b/web/apps/space/tests/post-upload.test.tsindex 75101939c2..54e311f68c 100644--- a/web/apps/space/tests/post-upload.test.ts+++ b/web/apps/space/tests/post-upload.test.ts@@ -1,5 +1,6 @@import { encryptBox, openSpaceAccountContext } from "ente-space-wasm";import { afterEach, expect, test, vi } from "vitest";+import { CachedSpacePost } from "../src/services/post-cache";afterEach(() => vi.unstubAllGlobals());@@ -44,13 +45,36 @@ const uploadFixture = async (failSecondUpload = false) => {},],});+ const profile = await encryptBox(+ btoa(JSON.stringify({ fullName: " Test User " })),+ spaceKey,+ );+ const author = {+ spaceId: "test-space",+ spaceSlug: "test",+ keyVersion: 1,+ encryptedProfile: Buffer.concat([+ Buffer.from(profile.nonce, "base64"),+ Buffer.from(profile.encryptedData, "base64"),+ ]).toString("base64"),+ };const calls: string[] = [];const uploadedAssets = new Map<string, ArrayBuffer>();let presigned = 0;let created: UploadedPost | undefined;+ const record = () => ({+ ...created,+ postId: 501,+ spaceId: "test-space",+ spaceSlug: "test",+ author,+ createdAt: "2026-09-17T00:00:00Z",+ viewerLiked: false,+ });const respond = async (request: Request) => {const path = new URL(request.url).pathname;calls.push(`${request.method} ${path}`);+ if (path.endsWith("/friends/shares")) return Response.json([]);if (path.endsWith("/uploads/presign")) {const index = presigned++;return Response.json({@@ -89,15 +113,13 @@ const uploadFixture = async (failSecondUpload = false) => {return Response.json({ postId: 501 });}if (request.method == "GET" && path.endsWith("/posts/501")) {- return Response.json({- ...created,- postId: 501,- spaceId: "test-space",- spaceSlug: "test",- author: { spaceId: "test-space", spaceSlug: "test" },- createdAt: "2026-09-17T00:00:00Z",- viewerLiked: false,- });+ return Response.json(record());+ }+ if (+ request.method == "GET" &&+ (path.endsWith("/posts") || path.endsWith("/feed"))+ ) {+ return Response.json({ items: [record()], nextCursor: "older" });}throw new Error(`Unexpected request: ${request.method} ${path}`);};@@ -106,7 +128,7 @@ const uploadFixture = async (failSecondUpload = false) => {Object.defineProperty(response, "url", { value: request.url });return response;});- return { ctx, calls, created: () => created };+ return { ctx, calls, author, created: () => created };};test.each([1, 3, 10])(@@ -120,13 +142,13 @@ test.each([1, 3, 10])("One shared caption",);expect(result.caption).toBe("One shared caption");- expect(result.objects.map((object) => object.objectKey)).toEqual(+ expect(result.photos.map((photo) => photo.asset.objectKey)).toEqual(Array.from({ length: count }, (_, i) => `photo-${i}`),);- expect(result.objects.map((object) => object.width)).toEqual(+ expect(result.photos.map((photo) => photo.width)).toEqual(Array.from({ length: count }, (_, i) => 1200 + i),);- expect(result.objects.map((object) => object.thumbHash)).toEqual(+ expect(result.photos.map((photo) => photo.thumbHash)).toEqual(Array.from({ length: count }, (_, i) => `hash-${i}`),);expect(created()?.objects.map((object) => object.position)).toEqual(@@ -168,13 +190,10 @@ test("copies typed-array photo bytes without JavaScript iteration", async () =>"Caption",);expect(created()?.objects).toHaveLength(1);- const downloaded = await ctx.downloadPostAssetWithKey(- post.spaceId,- post.encryptedPostKey,- post.keyVersion,- post.spaceId,- post.objects[0]!.objectKey,- );+ const cached = CachedSpacePost.shape.imageAsset+ .unwrap()+ .parse(JSON.parse(JSON.stringify(post.photos[0]!.asset)));+ const downloaded = await ctx.downloadPostAsset(cached, post.spaceId);expect(downloaded).toEqual(photo(0).bytes);} finally {ctx.free();@@ -212,3 +231,36 @@ test.each([0, 11])("rejects %i photos before uploading", async (count) => {ctx.free();}});++test("pages expose typed profiles and mark corrupt posts unavailable", async () => {+ const { ctx, created, author } = await uploadFixture();+ try {+ const post = await ctx.createPhotoPost(+ "test-space",+ [photo(0)],+ "Caption",+ );+ expect(post.author.profile).toEqual({ fullName: "Test User" });+ expect(post.isUnavailable).toBe(false);+ const metadataCipher = created()!.objects[0]!.metadataCipher;+ created()!.objects[0]!.metadataCipher = "not-base64";+ for (const page of [+ await ctx.listPosts("test-space"),+ await ctx.listFeed("test-space"),+ ]) {+ expect(page.nextCursor).toBe("older");+ expect(page.items[0]!.isUnavailable).toBe(true);+ expect(page.items[0]!.caption).toBeUndefined();+ expect(page.items[0]!.photos).toEqual([]);+ }+ await expect(ctx.getPost("test-space", 501n)).rejects.toThrow();+ created()!.objects[0]!.metadataCipher = metadataCipher;+ author.encryptedProfile = "not-base64";+ const [withoutProfile] = (await ctx.listPosts("test-space")).items;+ expect(withoutProfile!.photos).toHaveLength(1);+ expect(withoutProfile!.isUnavailable).toBe(false);+ expect(withoutProfile!.author.profile).toBeUndefined();+ } finally {+ ctx.free();+ }+});diff --git a/web/packages/wasm/space/index.ts b/web/packages/wasm/space/index.tsindex d184731a08..65a3e13de8 100644--- a/web/packages/wasm/space/index.ts+++ b/web/packages/wasm/space/index.ts@@ -10,8 +10,9 @@ export type {DecryptedSpaceProfile,MessageConversationActivity,MessageResponse,- PostObjectPayload,+ PostAsset,PostPage,+ PostPhoto,PostResponse,ProfileAvatarResponse,SpaceAccountCtxHandle,