format

client/src/cache.gleam

···
 pub fn set_profile(cache: Cache, profile: Profile) -> Cache {
   case profile.handle {
     Some(handle) -> {
-      let updated_profiles = dict.insert(cache.profile_entities, handle, profile)
+      let updated_profiles =
+        dict.insert(cache.profile_entities, handle, profile)
       Cache(..cache, profile_entities: updated_profiles)
     }
     None -> cache
···
   let updated_cache = set_profile(cache, optimistic_profile)
 
   // Track the update for potential rollback
-  Cache(
-    ..updated_cache,
-    optimistic_updates: [update, ..cache.optimistic_updates],
-  )
+  Cache(..updated_cache, optimistic_updates: [
+    update,
+    ..cache.optimistic_updates
+  ])
 }
 
 /// Commit an optimistic update (remove from rollback stack)

client/src/client/effects.gleam

···
             }
             Error(err) -> {
               io.println("JSON parse error: " <> string.inspect(err))
-              dispatch(model.ProfileQueryError(handle, "Failed to parse profile JSON"))
+              dispatch(model.ProfileQueryError(
+                handle,
+                "Failed to parse profile JSON",
+              ))
             }
           }
         }
···
             }
             Error(err) -> {
               io.println("JSON parse error: " <> string.inspect(err))
-              dispatch(model.AttendeesQueryError("Failed to parse attendees JSON"))
+              dispatch(model.AttendeesQueryError(
+                "Failed to parse attendees JSON",
+              ))
             }
           }
         }
···
       case result {
         Ok(file_data) -> {
           io.println("File processed successfully")
-          dispatch(model.ProfileEditMsg(profile_edit.AvatarFileProcessed(file_data)))
+          dispatch(
+            model.ProfileEditMsg(profile_edit.AvatarFileProcessed(file_data)),
+          )
         }
         Error(err) -> {
           io.println("Failed to process file: " <> err)
···
             Ok(updated_profile) -> {
               io.println("Profile parsed successfully")
               dispatch(
-                model.ProfileEditMsg(profile_edit.SaveCompleted(Ok(updated_profile))),
+                model.ProfileEditMsg(
+                  profile_edit.SaveCompleted(Ok(updated_profile)),
+                ),
               )
             }
             Error(_) -> {
               io.println("Failed to parse profile response")
               dispatch(
                 model.ProfileEditMsg(
-                  profile_edit.SaveCompleted(
-                    Error("Failed to parse updated profile"),
-                  ),
+                  profile_edit.SaveCompleted(Error(
+                    "Failed to parse updated profile",
+                  )),
                 ),
               )
             }
···
         }
         Ok(#(status, text)) -> {
           io.println(
-            "Save failed with status "
-            <> int.to_string(status)
-            <> ": "
-            <> text,
+            "Save failed with status " <> int.to_string(status) <> ": " <> text,
           )
           dispatch(
             model.ProfileEditMsg(
-              profile_edit.SaveCompleted(
-                Error("Failed to save profile (status " <> int.to_string(status) <> ")"),
-              ),
+              profile_edit.SaveCompleted(Error(
+                "Failed to save profile (status "
+                <> int.to_string(status)
+                <> ")",
+              )),
             ),
           )
         }
         Error(err) -> {
           io.println("Save request failed: " <> err)
-          dispatch(
-            model.ProfileEditMsg(profile_edit.SaveCompleted(Error(err))),
-          )
+          dispatch(model.ProfileEditMsg(profile_edit.SaveCompleted(Error(err))))
         }
       }
     })

client/src/client/init.gleam

···
     Some(profile_data), _ -> {
       // Seed cache with profile and mark as fresh
       let stale_time = query.stale_time(query.ProfileQuery(""))
-      cache.hydrate_profile(initial_cache, profile_data, current_time_ms, stale_time)
+      cache.hydrate_profile(
+        initial_cache,
+        profile_data,
+        current_time_ms,
+        stale_time,
+      )
     }
     None, Some(attendees_data) -> {
       // Seed cache with attendees and mark all profiles as fresh
···
 
       // Check if we need to fetch (cache might be stale or missing)
       let query_key = query.to_string(query.ProfileQuery(handle))
-      let needs_fetch = cache.is_query_stale(hydrated_cache, query_key, current_time_ms)
+      let needs_fetch =
+        cache.is_query_stale(hydrated_cache, query_key, current_time_ms)
 
       let fetch_effect = case needs_fetch {
         True -> effects.fetch_profile_with_cache(handle)
···
   document.query_selector("#model")
   |> result.map(plinth_element.inner_text)
   |> result.try(fn(json_string) {
-    json.parse(json_string, decode.at(["user"], {
-      use handle <- decode.field("handle", decode.string)
-      decode.success(layout.User(name: None, handle: handle))
-    }))
+    json.parse(
+      json_string,
+      decode.at(["user"], {
+        use handle <- decode.field("handle", decode.string)
+        decode.success(layout.User(name: None, handle: handle))
+      }),
+    )
     |> result.replace_error(Nil)
   })
   |> option.from_result

client/src/client/view.gleam

···
       model.Attendees -> {
         // Read from cache
         let query_key_str = query.to_string(query.AttendeesQuery)
-        let query_status = cache.get_query_status(current_model.cache, query_key_str)
+        let query_status =
+          cache.get_query_status(current_model.cache, query_key_str)
 
         case query_status {
           cache.Idle | cache.Fetching -> attendees.view_loading()
···
       model.Profile(handle: handle) -> {
         // Read profile from cache
         let query_key_str = query.to_string(query.ProfileQuery(handle))
-        let query_status = cache.get_query_status(current_model.cache, query_key_str)
+        let query_status =
+          cache.get_query_status(current_model.cache, query_key_str)
         let profile_from_cache = cache.get_profile(current_model.cache, handle)
 
         case profile_from_cache, query_status {
···
         // Read profile from cache
         let profile_from_cache = cache.get_profile(current_model.cache, handle)
         let query_key_str = query.to_string(query.ProfileQuery(handle))
-        let query_status = cache.get_query_status(current_model.cache, query_key_str)
+        let query_status =
+          cache.get_query_status(current_model.cache, query_key_str)
 
         case profile_from_cache, query_status {
           option.Some(p), _ ->

client/src/pages/attendees.gleam

···
         // Profile info
         html.div([attribute.class("flex-1 min-w-0")], [
           // Display name
-          html.h3([attribute.class("text-lg font-semibold text-white truncate")], [
-            html.text(display_name),
-          ]),
+          html.h3(
+            [attribute.class("text-lg font-semibold text-white truncate")],
+            [
+              html.text(display_name),
+            ],
+          ),
           // Handle
           case p.handle {
             option.Some(h) ->
···
 
 pub fn view_loading() -> Element(msg) {
   html.div([attribute.class("text-center py-12")], [
-    html.p([attribute.class("text-zinc-400")], [html.text("Loading attendees...")]),
+    html.p([attribute.class("text-zinc-400")], [
+      html.text("Loading attendees..."),
+    ]),
   ])
 }
 

client/src/pages/login.gleam

···
             html.label(
               [
                 attribute.for("loginHint"),
-                attribute.class(
-                  "block text-sm font-medium text-zinc-400 mb-2",
-                ),
+                attribute.class("block text-sm font-medium text-zinc-400 mb-2"),
               ],
               [html.text("Handle or PDS Host")],
             ),
···
               attribute.href("https://bsky.app"),
               attribute.target("_blank"),
               attribute.attribute("rel", "noopener noreferrer"),
-              attribute.class(
-                "text-zinc-400 hover:text-zinc-300 underline",
-              ),
+              attribute.class("text-zinc-400 hover:text-zinc-300 underline"),
             ],
             [html.text("Create one on Bluesky")],
           ),

client/src/pages/profile_edit.gleam

···
     DisplayNameUpdated(value) -> FormData(..form_data, display_name: value)
     DescriptionUpdated(value) -> FormData(..form_data, description: value)
     InterestsUpdated(value) -> FormData(..form_data, interests: value)
-    AvatarFileChanged(_files) -> form_data  // Handled in parent with effect
+    AvatarFileChanged(_files) -> form_data
+    // Handled in parent with effect
     AvatarFileProcessed(file_data) ->
       FormData(
         ..form_data,
···
                   attribute.id("avatar-upload"),
                   attribute.accept(["image/*"]),
                   attribute.class("hidden"),
-                  event.on("change", decode.map(decode.dynamic, fn(_) {
-                    on_msg(AvatarFileChanged([]))
-                  })),
+                  event.on(
+                    "change",
+                    decode.map(decode.dynamic, fn(_) {
+                      on_msg(AvatarFileChanged([]))
+                    }),
+                  ),
                 ]),
               ]),
             ]),
···
     ),
   ])
 }
-

client/src/ui/avatar.gleam

···
   Xl
 }
 
-pub fn avatar(
-  src: Option(String),
-  alt: String,
-  size: Size,
-) -> Element(msg) {
+pub fn avatar(src: Option(String), alt: String, size: Size) -> Element(msg) {
   let size_classes = case size {
     Sm -> "w-8 h-8"
     Md -> "w-12 h-12"
···
   }
 
   let base_classes =
-    size_classes
-    <> " rounded-full border-2 border-zinc-700 bg-zinc-800"
+    size_classes <> " rounded-full border-2 border-zinc-700 bg-zinc-800"
 
   case src {
     option.Some(url) ->

client/src/ui/layout.gleam

···
   User(name: Option(String), handle: String)
 }
 
-pub fn layout(
-  user: Option(User),
-  children: List(Element(msg)),
-) -> Element(msg) {
-  html.div([attribute.class("min-h-screen bg-zinc-950 text-zinc-300 font-mono")], [
-    html.div([attribute.class("max-w-4xl mx-auto px-6 py-12")], [
-      // Header
-      html.div([attribute.class("border-b border-zinc-800 pb-4")], [
-        html.div([attribute.class("flex items-end justify-between")], [
-          // Logo/Title
-          html.a(
-            [
-              attribute.href("/"),
-              attribute.class("flex items-center gap-3 hover:opacity-80 transition-opacity"),
-            ],
-            [
-              html.div([], [
-                html.h1([attribute.class("text-2xl font-bold text-white")], [
-                  html.text("atmosphere conf"),
+pub fn layout(user: Option(User), children: List(Element(msg))) -> Element(msg) {
+  html.div(
+    [attribute.class("min-h-screen bg-zinc-950 text-zinc-300 font-mono")],
+    [
+      html.div([attribute.class("max-w-4xl mx-auto px-6 py-12")], [
+        // Header
+        html.div([attribute.class("border-b border-zinc-800 pb-4")], [
+          html.div([attribute.class("flex items-end justify-between")], [
+            // Logo/Title
+            html.a(
+              [
+                attribute.href("/"),
+                attribute.class(
+                  "flex items-center gap-3 hover:opacity-80 transition-opacity",
+                ),
+              ],
+              [
+                html.div([], [
+                  html.h1([attribute.class("text-2xl font-bold text-white")], [
+                    html.text("atmosphere conf"),
+                  ]),
                 ]),
-              ]),
-            ],
-          ),
-          // Navigation
-          html.div([attribute.class("flex gap-4 text-xs items-center")], [
-            case user {
-              option.Some(_) ->
-                html.a(
-                  [
-                    attribute.href("/attendees"),
-                    attribute.class("px-2 py-1 text-zinc-500 hover:text-zinc-300 transition-colors"),
-                  ],
-                  [html.text("Attendees")],
-                )
-              option.None -> html.text("")
-            },
-            view_nav(user),
+              ],
+            ),
+            // Navigation
+            html.div([attribute.class("flex gap-4 text-xs items-center")], [
+              case user {
+                option.Some(_) ->
+                  html.a(
+                    [
+                      attribute.href("/attendees"),
+                      attribute.class(
+                        "px-2 py-1 text-zinc-500 hover:text-zinc-300 transition-colors",
+                      ),
+                    ],
+                    [html.text("Attendees")],
+                  )
+                option.None -> html.text("")
+              },
+              view_nav(user),
+            ]),
           ]),
         ]),
+        // Spacer
+        html.div([attribute.class("mb-8")], []),
+        // Content
+        html.div([], children),
       ]),
-      // Spacer
-      html.div([attribute.class("mb-8")], []),
-      // Content
-      html.div([], children),
-    ]),
-  ])
+    ],
+  )
 }
 
 fn view_nav(user: Option(User)) -> Element(msg) {
···
         html.a(
           [
             attribute.href("/profile/" <> u.handle),
-            attribute.class("px-2 py-1 text-zinc-400 hover:text-zinc-200 transition-colors"),
+            attribute.class(
+              "px-2 py-1 text-zinc-400 hover:text-zinc-200 transition-colors",
+            ),
           ],
           [html.text(display_name)],
         ),
···
             html.button(
               [
                 attribute.type_("submit"),
-                attribute.class("px-2 py-1 text-zinc-500 hover:text-zinc-300 transition-colors cursor-pointer"),
+                attribute.class(
+                  "px-2 py-1 text-zinc-500 hover:text-zinc-300 transition-colors cursor-pointer",
+                ),
               ],
               [html.text("Sign Out")],
             ),
···
       html.a(
         [
           attribute.href("/login"),
-          attribute.class("px-2 py-1 text-zinc-500 hover:text-zinc-300 transition-colors"),
+          attribute.class(
+            "px-2 py-1 text-zinc-500 hover:text-zinc-300 transition-colors",
+          ),
         ],
         [html.text("Sign In")],
       )

client/src/ui/location_input.gleam

···
           )
         }
         Error(_err) -> {
-          #(
-            Model(..model, suggestions: [], is_loading: False),
-            effect.none(),
-          )
+          #(Model(..model, suggestions: [], is_loading: False), effect.none())
         }
       }
     }
···
 fn icon_element() -> Element(Msg) {
   html.div(
     [
-      attribute.class(
-        "absolute right-3 top-1/2 -translate-y-1/2 text-zinc-500",
-      ),
+      attribute.class("absolute right-3 top-1/2 -translate-y-1/2 text-zinc-500"),
     ],
     [html.text("📍")],
   )

client/src/ui/textarea.gleam

···
 import lustre/element.{type Element}
 import lustre/element/html
 
-pub fn textarea(
-  attributes: List(Attribute(msg)),
-  value: String,
-) -> Element(msg) {
+pub fn textarea(attributes: List(Attribute(msg)), value: String) -> Element(msg) {
   let classes =
     "w-full px-3 py-2 bg-zinc-900 border border-zinc-800 rounded text-sm text-zinc-300 focus:outline-none focus:border-zinc-700 disabled:opacity-50 disabled:cursor-not-allowed resize-y min-h-[100px]"
 

client/src/utils/location.gleam

···
 
 /// Search for locations using Nominatim API
 @external(javascript, "../client_ffi.mjs", "searchLocations")
-pub fn search_locations(
-  query: String,
-) -> Promise(Result(List(Dynamic), String))
+pub fn search_locations(query: String) -> Promise(Result(List(Dynamic), String))
 
 /// Convert lat/lon to H3 index
 @external(javascript, "../client_ffi.mjs", "latLonToH3")

server/src/api/graphql.gleam

···
   ht: get_profile_gql.CommunityLexiconLocationHthree,
 ) -> Option(profile.HomeTown) {
   case ht.name, ht.value {
-    Some(name), Some(value) -> Some(profile.HomeTown(name: name, h3_index: value))
+    Some(name), Some(value) ->
+      Some(profile.HomeTown(name: name, h3_index: value))
     _, _ -> None
   }
 }
···
   ht: update_profile_gql.CommunityLexiconLocationHthree,
 ) -> Option(profile.HomeTown) {
   case ht.name, ht.value {
-    Some(name), Some(value) -> Some(profile.HomeTown(name: name, h3_index: value))
+    Some(name), Some(value) ->
+      Some(profile.HomeTown(name: name, h3_index: value))
     _, _ -> None
   }
 }
···
   ht: list_profiles_gql.CommunityLexiconLocationHthree,
 ) -> Option(profile.HomeTown) {
   case ht.name, ht.value {
-    Some(name), Some(value) -> Some(profile.HomeTown(name: name, h3_index: value))
+    Some(name), Some(value) ->
+      Some(profile.HomeTown(name: name, h3_index: value))
     _, _ -> None
   }
 }

server/src/api/graphql/check_profile_exists.gleam

···
   OrgAtmosphereconfProfileConnection(edges: List(OrgAtmosphereconfProfileEdge))
 }
 
-pub fn org_atmosphereconf_profile_connection_decoder() -> decode.Decoder(OrgAtmosphereconfProfileConnection) {
-  use edges <- decode.field("edges", decode.list(org_atmosphereconf_profile_edge_decoder()))
+pub fn org_atmosphereconf_profile_connection_decoder() -> decode.Decoder(
+  OrgAtmosphereconfProfileConnection,
+) {
+  use edges <- decode.field(
+    "edges",
+    decode.list(org_atmosphereconf_profile_edge_decoder()),
+  )
   decode.success(OrgAtmosphereconfProfileConnection(edges: edges))
 }
 
···
   OrgAtmosphereconfProfileEdge(node: OrgAtmosphereconfProfile)
 }
 
-pub fn org_atmosphereconf_profile_edge_decoder() -> decode.Decoder(OrgAtmosphereconfProfileEdge) {
+pub fn org_atmosphereconf_profile_edge_decoder() -> decode.Decoder(
+  OrgAtmosphereconfProfileEdge,
+) {
   use node <- decode.field("node", org_atmosphereconf_profile_decoder())
   decode.success(OrgAtmosphereconfProfileEdge(node: node))
 }
···
   OrgAtmosphereconfProfile(id: String)
 }
 
-pub fn org_atmosphereconf_profile_decoder() -> decode.Decoder(OrgAtmosphereconfProfile) {
+pub fn org_atmosphereconf_profile_decoder() -> decode.Decoder(
+  OrgAtmosphereconfProfile,
+) {
   use id <- decode.field("id", decode.string)
   decode.success(OrgAtmosphereconfProfile(id: id))
 }
···
   )
 }
 
-pub fn check_profile_exists_response_decoder() -> decode.Decoder(CheckProfileExistsResponse) {
-  use org_atmosphereconf_profiles <- decode.field("orgAtmosphereconfProfiles", org_atmosphereconf_profile_connection_decoder())
+pub fn check_profile_exists_response_decoder() -> decode.Decoder(
+  CheckProfileExistsResponse,
+) {
+  use org_atmosphereconf_profiles <- decode.field(
+    "orgAtmosphereconfProfiles",
+    org_atmosphereconf_profile_connection_decoder(),
+  )
   decode.success(CheckProfileExistsResponse(
     org_atmosphereconf_profiles: org_atmosphereconf_profiles,
   ))
 }
 
-pub fn check_profile_exists(client: squall.Client, did: String) -> Result(CheckProfileExistsResponse, String) {
+pub fn check_profile_exists(
+  client: squall.Client,
+  did: String,
+) -> Result(CheckProfileExistsResponse, String) {
   let query =
     "query CheckProfile($did: String!) { orgAtmosphereconfProfiles(where: { did: { eq: $did } }, first: 1) { edges { node { id } } } }"
-  let variables =
-    json.object([#("did", json.string(did))])
+  let variables = json.object([#("did", json.string(did))])
   let body =
     json.object([#("query", json.string(query)), #("variables", variables)])
   use req <- result.try(

server/src/api/graphql/create_profile.gleam

···
 import gleam/httpc
 import gleam/json
 import gleam/list
+import gleam/option.{type Option, None, Some}
 import gleam/result
 import squall
-import gleam/option.{type Option, Some, None}
 
 pub type OrgAtmosphereconfProfileInput {
   OrgAtmosphereconfProfileInput(
···
   )
 }
 
-fn org_atmosphereconf_profile_input_to_json(input: OrgAtmosphereconfProfileInput) -> json.Json {
-  [{
+fn org_atmosphereconf_profile_input_to_json(
+  input: OrgAtmosphereconfProfileInput,
+) -> json.Json {
+  [
+    {
       case input.avatar {
         Some(val) -> Some(#("avatar", val))
         None -> None
       }
-    }, {
+    },
+    {
       case input.created_at {
         Some(val) -> Some(#("createdAt", json.string(val)))
         None -> None
       }
-    }, {
+    },
+    {
       case input.description {
         Some(val) -> Some(#("description", json.string(val)))
         None -> None
       }
-    }, {
+    },
+    {
       case input.display_name {
         Some(val) -> Some(#("displayName", json.string(val)))
         None -> None
       }
-    }, {
+    },
+    {
       case input.home_town {
         Some(val) -> Some(#("homeTown", val))
         None -> None
       }
-    }, {
+    },
+    {
       case input.interests {
-        Some(val) -> Some(#("interests", json.array(from: val, of: json.string)))
+        Some(val) ->
+          Some(#("interests", json.array(from: val, of: json.string)))
         None -> None
       }
-    }]
+    },
+  ]
   |> list.filter_map(fn(x) {
     case x {
       Some(val) -> Ok(val)
···
   OrgAtmosphereconfProfile(id: String)
 }
 
-pub fn org_atmosphereconf_profile_decoder() -> decode.Decoder(OrgAtmosphereconfProfile) {
+pub fn org_atmosphereconf_profile_decoder() -> decode.Decoder(
+  OrgAtmosphereconfProfile,
+) {
   use id <- decode.field("id", decode.string)
   decode.success(OrgAtmosphereconfProfile(id: id))
 }
···
   )
 }
 
-pub fn create_profile_response_decoder() -> decode.Decoder(CreateProfileResponse) {
-  use create_org_atmosphereconf_profile <- decode.field("createOrgAtmosphereconfProfile", org_atmosphereconf_profile_decoder())
+pub fn create_profile_response_decoder() -> decode.Decoder(
+  CreateProfileResponse,
+) {
+  use create_org_atmosphereconf_profile <- decode.field(
+    "createOrgAtmosphereconfProfile",
+    org_atmosphereconf_profile_decoder(),
+  )
   decode.success(CreateProfileResponse(
     create_org_atmosphereconf_profile: create_org_atmosphereconf_profile,
   ))
 }
 
-pub fn create_profile(client: squall.Client, input: OrgAtmosphereconfProfileInput, rkey: String) -> Result(CreateProfileResponse, String) {
+pub fn create_profile(
+  client: squall.Client,
+  input: OrgAtmosphereconfProfileInput,
+  rkey: String,
+) -> Result(CreateProfileResponse, String) {
   let query =
     "mutation CreateProfile($input: OrgAtmosphereconfProfileInput!, $rkey: String) { createOrgAtmosphereconfProfile(input: $input, rkey: $rkey) { id } }"
   let variables =
-    json.object(
-      [
-        #("input", org_atmosphereconf_profile_input_to_json(input)),
-        #("rkey", json.string(rkey)),
-      ],
-    )
+    json.object([
+      #("input", org_atmosphereconf_profile_input_to_json(input)),
+      #("rkey", json.string(rkey)),
+    ])
   let body =
     json.object([#("query", json.string(query)), #("variables", variables)])
   use req <- result.try(

server/src/api/graphql/get_bluesky_profile.gleam

···
 import gleam/httpc
 import gleam/json
 import gleam/list
+import gleam/option.{type Option}
 import gleam/result
 import squall
-import gleam/option.{type Option}
 
 pub type AppBskyActorProfileConnection {
   AppBskyActorProfileConnection(edges: List(AppBskyActorProfileEdge))
 }
 
-pub fn app_bsky_actor_profile_connection_decoder() -> decode.Decoder(AppBskyActorProfileConnection) {
-  use edges <- decode.field("edges", decode.list(app_bsky_actor_profile_edge_decoder()))
+pub fn app_bsky_actor_profile_connection_decoder() -> decode.Decoder(
+  AppBskyActorProfileConnection,
+) {
+  use edges <- decode.field(
+    "edges",
+    decode.list(app_bsky_actor_profile_edge_decoder()),
+  )
   decode.success(AppBskyActorProfileConnection(edges: edges))
 }
 
···
   AppBskyActorProfileEdge(node: AppBskyActorProfile)
 }
 
-pub fn app_bsky_actor_profile_edge_decoder() -> decode.Decoder(AppBskyActorProfileEdge) {
+pub fn app_bsky_actor_profile_edge_decoder() -> decode.Decoder(
+  AppBskyActorProfileEdge,
+) {
   use node <- decode.field("node", app_bsky_actor_profile_decoder())
   decode.success(AppBskyActorProfileEdge(node: node))
 }
···
 }
 
 pub fn app_bsky_actor_profile_decoder() -> decode.Decoder(AppBskyActorProfile) {
-  use display_name <- decode.field("displayName", decode.optional(decode.string))
+  use display_name <- decode.field(
+    "displayName",
+    decode.optional(decode.string),
+  )
   use description <- decode.field("description", decode.optional(decode.string))
   use avatar <- decode.field("avatar", decode.optional(blob_decoder()))
   decode.success(AppBskyActorProfile(
···
   )
 }
 
-pub fn get_bluesky_profile_response_decoder() -> decode.Decoder(GetBlueskyProfileResponse) {
-  use app_bsky_actor_profiles <- decode.field("appBskyActorProfiles", app_bsky_actor_profile_connection_decoder())
+pub fn get_bluesky_profile_response_decoder() -> decode.Decoder(
+  GetBlueskyProfileResponse,
+) {
+  use app_bsky_actor_profiles <- decode.field(
+    "appBskyActorProfiles",
+    app_bsky_actor_profile_connection_decoder(),
+  )
   decode.success(GetBlueskyProfileResponse(
     app_bsky_actor_profiles: app_bsky_actor_profiles,
   ))
 }
 
-pub fn get_bluesky_profile(client: squall.Client, did: String) -> Result(GetBlueskyProfileResponse, String) {
+pub fn get_bluesky_profile(
+  client: squall.Client,
+  did: String,
+) -> Result(GetBlueskyProfileResponse, String) {
   let query =
     "query GetBskyProfile($did: String!) { appBskyActorProfiles(where: { did: { eq: $did } }, first: 1) { edges { node { displayName description avatar { ref mimeType size } } } } }"
-  let variables =
-    json.object([#("did", json.string(did))])
+  let variables = json.object([#("did", json.string(did))])
   let body =
     json.object([#("query", json.string(query)), #("variables", variables)])
   use req <- result.try(

server/src/api/graphql/get_profile.gleam

···
 import gleam/httpc
 import gleam/json
 import gleam/list
+import gleam/option.{type Option}
 import gleam/result
 import squall
-import gleam/option.{type Option}
 
 pub type OrgAtmosphereconfProfileConnection {
   OrgAtmosphereconfProfileConnection(edges: List(OrgAtmosphereconfProfileEdge))
 }
 
-pub fn org_atmosphereconf_profile_connection_decoder() -> decode.Decoder(OrgAtmosphereconfProfileConnection) {
-  use edges <- decode.field("edges", decode.list(org_atmosphereconf_profile_edge_decoder()))
+pub fn org_atmosphereconf_profile_connection_decoder() -> decode.Decoder(
+  OrgAtmosphereconfProfileConnection,
+) {
+  use edges <- decode.field(
+    "edges",
+    decode.list(org_atmosphereconf_profile_edge_decoder()),
+  )
   decode.success(OrgAtmosphereconfProfileConnection(edges: edges))
 }
 
···
   OrgAtmosphereconfProfileEdge(node: OrgAtmosphereconfProfile)
 }
 
-pub fn org_atmosphereconf_profile_edge_decoder() -> decode.Decoder(OrgAtmosphereconfProfileEdge) {
+pub fn org_atmosphereconf_profile_edge_decoder() -> decode.Decoder(
+  OrgAtmosphereconfProfileEdge,
+) {
   use node <- decode.field("node", org_atmosphereconf_profile_decoder())
   decode.success(OrgAtmosphereconfProfileEdge(node: node))
 }
···
   )
 }
 
-pub fn org_atmosphereconf_profile_decoder() -> decode.Decoder(OrgAtmosphereconfProfile) {
+pub fn org_atmosphereconf_profile_decoder() -> decode.Decoder(
+  OrgAtmosphereconfProfile,
+) {
   use id <- decode.field("id", decode.string)
   use uri <- decode.field("uri", decode.string)
   use cid <- decode.field("cid", decode.string)
   use did <- decode.field("did", decode.string)
-  use actor_handle <- decode.field("actorHandle", decode.optional(decode.string))
-  use display_name <- decode.field("displayName", decode.optional(decode.string))
+  use actor_handle <- decode.field(
+    "actorHandle",
+    decode.optional(decode.string),
+  )
+  use display_name <- decode.field(
+    "displayName",
+    decode.optional(decode.string),
+  )
   use description <- decode.field("description", decode.optional(decode.string))
   use avatar <- decode.field("avatar", decode.optional(blob_decoder()))
-  use home_town <- decode.field("homeTown", decode.optional(community_lexicon_location_hthree_decoder()))
-  use interests <- decode.field("interests", decode.optional(decode.list(decode.string)))
+  use home_town <- decode.field(
+    "homeTown",
+    decode.optional(community_lexicon_location_hthree_decoder()),
+  )
+  use interests <- decode.field(
+    "interests",
+    decode.optional(decode.list(decode.string)),
+  )
   use created_at <- decode.field("createdAt", decode.optional(decode.string))
   use indexed_at <- decode.field("indexedAt", decode.string)
   decode.success(OrgAtmosphereconfProfile(
···
   CommunityLexiconLocationHthree(name: Option(String), value: Option(String))
 }
 
-pub fn community_lexicon_location_hthree_decoder() -> decode.Decoder(CommunityLexiconLocationHthree) {
+pub fn community_lexicon_location_hthree_decoder() -> decode.Decoder(
+  CommunityLexiconLocationHthree,
+) {
   use name <- decode.field("name", decode.optional(decode.string))
   use value <- decode.field("value", decode.optional(decode.string))
   decode.success(CommunityLexiconLocationHthree(name: name, value: value))
···
 }
 
 pub fn get_profile_response_decoder() -> decode.Decoder(GetProfileResponse) {
-  use org_atmosphereconf_profiles <- decode.field("orgAtmosphereconfProfiles", org_atmosphereconf_profile_connection_decoder())
+  use org_atmosphereconf_profiles <- decode.field(
+    "orgAtmosphereconfProfiles",
+    org_atmosphereconf_profile_connection_decoder(),
+  )
   decode.success(GetProfileResponse(
     org_atmosphereconf_profiles: org_atmosphereconf_profiles,
   ))
 }
 
-pub fn get_profile(client: squall.Client, handle: String) -> Result(GetProfileResponse, String) {
+pub fn get_profile(
+  client: squall.Client,
+  handle: String,
+) -> Result(GetProfileResponse, String) {
   let query =
     "query GetProfile($handle: String!) { orgAtmosphereconfProfiles(where: { actorHandle: { eq: $handle } }, first: 1) { edges { node { id uri cid did actorHandle displayName description avatar { ref mimeType size url(preset: \"avatar\") } homeTown { name value } interests createdAt indexedAt } } } }"
-  let variables =
-    json.object([#("handle", json.string(handle))])
+  let variables = json.object([#("handle", json.string(handle))])
   let body =
     json.object([#("query", json.string(query)), #("variables", variables)])
   use req <- result.try(

server/src/api/graphql/list_profiles.gleam

···
 import gleam/httpc
 import gleam/json
 import gleam/list
+import gleam/option.{type Option}
 import gleam/result
 import squall
-import gleam/option.{type Option}
 
 pub type OrgAtmosphereconfProfileConnection {
   OrgAtmosphereconfProfileConnection(edges: List(OrgAtmosphereconfProfileEdge))
 }
 
-pub fn org_atmosphereconf_profile_connection_decoder() -> decode.Decoder(OrgAtmosphereconfProfileConnection) {
-  use edges <- decode.field("edges", decode.list(org_atmosphereconf_profile_edge_decoder()))
+pub fn org_atmosphereconf_profile_connection_decoder() -> decode.Decoder(
+  OrgAtmosphereconfProfileConnection,
+) {
+  use edges <- decode.field(
+    "edges",
+    decode.list(org_atmosphereconf_profile_edge_decoder()),
+  )
   decode.success(OrgAtmosphereconfProfileConnection(edges: edges))
 }
 
···
   OrgAtmosphereconfProfileEdge(node: OrgAtmosphereconfProfile)
 }
 
-pub fn org_atmosphereconf_profile_edge_decoder() -> decode.Decoder(OrgAtmosphereconfProfileEdge) {
+pub fn org_atmosphereconf_profile_edge_decoder() -> decode.Decoder(
+  OrgAtmosphereconfProfileEdge,
+) {
   use node <- decode.field("node", org_atmosphereconf_profile_decoder())
   decode.success(OrgAtmosphereconfProfileEdge(node: node))
 }
···
   )
 }
 
-pub fn org_atmosphereconf_profile_decoder() -> decode.Decoder(OrgAtmosphereconfProfile) {
+pub fn org_atmosphereconf_profile_decoder() -> decode.Decoder(
+  OrgAtmosphereconfProfile,
+) {
   use id <- decode.field("id", decode.string)
   use uri <- decode.field("uri", decode.string)
   use cid <- decode.field("cid", decode.string)
   use did <- decode.field("did", decode.string)
-  use actor_handle <- decode.field("actorHandle", decode.optional(decode.string))
-  use display_name <- decode.field("displayName", decode.optional(decode.string))
+  use actor_handle <- decode.field(
+    "actorHandle",
+    decode.optional(decode.string),
+  )
+  use display_name <- decode.field(
+    "displayName",
+    decode.optional(decode.string),
+  )
   use description <- decode.field("description", decode.optional(decode.string))
   use avatar <- decode.field("avatar", decode.optional(blob_decoder()))
-  use home_town <- decode.field("homeTown", decode.optional(community_lexicon_location_hthree_decoder()))
-  use interests <- decode.field("interests", decode.optional(decode.list(decode.string)))
+  use home_town <- decode.field(
+    "homeTown",
+    decode.optional(community_lexicon_location_hthree_decoder()),
+  )
+  use interests <- decode.field(
+    "interests",
+    decode.optional(decode.list(decode.string)),
+  )
   use created_at <- decode.field("createdAt", decode.optional(decode.string))
   use indexed_at <- decode.field("indexedAt", decode.string)
   decode.success(OrgAtmosphereconfProfile(
···
   CommunityLexiconLocationHthree(name: Option(String), value: Option(String))
 }
 
-pub fn community_lexicon_location_hthree_decoder() -> decode.Decoder(CommunityLexiconLocationHthree) {
+pub fn community_lexicon_location_hthree_decoder() -> decode.Decoder(
+  CommunityLexiconLocationHthree,
+) {
   use name <- decode.field("name", decode.optional(decode.string))
   use value <- decode.field("value", decode.optional(decode.string))
   decode.success(CommunityLexiconLocationHthree(name: name, value: value))
···
 }
 
 pub fn list_profiles_response_decoder() -> decode.Decoder(ListProfilesResponse) {
-  use org_atmosphereconf_profiles <- decode.field("orgAtmosphereconfProfiles", org_atmosphereconf_profile_connection_decoder())
+  use org_atmosphereconf_profiles <- decode.field(
+    "orgAtmosphereconfProfiles",
+    org_atmosphereconf_profile_connection_decoder(),
+  )
   decode.success(ListProfilesResponse(
     org_atmosphereconf_profiles: org_atmosphereconf_profiles,
   ))
 }
 
-pub fn list_profiles(client: squall.Client) -> Result(ListProfilesResponse, String) {
+pub fn list_profiles(
+  client: squall.Client,
+) -> Result(ListProfilesResponse, String) {
   let query =
     "query ListProfiles { orgAtmosphereconfProfiles { edges { node { id uri cid did actorHandle displayName description avatar { ref mimeType size url(preset: \"avatar\") } homeTown { name value } interests createdAt indexedAt } } } }"
-  let variables =
-    json.object([])
+  let variables = json.object([])
   let body =
     json.object([#("query", json.string(query)), #("variables", variables)])
   use req <- result.try(

server/src/api/graphql/sync_user_collections.gleam

···
   SyncUserCollectionsResponse(sync_user_collections: SyncResult)
 }
 
-pub fn sync_user_collections_response_decoder() -> decode.Decoder(SyncUserCollectionsResponse) {
-  use sync_user_collections <- decode.field("syncUserCollections", sync_result_decoder())
+pub fn sync_user_collections_response_decoder() -> decode.Decoder(
+  SyncUserCollectionsResponse,
+) {
+  use sync_user_collections <- decode.field(
+    "syncUserCollections",
+    sync_result_decoder(),
+  )
   decode.success(SyncUserCollectionsResponse(
     sync_user_collections: sync_user_collections,
   ))
 }
 
-pub fn sync_user_collections(client: squall.Client, did: String) -> Result(SyncUserCollectionsResponse, String) {
+pub fn sync_user_collections(
+  client: squall.Client,
+  did: String,
+) -> Result(SyncUserCollectionsResponse, String) {
   let query =
     "mutation SyncUserCollections($did: String!) { syncUserCollections(did: $did) { success message } }"
-  let variables =
-    json.object([#("did", json.string(did))])
+  let variables = json.object([#("did", json.string(did))])
   let body =
     json.object([#("query", json.string(query)), #("variables", variables)])
   use req <- result.try(

server/src/api/graphql/update_profile.gleam

···
 import gleam/httpc
 import gleam/json
 import gleam/list
+import gleam/option.{type Option, None, Some}
 import gleam/result
 import squall
-import gleam/option.{type Option, Some, None}
 
 pub type OrgAtmosphereconfProfileInput {
   OrgAtmosphereconfProfileInput(
···
   )
 }
 
-fn org_atmosphereconf_profile_input_to_json(input: OrgAtmosphereconfProfileInput) -> json.Json {
-  [{
+fn org_atmosphereconf_profile_input_to_json(
+  input: OrgAtmosphereconfProfileInput,
+) -> json.Json {
+  [
+    {
       case input.avatar {
         Some(val) -> Some(#("avatar", val))
         None -> None
       }
-    }, {
+    },
+    {
       case input.created_at {
         Some(val) -> Some(#("createdAt", json.string(val)))
         None -> None
       }
-    }, {
+    },
+    {
       case input.description {
         Some(val) -> Some(#("description", json.string(val)))
         None -> None
       }
-    }, {
+    },
+    {
       case input.display_name {
         Some(val) -> Some(#("displayName", json.string(val)))
         None -> None
       }
-    }, {
+    },
+    {
       case input.home_town {
         Some(val) -> Some(#("homeTown", val))
         None -> None
       }
-    }, {
+    },
+    {
       case input.interests {
-        Some(val) -> Some(#("interests", json.array(from: val, of: json.string)))
+        Some(val) ->
+          Some(#("interests", json.array(from: val, of: json.string)))
         None -> None
       }
-    }]
+    },
+  ]
   |> list.filter_map(fn(x) {
     case x {
       Some(val) -> Ok(val)
···
   )
 }
 
-pub fn org_atmosphereconf_profile_decoder() -> decode.Decoder(OrgAtmosphereconfProfile) {
+pub fn org_atmosphereconf_profile_decoder() -> decode.Decoder(
+  OrgAtmosphereconfProfile,
+) {
   use id <- decode.field("id", decode.string)
   use uri <- decode.field("uri", decode.string)
   use cid <- decode.field("cid", decode.string)
   use did <- decode.field("did", decode.string)
-  use actor_handle <- decode.field("actorHandle", decode.optional(decode.string))
-  use display_name <- decode.field("displayName", decode.optional(decode.string))
+  use actor_handle <- decode.field(
+    "actorHandle",
+    decode.optional(decode.string),
+  )
+  use display_name <- decode.field(
+    "displayName",
+    decode.optional(decode.string),
+  )
   use description <- decode.field("description", decode.optional(decode.string))
   use avatar <- decode.field("avatar", decode.optional(blob_decoder()))
-  use home_town <- decode.field("homeTown", decode.optional(community_lexicon_location_hthree_decoder()))
-  use interests <- decode.field("interests", decode.optional(decode.list(decode.string)))
+  use home_town <- decode.field(
+    "homeTown",
+    decode.optional(community_lexicon_location_hthree_decoder()),
+  )
+  use interests <- decode.field(
+    "interests",
+    decode.optional(decode.list(decode.string)),
+  )
   use created_at <- decode.field("createdAt", decode.optional(decode.string))
   use indexed_at <- decode.field("indexedAt", decode.string)
   decode.success(OrgAtmosphereconfProfile(
···
   CommunityLexiconLocationHthree(name: Option(String), value: Option(String))
 }
 
-pub fn community_lexicon_location_hthree_decoder() -> decode.Decoder(CommunityLexiconLocationHthree) {
+pub fn community_lexicon_location_hthree_decoder() -> decode.Decoder(
+  CommunityLexiconLocationHthree,
+) {
   use name <- decode.field("name", decode.optional(decode.string))
   use value <- decode.field("value", decode.optional(decode.string))
   decode.success(CommunityLexiconLocationHthree(name: name, value: value))
···
   )
 }
 
-pub fn update_profile_response_decoder() -> decode.Decoder(UpdateProfileResponse) {
-  use update_org_atmosphereconf_profile <- decode.field("updateOrgAtmosphereconfProfile", org_atmosphereconf_profile_decoder())
+pub fn update_profile_response_decoder() -> decode.Decoder(
+  UpdateProfileResponse,
+) {
+  use update_org_atmosphereconf_profile <- decode.field(
+    "updateOrgAtmosphereconfProfile",
+    org_atmosphereconf_profile_decoder(),
+  )
   decode.success(UpdateProfileResponse(
     update_org_atmosphereconf_profile: update_org_atmosphereconf_profile,
   ))
 }
 
-pub fn update_profile(client: squall.Client, rkey: String, input: OrgAtmosphereconfProfileInput) -> Result(UpdateProfileResponse, String) {
+pub fn update_profile(
+  client: squall.Client,
+  rkey: String,
+  input: OrgAtmosphereconfProfileInput,
+) -> Result(UpdateProfileResponse, String) {
   let query =
     "mutation UpdateProfile($rkey: String!, $input: OrgAtmosphereconfProfileInput!) { updateOrgAtmosphereconfProfile(rkey: $rkey, input: $input) { id uri cid did actorHandle displayName description avatar { ref mimeType size url } homeTown { name value } interests createdAt indexedAt } }"
   let variables =
-    json.object(
-      [
-        #("rkey", json.string(rkey)),
-        #("input", org_atmosphereconf_profile_input_to_json(input)),
-      ],
-    )
+    json.object([
+      #("rkey", json.string(rkey)),
+      #("input", org_atmosphereconf_profile_input_to_json(input)),
+    ])
   let body =
     json.object([#("query", json.string(query)), #("variables", variables)])
   use req <- result.try(

server/src/api/graphql/upload_blob.gleam

···
   decode.success(UploadBlobResponse(upload_blob: upload_blob))
 }
 
-pub fn upload_blob(client: squall.Client, data: String, mime_type: String) -> Result(UploadBlobResponse, String) {
+pub fn upload_blob(
+  client: squall.Client,
+  data: String,
+  mime_type: String,
+) -> Result(UploadBlobResponse, String) {
   let query =
     "mutation UploadBlob($data: String!, $mimeType: String!) { uploadBlob(data: $data, mimeType: $mimeType) { blob { ref mimeType size } } }"
   let variables =
-    json.object(
-      [
-        #("data", json.string(data)),
-        #("mimeType", json.string(mime_type)),
-      ],
-    )
+    json.object([
+      #("data", json.string(data)),
+      #("mimeType", json.string(mime_type)),
+    ])
   let body =
     json.object([#("query", json.string(query)), #("variables", variables)])
   use req <- result.try(

shared/src/shared/profile.gleam

···
   use cid <- decode.field("cid", decode.string)
   use did <- decode.field("did", decode.string)
   use handle <- decode.field("handle", decode.optional(decode.string))
-  use display_name <- decode.field("display_name", decode.optional(decode.string))
+  use display_name <- decode.field(
+    "display_name",
+    decode.optional(decode.string),
+  )
   use description <- decode.field("description", decode.optional(decode.string))
   use avatar_url <- decode.field("avatar_url", decode.optional(decode.string))
   use avatar_blob <- decode.field(
     "avatar_blob",
     decode.optional(avatar_blob_decoder()),
   )
-  use home_town <- decode.field("home_town", decode.optional(home_town_decoder()))
+  use home_town <- decode.field(
+    "home_town",
+    decode.optional(home_town_decoder()),
+  )
   use interests <- decode.field(
     "interests",
     decode.optional(decode.list(decode.string)),