iOS and Android dependency updates and optimizations

.editorconfig

@@ -0,0 +1,18 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.{json,yml,yaml}]
+indent_size = 2
+
+[Makefile]
+indent_style = tab

.gitattributes

@@ -0,0 +1,77 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Source code files
+*.swift text eol=lf
+*.kt text eol=lf
+*.kts text eol=lf
+*.java text eol=lf
+*.go text eol=lf
+*.py text eol=lf
+*.ts text eol=lf
+*.tsx text eol=lf
+*.js text eol=lf
+*.jsx text eol=lf
+*.mjs text eol=lf
+*.cjs text eol=lf
+
+# Configuration files
+*.json text eol=lf
+*.yml text eol=lf
+*.yaml text eol=lf
+*.toml text eol=lf
+*.xml text eol=lf
+*.plist text eol=lf
+*.properties text eol=lf
+*.gradle text eol=lf
+*.md text eol=lf
+
+# Shell scripts
+*.sh text eol=lf
+*.bash text eol=lf
+*.zsh text eol=lf
+
+# Windows batch files
+*.bat text eol=crlf
+*.cmd text eol=crlf
+
+# Binary files
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.webp binary
+*.pdf binary
+*.zip binary
+*.tar binary
+*.gz binary
+*.jar binary
+*.aar binary
+*.apk binary
+*.ipa binary
+*.xcassets binary
+*.ttf binary
+*.otf binary
+*.woff binary
+*.woff2 binary
+*.eot binary
+
+# Xcode files
+*.pbxproj merge=union
+*.xcworkspacedata text eol=lf
+*.xcscheme text eol=lf
+
+# Gradle wrapper
+gradlew text eol=lf
+gradlew.bat text eol=crlf
+gradle-wrapper.jar binary
+
+# Lock files
+*.lock text -diff
+package-lock.json text -diff
+pnpm-lock.yaml text -diff
+
+# Documentation
+LICENSE text eol=lf
+README.md text eol=lf

.gitignore

@@ -9,6 +9,11 @@ local.properties
 # Log/OS Files
 *.log
 .DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+Thumbs.db
 
 # Android Studio generated files and folders
 captures/
@@ -34,3 +39,44 @@ google-services.json
 
 # Android Profiling
 *.hprof
+
+# iOS/Xcode
+ios/build/
+ios/DerivedData/
+ios/*.xcuserstate
+ios/**/xcuserdata/
+ios/**/*.xcuserstate
+*.xccheckout
+*.moved-aside
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+*.hmap
+*.ipa
+*.dSYM.zip
+*.dSYM
+timeline.xctimeline
+playground.xcworkspace
+
+# CocoaPods
+ios/Pods/
+ios/Podfile.lock
+
+# Swift Package Manager
+ios/.swiftpm/
+ios/Package.resolved
+.build/
+
+# fastlane
+fastlane/report.xml
+fastlane/Preview.html
+fastlane/screenshots/**/*.png
+fastlane/test_output
+
+# Code Injection
+iOSInjectionProject/

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    Ascently is a FOSS app meant to help climbers track their sessions, routes/problems, and overall progress.
+    Copyright (C) 2025 Atridad Lahiji
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    Ascently  Copyright (C) 2025  Atridad Lahiji
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

Makefile

@@ -0,0 +1,90 @@
+# Ascently Makefile
+
+.PHONY: help android-lint android-format android-build android-test \
+        ios-lint ios-format ios-build ios-test clean
+
+# Default target
+help:
+	@echo "Ascently Dev Commands"
+	@echo "=============================="
+	@echo ""
+	@echo "Android:"
+	@echo "  make android-lint: Run Detekt static analysis"
+	@echo "  make android-format: Check code formatting with Spotless"
+	@echo "  make android-format-fix: Auto-fix code formatting"
+	@echo "  make android-build: Build debug APK"
+	@echo "  make android-release: Build release APK"
+	@echo "  make android-test: Run unit tests"
+	@echo ""
+	@echo "iOS:"
+	@echo "  make ios-lint: Run SwiftLint"
+	@echo "  make ios-lint-fix: Run SwiftLint with auto-fix"
+	@echo "  make ios-format: Run SwiftFormat (dry-run)"
+	@echo "  make ios-format-fix: Run SwiftFormat with auto-fix"
+	@echo "  make ios-build: Build iOS app"
+	@echo ""
+	@echo "General:"
+	@echo "  make lint: Run linters for both platforms"
+	@echo "  make format: Check formatting for both platforms"
+	@echo "  make clean: Clean build artifacts"
+
+# Android commands
+android-lint:
+	cd android && ./gradlew detekt
+
+android-format:
+	cd android && ./gradlew spotlessCheck
+
+android-format-fix:
+	cd android && ./gradlew spotlessApply
+
+android-build:
+	cd android && ./gradlew assembleDebug
+
+android-release:
+	cd android && ./gradlew assembleRelease
+
+android-test:
+	cd android && ./gradlew test
+
+# iOS commands (requires SwiftLint and SwiftFormat!!!)
+ios-lint:
+	@if command -v swiftlint >/dev/null 2>&1; then \
+		cd ios && swiftlint; \
+	else \
+		echo "SwiftLint not installed. Install with: brew install swiftlint"; \
+	fi
+
+ios-lint-fix:
+	@if command -v swiftlint >/dev/null 2>&1; then \
+		cd ios && swiftlint --fix; \
+	else \
+		echo "SwiftLint not installed. Install with: brew install swiftlint"; \
+	fi
+
+ios-format:
+	@if command -v swiftformat >/dev/null 2>&1; then \
+		cd ios && swiftformat . --lint; \
+	else \
+		echo "SwiftFormat not installed. Install with: brew install swiftformat"; \
+	fi
+
+ios-format-fix:
+	@if command -v swiftformat >/dev/null 2>&1; then \
+		cd ios && swiftformat .; \
+	else \
+		echo "SwiftFormat not installed. Install with: brew install swiftformat"; \
+	fi
+
+ios-build:
+	cd ios && xcodebuild -project Ascently.xcodeproj -scheme Ascently -configuration Debug build
+
+# Combined commands
+lint: android-lint ios-lint
+
+format: android-format ios-format
+
+# Clean
+clean:
+	cd android && ./gradlew clean
+	rm -rf ios/build ios/DerivedData

android/.editorconfig

@@ -0,0 +1,31 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.{kt,kts}]
+indent_size = 4
+max_line_length = 220
+ij_kotlin_code_style_defaults = KOTLIN_OFFICIAL
+ktlint_standard_no-wildcard-imports = disabled
+ktlint_standard_package-name = disabled
+
+[*.{xml,gradle}]
+indent_size = 4
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.properties]
+indent_size = 2
+
+[*.toml]
+indent_size = 4
+
+[Makefile]
+indent_style = tab

android/app/build.gradle.kts

@@ -6,6 +6,8 @@ plugins {
     alias(libs.plugins.kotlin.compose)
     alias(libs.plugins.kotlin.serialization)
     alias(libs.plugins.ksp)
+    alias(libs.plugins.detekt)
+    alias(libs.plugins.spotless)
 }
 
 android {
@@ -16,8 +18,8 @@ android {
         applicationId = "com.atridad.ascently"
         minSdk = 31
         targetSdk = 36
-        versionCode = 4
+        versionCode = 50
-        versionName = "2.3.0"
+        versionName = "2.5.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -26,8 +28,8 @@ android {
         release {
             isMinifyEnabled = true
             proguardFiles(
-                    getDefaultProguardFile("proguard-android-optimize.txt"),
+                getDefaultProguardFile("proguard-android-optimize.txt"),
-                    "proguard-rules.pro"
+                "proguard-rules.pro",
             )
         }
     }
@@ -83,7 +85,7 @@ dependencies {
     implementation(libs.coil.compose)
 
     // Health Connect
-    implementation("androidx.health.connect:connect-client:1.1.0-alpha07")
+    implementation(libs.health.connect)
 
     // Testing
     testImplementation(libs.junit)
@@ -99,6 +101,51 @@ dependencies {
     androidTestImplementation(libs.androidx.ui.test.junit4)
     debugImplementation(libs.androidx.ui.tooling)
     debugImplementation(libs.androidx.ui.test.manifest)
-    debugImplementation(libs.androidx.ui.tooling)
+}
-    debugImplementation(libs.androidx.ui.test.manifest)
+
+// Detekt configuration
+detekt {
+    config.setFrom(files("$rootDir/detekt.yml"))
+    buildUponDefaultConfig = true
+    allRules = false
+    parallel = true
+}
+
+// Spotless configuration for code formatting
+spotless {
+    kotlin {
+        target("**/*.kt")
+        targetExclude("**/build/**/*.kt")
+        ktlint("1.2.1")
+            .editorConfigOverride(
+                mapOf(
+                    "ktlint_standard_no-wildcard-imports" to "disabled",
+                    "ktlint_standard_package-name" to "disabled",
+                    "ktlint_standard_function-naming" to "disabled",
+                    "ktlint_standard_filename" to "disabled",
+                    "ktlint_standard_value-parameter-comment" to "disabled",
+                    "ktlint_standard_comment-wrapping" to "disabled",
+                    "ktlint_standard_multiline-expression-wrapping" to "disabled",
+                    "ktlint_standard_string-template-indent" to "disabled",
+                    "ktlint_standard_property-naming" to "disabled",
+                    "ktlint_standard_class-naming" to "disabled",
+                    "ktlint_standard_backing-property-naming" to "disabled",
+                    "ktlint_standard_function-signature" to "disabled",
+                    "ktlint_standard_parameter-list-wrapping" to "disabled",
+                    "ktlint_standard_max-line-length" to "disabled",
+                    "max_line_length" to "off",
+                ),
+            )
+    }
+    kotlinGradle {
+        target("**/*.kts")
+        targetExclude("**/build/**/*.kts")
+        ktlint("1.2.1")
+            .editorConfigOverride(
+                mapOf(
+                    "ktlint_standard_no-wildcard-imports" to "disabled",
+                    "max_line_length" to "off",
+                ),
+            )
+    }
 }

android/app/proguard-rules.pro

@@ -5,17 +5,61 @@
 # For more details, see
 #   http://developer.android.com/guide/developing/tools/proguard.html
 
+# Preserve line number information for debugging stack traces
+-keepattributes SourceFile,LineNumberTable
+
+# Hide the original source file name
+-renamesourcefileattribute SourceFile
+
+# Keep generic signatures for Kotlin
+-keepattributes Signature
+
+# Keep annotations
+-keepattributes *Annotation*
+
+# Room Database
+-keep class * extends androidx.room.RoomDatabase
+-keep @androidx.room.Entity class *
+-keepclassmembers class * {
+    @androidx.room.* <fields>;
+    @androidx.room.* <methods>;
+}
+
+# Kotlinx Serialization
+-keepattributes *Annotation*, InnerClasses
+-dontnote kotlinx.serialization.AnnotationsKt
+
+-keepclassmembers class kotlinx.serialization.json.** {
+    *** Companion;
+}
+-keepclasseswithmembers class kotlinx.serialization.json.** {
+    kotlinx.serialization.KSerializer serializer(...);
+}
+
+-keep,includedescriptorclasses class com.atridad.ascently.**$$serializer { *; }
+-keepclassmembers class com.atridad.ascently.** {
+    *** Companion;
+}
+-keepclasseswithmembers class com.atridad.ascently.** {
+    kotlinx.serialization.KSerializer serializer(...);
+}
+
+# Keep data classes used for serialization
+-keep class com.atridad.ascently.data.model.** { *; }
+-keep class com.atridad.ascently.data.format.** { *; }
+
+# Coroutines
+-keepnames class kotlinx.coroutines.internal.MainDispatcherFactory {}
+-keepnames class kotlinx.coroutines.CoroutineExceptionHandler {}
+-keepclassmembers class kotlinx.coroutines.** {
+    volatile <fields>;
+}
+
+
+
 # If your project uses WebView with JS, uncomment the following
 # and specify the fully qualified class name to the JavaScript interface
 # class:
 #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
 #   public *;
 #}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile

android/app/src/main/AndroidManifest.xml

@@ -27,6 +27,7 @@
 
     <!-- Permissions for notifications and foreground service -->
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.POST_PROMOTED_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
 

android/app/src/main/java/com/atridad/ascently/MainActivity.kt

@@ -37,9 +37,9 @@ class MainActivity : ComponentActivity() {
             AscentlyTheme {
                 Surface(modifier = Modifier.fillMaxSize()) {
                     AscentlyApp(
-                            shortcutAction = shortcutAction,
+                        shortcutAction = shortcutAction,
-                            lastUsedGymId = lastUsedGymId,
+                        lastUsedGymId = lastUsedGymId,
-                            onShortcutActionProcessed = { clearShortcutAction() }
+                        onShortcutActionProcessed = { clearShortcutAction() },
                     )
                 }
             }

android/app/src/main/java/com/atridad/ascently/data/database/Converters.kt

@@ -76,5 +76,4 @@ class Converters {
     fun toSessionStatus(value: String): SessionStatus {
         return SessionStatus.valueOf(value)
     }
-
 }

android/app/src/main/java/com/atridad/ascently/data/database/OpenClimbDatabase.kt

@@ -11,9 +11,9 @@ import com.atridad.ascently.data.database.dao.*
 import com.atridad.ascently.data.model.*
 
 @Database(
-        entities = [Gym::class, Problem::class, ClimbSession::class, Attempt::class],
+    entities = [Gym::class, Problem::class, ClimbSession::class, Attempt::class],
-        version = 6,
+    version = 6,
-        exportSchema = false
+    exportSchema = false,
 )
 @TypeConverters(Converters::class)
 abstract class AscentlyDatabase : RoomDatabase() {
@@ -27,79 +27,79 @@ abstract class AscentlyDatabase : RoomDatabase() {
         @Volatile private var INSTANCE: AscentlyDatabase? = null
 
         val MIGRATION_4_5 =
-                object : Migration(4, 5) {
+            object : Migration(4, 5) {
-                    override fun migrate(db: SupportSQLiteDatabase) {
+                override fun migrate(db: SupportSQLiteDatabase) {
-                        val cursor = db.query("PRAGMA table_info(climb_sessions)")
+                    val cursor = db.query("PRAGMA table_info(climb_sessions)")
-                        val existingColumns = mutableSetOf<String>()
+                    val existingColumns = mutableSetOf<String>()
 
-                        while (cursor.moveToNext()) {
+                    while (cursor.moveToNext()) {
-                            val columnName = cursor.getString(cursor.getColumnIndexOrThrow("name"))
+                        val columnName = cursor.getString(cursor.getColumnIndexOrThrow("name"))
-                            existingColumns.add(columnName)
+                        existingColumns.add(columnName)
-                        }
+                    }
-                        cursor.close()
+                    cursor.close()
-
-                        if (!existingColumns.contains("startTime")) {
-                            db.execSQL("ALTER TABLE climb_sessions ADD COLUMN startTime TEXT")
-                        }
-                        if (!existingColumns.contains("endTime")) {
-                            db.execSQL("ALTER TABLE climb_sessions ADD COLUMN endTime TEXT")
-                        }
-                        if (!existingColumns.contains("status")) {
-                            db.execSQL(
-                                    "ALTER TABLE climb_sessions ADD COLUMN status TEXT NOT NULL DEFAULT 'COMPLETED'"
-                            )
-                        }
 
+                    if (!existingColumns.contains("startTime")) {
+                        db.execSQL("ALTER TABLE climb_sessions ADD COLUMN startTime TEXT")
+                    }
+                    if (!existingColumns.contains("endTime")) {
+                        db.execSQL("ALTER TABLE climb_sessions ADD COLUMN endTime TEXT")
+                    }
+                    if (!existingColumns.contains("status")) {
                         db.execSQL(
-                                "UPDATE climb_sessions SET startTime = createdAt WHERE startTime IS NULL"
+                            "ALTER TABLE climb_sessions ADD COLUMN status TEXT NOT NULL DEFAULT 'COMPLETED'",
-                        )
-                        db.execSQL(
-                                "UPDATE climb_sessions SET status = 'COMPLETED' WHERE status IS NULL OR status = ''"
                         )
                     }
+
+                    db.execSQL(
+                        "UPDATE climb_sessions SET startTime = createdAt WHERE startTime IS NULL",
+                    )
+                    db.execSQL(
+                        "UPDATE climb_sessions SET status = 'COMPLETED' WHERE status IS NULL OR status = ''",
+                    )
                 }
+            }
 
         val MIGRATION_5_6 =
-                object : Migration(5, 6) {
+            object : Migration(5, 6) {
-                    override fun migrate(db: SupportSQLiteDatabase) {
+                override fun migrate(db: SupportSQLiteDatabase) {
-                        // Add updatedAt column to attempts table
+                    // Add updatedAt column to attempts table
-                        val cursor = db.query("PRAGMA table_info(attempts)")
+                    val cursor = db.query("PRAGMA table_info(attempts)")
-                        val existingColumns = mutableSetOf<String>()
+                    val existingColumns = mutableSetOf<String>()
 
-                        while (cursor.moveToNext()) {
+                    while (cursor.moveToNext()) {
-                            val columnName = cursor.getString(cursor.getColumnIndexOrThrow("name"))
+                        val columnName = cursor.getString(cursor.getColumnIndexOrThrow("name"))
-                            existingColumns.add(columnName)
+                        existingColumns.add(columnName)
-                        }
+                    }
-                        cursor.close()
+                    cursor.close()
 
-                        if (!existingColumns.contains("updatedAt")) {
+                    if (!existingColumns.contains("updatedAt")) {
-                            db.execSQL(
+                        db.execSQL(
-                                    "ALTER TABLE attempts ADD COLUMN updatedAt TEXT NOT NULL DEFAULT ''"
+                            "ALTER TABLE attempts ADD COLUMN updatedAt TEXT NOT NULL DEFAULT ''",
-                            )
+                        )
-                            // Set updatedAt to createdAt for existing records
+                        // Set updatedAt to createdAt for existing records
-                            db.execSQL(
+                        db.execSQL(
-                                    "UPDATE attempts SET updatedAt = createdAt WHERE updatedAt = ''"
+                            "UPDATE attempts SET updatedAt = createdAt WHERE updatedAt = ''",
-                            )
+                        )
-                        }
                     }
                 }
+            }
 
         fun getDatabase(context: Context): AscentlyDatabase {
             return INSTANCE
-                    ?: synchronized(this) {
+                ?: synchronized(this) {
-                        val instance =
+                    val instance =
-                            Room.databaseBuilder(
+                        Room.databaseBuilder(
-                                context.applicationContext,
+                            context.applicationContext,
-                                AscentlyDatabase::class.java,
+                            AscentlyDatabase::class.java,
-                                "ascently_database"
+                            "ascently_database",
-                            )
+                        )
-                                .addMigrations(MIGRATION_4_5, MIGRATION_5_6)
+                            .addMigrations(MIGRATION_4_5, MIGRATION_5_6)
-                                .enableMultiInstanceInvalidation()
+                            .enableMultiInstanceInvalidation()
-                                .fallbackToDestructiveMigration(false)
+                            .fallbackToDestructiveMigration(false)
-                                        .build()
+                            .build()
-                        INSTANCE = instance
+                    INSTANCE = instance
-                        instance
+                    instance
-                    }
+                }
         }
     }
 }

android/app/src/main/java/com/atridad/ascently/data/database/dao/ProblemDao.kt

@@ -11,7 +11,8 @@ interface ProblemDao {
     @Query("SELECT * FROM problems ORDER BY updatedAt DESC")
     fun getAllProblems(): Flow<List<Problem>>
 
-    @Query("SELECT * FROM problems WHERE id = :id") suspend fun getProblemById(id: String): Problem?
+    @Query("SELECT * FROM problems WHERE id = :id")
+    suspend fun getProblemById(id: String): Problem?
 
     @Query("SELECT * FROM problems WHERE gymId = :gymId ORDER BY updatedAt DESC")
     fun getProblemsByGym(gymId: String): Flow<List<Problem>>
@@ -20,7 +21,7 @@ interface ProblemDao {
     fun getProblemsByClimbType(climbType: ClimbType): Flow<List<Problem>>
 
     @Query(
-            "SELECT * FROM problems WHERE gymId = :gymId AND climbType = :climbType ORDER BY updatedAt DESC"
+        "SELECT * FROM problems WHERE gymId = :gymId AND climbType = :climbType ORDER BY updatedAt DESC",
     )
     fun getProblemsByGymAndType(gymId: String, climbType: ClimbType): Flow<List<Problem>>
 
@@ -30,7 +31,8 @@ interface ProblemDao {
     @Query("SELECT * FROM problems WHERE gymId = :gymId AND isActive = 1 ORDER BY updatedAt DESC")
     fun getActiveProblemsByGym(gymId: String): Flow<List<Problem>>
 
-    @Insert(onConflict = OnConflictStrategy.REPLACE) suspend fun insertProblem(problem: Problem)
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertProblem(problem: Problem)
 
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun insertProblems(problems: List<Problem>)
@@ -39,7 +41,8 @@ interface ProblemDao {
 
     @Delete suspend fun deleteProblem(problem: Problem)
 
-    @Query("DELETE FROM problems WHERE id = :id") suspend fun deleteProblemById(id: String)
+    @Query("DELETE FROM problems WHERE id = :id")
+    suspend fun deleteProblemById(id: String)
 
     @Query("SELECT COUNT(*) FROM problems WHERE gymId = :gymId")
     suspend fun getProblemsCountByGym(gymId: String): Int
@@ -48,17 +51,19 @@ interface ProblemDao {
     suspend fun getActiveProblemsCount(): Int
 
     @Query(
-            """
+        """
         SELECT * FROM problems
         WHERE (name LIKE '%' || :searchQuery || '%'
         OR description LIKE '%' || :searchQuery || '%'
         OR location LIKE '%' || :searchQuery || '%')
         ORDER BY updatedAt DESC
-    """
+    """,
     )
     fun searchProblems(searchQuery: String): Flow<List<Problem>>
 
-    @Query("SELECT COUNT(*) FROM problems") suspend fun getProblemsCount(): Int
+    @Query("SELECT COUNT(*) FROM problems")
+    suspend fun getProblemsCount(): Int
 
-    @Query("DELETE FROM problems") suspend fun deleteAllProblems()
+    @Query("DELETE FROM problems")
+    suspend fun deleteAllProblems()
 }

android/app/src/main/java/com/atridad/ascently/data/format/BackupFormat.kt

@@ -6,64 +6,64 @@ import kotlinx.serialization.Serializable
 // Root structure for Ascently backup data
 @Serializable
 data class ClimbDataBackup(
-        val exportedAt: String,
+    val exportedAt: String,
-        val version: String = "2.0",
+    val version: String = "2.0",
-        val formatVersion: String = "2.0",
+    val formatVersion: String = "2.0",
-        val gyms: List<BackupGym>,
+    val gyms: List<BackupGym>,
-        val problems: List<BackupProblem>,
+    val problems: List<BackupProblem>,
-        val sessions: List<BackupClimbSession>,
+    val sessions: List<BackupClimbSession>,
-        val attempts: List<BackupAttempt>,
+    val attempts: List<BackupAttempt>,
-        val deletedItems: List<DeletedItem> = emptyList()
+    val deletedItems: List<DeletedItem> = emptyList(),
 )
 
 @Serializable
 data class DeletedItem(
-        val id: String,
+    val id: String,
-        val type: String, // "gym", "problem", "session", "attempt"
+    val type: String, // "gym", "problem", "session", "attempt"
-        val deletedAt: String
+    val deletedAt: String,
 )
 
 // Platform-neutral gym representation for backup/restore
 @Serializable
 data class BackupGym(
-        val id: String,
+    val id: String,
-        val name: String,
+    val name: String,
-        val location: String? = null,
+    val location: String? = null,
-        val supportedClimbTypes: List<ClimbType>,
+    val supportedClimbTypes: List<ClimbType>,
-        val difficultySystems: List<DifficultySystem>,
+    val difficultySystems: List<DifficultySystem>,
-        @kotlinx.serialization.SerialName("customDifficultyGrades")
+    @kotlinx.serialization.SerialName("customDifficultyGrades")
-        val customDifficultyGrades: List<String>? = null,
+    val customDifficultyGrades: List<String>? = null,
-        val notes: String? = null,
+    val notes: String? = null,
-        val createdAt: String,
+    val createdAt: String,
-        val updatedAt: String
+    val updatedAt: String,
 ) {
     companion object {
         fun fromGym(gym: Gym): BackupGym {
             return BackupGym(
-                    id = gym.id,
+                id = gym.id,
-                    name = gym.name,
+                name = gym.name,
-                    location = gym.location,
+                location = gym.location,
-                    supportedClimbTypes = gym.supportedClimbTypes,
+                supportedClimbTypes = gym.supportedClimbTypes,
-                    difficultySystems = gym.difficultySystems,
+                difficultySystems = gym.difficultySystems,
-                    customDifficultyGrades = gym.customDifficultyGrades.ifEmpty { null },
+                customDifficultyGrades = gym.customDifficultyGrades.ifEmpty { null },
-                    notes = gym.notes,
+                notes = gym.notes,
-                    createdAt = gym.createdAt,
+                createdAt = gym.createdAt,
-                    updatedAt = gym.updatedAt
+                updatedAt = gym.updatedAt,
             )
         }
     }
 
     fun toGym(): Gym {
         return Gym(
-                id = id,
+            id = id,
-                name = name,
+            name = name,
-                location = location,
+            location = location,
-                supportedClimbTypes = supportedClimbTypes,
+            supportedClimbTypes = supportedClimbTypes,
-                difficultySystems = difficultySystems,
+            difficultySystems = difficultySystems,
-                customDifficultyGrades = customDifficultyGrades ?: emptyList(),
+            customDifficultyGrades = customDifficultyGrades ?: emptyList(),
-                notes = notes,
+            notes = notes,
-                createdAt = createdAt,
+            createdAt = createdAt,
-                updatedAt = updatedAt
+            updatedAt = updatedAt,
         )
     }
 }
@@ -71,60 +71,63 @@ data class BackupGym(
 // Platform-neutral problem representation for backup/restore
 @Serializable
 data class BackupProblem(
-        val id: String,
+    val id: String,
-        val gymId: String,
+    val gymId: String,
-        val name: String? = null,
+    val name: String? = null,
-        val description: String? = null,
+    val description: String? = null,
-        val climbType: ClimbType,
+    val climbType: ClimbType,
-        val difficulty: DifficultyGrade,
+    val difficulty: DifficultyGrade,
-        val tags: List<String>? = null,
+    val tags: List<String>? = null,
-        val location: String? = null,
+    val location: String? = null,
-        val imagePaths: List<String>? = null,
+    val imagePaths: List<String>? = null,
-        val isActive: Boolean = true,
+    val isActive: Boolean = true,
-        val dateSet: String? = null,
+    val dateSet: String? = null,
-        val notes: String? = null,
+    val notes: String? = null,
-        val createdAt: String,
+    val createdAt: String,
-        val updatedAt: String
+    val updatedAt: String,
 ) {
     companion object {
         fun fromProblem(problem: Problem): BackupProblem {
             return BackupProblem(
-                    id = problem.id,
+                id = problem.id,
-                    gymId = problem.gymId,
+                gymId = problem.gymId,
-                    name = problem.name,
+                name = problem.name,
-                    description = problem.description,
+                description = problem.description,
-                    climbType = problem.climbType,
+                climbType = problem.climbType,
-                    difficulty = problem.difficulty,
+                difficulty = problem.difficulty,
-                    tags = problem.tags,
+                tags = problem.tags,
-                    location = problem.location,
+                location = problem.location,
-                    imagePaths =
+                imagePaths =
-                            if (problem.imagePaths.isEmpty()) null
+                if (problem.imagePaths.isEmpty()) {
-                            else problem.imagePaths.map { path -> path.substringAfterLast('/') },
+                    null
-                    isActive = problem.isActive,
+                } else {
-                    dateSet = problem.dateSet,
+                    problem.imagePaths.map { path -> path.substringAfterLast('/') }
-                    notes = problem.notes,
+                },
-                    createdAt = problem.createdAt,
+                isActive = problem.isActive,
-                    updatedAt = problem.updatedAt
+                dateSet = problem.dateSet,
+                notes = problem.notes,
+                createdAt = problem.createdAt,
+                updatedAt = problem.updatedAt,
             )
         }
     }
 
     fun toProblem(): Problem {
         return Problem(
-                id = id,
+            id = id,
-                gymId = gymId,
+            gymId = gymId,
-                name = name,
+            name = name,
-                description = description,
+            description = description,
-                climbType = climbType,
+            climbType = climbType,
-                difficulty = difficulty,
+            difficulty = difficulty,
-                tags = tags ?: emptyList(),
+            tags = tags ?: emptyList(),
-                location = location,
+            location = location,
-                imagePaths = imagePaths ?: emptyList(),
+            imagePaths = imagePaths ?: emptyList(),
-                isActive = isActive,
+            isActive = isActive,
-                dateSet = dateSet,
+            dateSet = dateSet,
-                notes = notes,
+            notes = notes,
-                createdAt = createdAt,
+            createdAt = createdAt,
-                updatedAt = updatedAt
+            updatedAt = updatedAt,
         )
     }
 
@@ -136,46 +139,46 @@ data class BackupProblem(
 // Platform-neutral climb session representation for backup/restore
 @Serializable
 data class BackupClimbSession(
-        val id: String,
+    val id: String,
-        val gymId: String,
+    val gymId: String,
-        val date: String,
+    val date: String,
-        val startTime: String? = null,
+    val startTime: String? = null,
-        val endTime: String? = null,
+    val endTime: String? = null,
-        val duration: Long? = null,
+    val duration: Long? = null,
-        val status: SessionStatus,
+    val status: SessionStatus,
-        val notes: String? = null,
+    val notes: String? = null,
-        val createdAt: String,
+    val createdAt: String,
-        val updatedAt: String
+    val updatedAt: String,
 ) {
     companion object {
         fun fromClimbSession(session: ClimbSession): BackupClimbSession {
             return BackupClimbSession(
-                    id = session.id,
+                id = session.id,
-                    gymId = session.gymId,
+                gymId = session.gymId,
-                    date = session.date,
+                date = session.date,
-                    startTime = session.startTime,
+                startTime = session.startTime,
-                    endTime = session.endTime,
+                endTime = session.endTime,
-                    duration = session.duration,
+                duration = session.duration,
-                    status = session.status,
+                status = session.status,
-                    notes = session.notes,
+                notes = session.notes,
-                    createdAt = session.createdAt,
+                createdAt = session.createdAt,
-                    updatedAt = session.updatedAt
+                updatedAt = session.updatedAt,
             )
         }
     }
 
     fun toClimbSession(): ClimbSession {
         return ClimbSession(
-                id = id,
+            id = id,
-                gymId = gymId,
+            gymId = gymId,
-                date = date,
+            date = date,
-                startTime = startTime,
+            startTime = startTime,
-                endTime = endTime,
+            endTime = endTime,
-                duration = duration,
+            duration = duration,
-                status = status,
+            status = status,
-                notes = notes,
+            notes = notes,
-                createdAt = createdAt,
+            createdAt = createdAt,
-                updatedAt = updatedAt
+            updatedAt = updatedAt,
         )
     }
 }
@@ -183,49 +186,49 @@ data class BackupClimbSession(
 // Platform-neutral attempt representation for backup/restore
 @Serializable
 data class BackupAttempt(
-        val id: String,
+    val id: String,
-        val sessionId: String,
+    val sessionId: String,
-        val problemId: String,
+    val problemId: String,
-        val result: AttemptResult,
+    val result: AttemptResult,
-        val highestHold: String? = null,
+    val highestHold: String? = null,
-        val notes: String? = null,
+    val notes: String? = null,
-        val duration: Long? = null,
+    val duration: Long? = null,
-        val restTime: Long? = null,
+    val restTime: Long? = null,
-        val timestamp: String,
+    val timestamp: String,
-        val createdAt: String,
+    val createdAt: String,
-        val updatedAt: String? = null
+    val updatedAt: String? = null,
 ) {
     companion object {
         fun fromAttempt(attempt: Attempt): BackupAttempt {
             return BackupAttempt(
-                    id = attempt.id,
+                id = attempt.id,
-                    sessionId = attempt.sessionId,
+                sessionId = attempt.sessionId,
-                    problemId = attempt.problemId,
+                problemId = attempt.problemId,
-                    result = attempt.result,
+                result = attempt.result,
-                    highestHold = attempt.highestHold,
+                highestHold = attempt.highestHold,
-                    notes = attempt.notes,
+                notes = attempt.notes,
-                    duration = attempt.duration,
+                duration = attempt.duration,
-                    restTime = attempt.restTime,
+                restTime = attempt.restTime,
-                    timestamp = attempt.timestamp,
+                timestamp = attempt.timestamp,
-                    createdAt = attempt.createdAt,
+                createdAt = attempt.createdAt,
-                    updatedAt = attempt.updatedAt
+                updatedAt = attempt.updatedAt,
             )
         }
     }
 
     fun toAttempt(): Attempt {
         return Attempt(
-                id = id,
+            id = id,
-                sessionId = sessionId,
+            sessionId = sessionId,
-                problemId = problemId,
+            problemId = problemId,
-                result = result,
+            result = result,
-                highestHold = highestHold,
+            highestHold = highestHold,
-                notes = notes,
+            notes = notes,
-                duration = duration,
+            duration = duration,
-                restTime = restTime,
+            restTime = restTime,
-                timestamp = timestamp,
+            timestamp = timestamp,
-                createdAt = createdAt,
+            createdAt = createdAt,
-                updatedAt = updatedAt ?: createdAt
+            updatedAt = updatedAt ?: createdAt,
         )
     }
 }

android/app/src/main/java/com/atridad/ascently/data/health/HealthConnectStub.kt

@@ -3,7 +3,6 @@ package com.atridad.ascently.data.health
 import android.annotation.SuppressLint
 import android.content.Context
 import android.content.SharedPreferences
-import com.atridad.ascently.utils.AppLogger
 import androidx.activity.result.contract.ActivityResultContract
 import androidx.health.connect.client.HealthConnectClient
 import androidx.health.connect.client.PermissionController
@@ -11,17 +10,20 @@ import androidx.health.connect.client.permission.HealthPermission
 import androidx.health.connect.client.records.ExerciseSessionRecord
 import androidx.health.connect.client.records.HeartRateRecord
 import androidx.health.connect.client.records.TotalCaloriesBurnedRecord
+
 import androidx.health.connect.client.units.Energy
 import com.atridad.ascently.data.model.ClimbSession
 import com.atridad.ascently.data.model.SessionStatus
+import com.atridad.ascently.utils.AppLogger
 import com.atridad.ascently.utils.DateFormatUtils
-import java.time.Duration
-import java.time.Instant
-import java.time.ZoneOffset
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.flow
+import java.time.Duration
+import java.time.Instant
+import java.time.ZoneOffset
+import androidx.core.content.edit
 
 /**
  * Health Connect manager for Ascently that syncs climbing sessions to Samsung Health, Google Fit,
@@ -52,7 +54,7 @@ class HealthConnectManager(private val context: Context) {
                 HealthPermission.getReadPermission(HeartRateRecord::class),
                 HealthPermission.getWritePermission(HeartRateRecord::class),
                 HealthPermission.getReadPermission(TotalCaloriesBurnedRecord::class),
-                HealthPermission.getWritePermission(TotalCaloriesBurnedRecord::class)
+                HealthPermission.getWritePermission(TotalCaloriesBurnedRecord::class),
             )
     }
 
@@ -127,8 +129,9 @@ class HealthConnectManager(private val context: Context) {
 
     suspend fun isReady(): Boolean {
         return try {
-            if (!_isEnabled.value || !_isCompatible.value || healthConnectClient == null)
+            if (!_isEnabled.value || !_isCompatible.value || healthConnectClient == null) {
                 return false
+            }
 
             val isAvailable =
                 HealthConnectClient.getSdkStatus(context) == HealthConnectClient.SDK_AVAILABLE
@@ -157,18 +160,18 @@ class HealthConnectManager(private val context: Context) {
     suspend fun syncCompletedSession(
         session: ClimbSession,
         gymName: String,
-        attemptCount: Int = 0
+        attemptCount: Int = 0,
     ): Result<Unit> {
         return try {
             if (!isReady() || !_autoSync.value) {
                 return Result.failure(
-                    IllegalStateException("Health Connect not ready or auto-sync disabled")
+                    IllegalStateException("Health Connect not ready or auto-sync disabled"),
                 )
             }
 
             if (session.status != SessionStatus.COMPLETED) {
                 return Result.failure(
-                    IllegalArgumentException("Only completed sessions can be synced")
+                    IllegalArgumentException("Only completed sessions can be synced"),
                 )
             }
 
@@ -177,7 +180,7 @@ class HealthConnectManager(private val context: Context) {
 
             if (startTime == null || endTime == null) {
                 return Result.failure(
-                    IllegalArgumentException("Session must have valid start and end times")
+                    IllegalArgumentException("Session must have valid start and end times"),
                 )
             }
 
@@ -190,12 +193,13 @@ class HealthConnectManager(private val context: Context) {
                     ExerciseSessionRecord(
                         startTime = startTime,
                         startZoneOffset =
-                            ZoneOffset.systemDefault().rules.getOffset(startTime),
+                        ZoneOffset.systemDefault().rules.getOffset(startTime),
                         endTime = endTime,
                         endZoneOffset = ZoneOffset.systemDefault().rules.getOffset(endTime),
                         exerciseType =
-                            ExerciseSessionRecord.EXERCISE_TYPE_STRENGTH_TRAINING,
+                        ExerciseSessionRecord.EXERCISE_TYPE_STRENGTH_TRAINING,
-                        title = "Rock Climbing at $gymName"
+                        title = "Rock Climbing at $gymName",
+                        metadata = androidx.health.connect.client.records.metadata.Metadata.manualEntry(),
                     )
                 records.add(exerciseSession)
             } catch (e: Exception) {
@@ -211,11 +215,12 @@ class HealthConnectManager(private val context: Context) {
                         TotalCaloriesBurnedRecord(
                             startTime = startTime,
                             startZoneOffset =
-                                ZoneOffset.systemDefault().rules.getOffset(startTime),
+                            ZoneOffset.systemDefault().rules.getOffset(startTime),
                             endTime = endTime,
                             endZoneOffset =
-                                ZoneOffset.systemDefault().rules.getOffset(endTime),
+                            ZoneOffset.systemDefault().rules.getOffset(endTime),
-                            energy = Energy.calories(estimatedCalories)
+                            energy = Energy.calories(estimatedCalories),
+                            metadata = androidx.health.connect.client.records.metadata.Metadata.manualEntry(),
                         )
                     records.add(caloriesRecord)
                 }
@@ -238,9 +243,9 @@ class HealthConnectManager(private val context: Context) {
                 }
 
                 preferences
-                    .edit()
+                    .edit {
-                    .putString("last_sync_success", DateFormatUtils.nowISO8601())
+                        putString("last_sync_success", DateFormatUtils.nowISO8601())
-                    .apply()
+                    }
             } else {
                 val reason =
                     when {
@@ -262,7 +267,7 @@ class HealthConnectManager(private val context: Context) {
     suspend fun autoSyncCompletedSession(
         session: ClimbSession,
         gymName: String,
-        attemptCount: Int = 0
+        attemptCount: Int = 0,
     ): Result<Unit> {
         return if (_autoSync.value && isReady() && session.status == SessionStatus.COMPLETED) {
             AppLogger.d(TAG) { "Auto-syncing completed session '${session.id}' to Health Connect..." }
@@ -295,7 +300,7 @@ class HealthConnectManager(private val context: Context) {
     private fun createHeartRateRecord(
         startTime: Instant,
         endTime: Instant,
-        attemptCount: Int
+        attemptCount: Int,
     ): HeartRateRecord? {
         return try {
             val samples = mutableListOf<HeartRateRecord.Sample>()
@@ -324,7 +329,8 @@ class HealthConnectManager(private val context: Context) {
                 startZoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime),
                 endTime = endTime,
                 endZoneOffset = ZoneOffset.systemDefault().rules.getOffset(endTime),
-                samples = samples
+                samples = samples,
+                metadata = androidx.health.connect.client.records.metadata.Metadata.manualEntry(),
             )
         } catch (e: Exception) {
             AppLogger.e(TAG, e) { "Error creating heart rate record" }

android/app/src/main/java/com/atridad/ascently/data/model/Attempt.kt

@@ -1,5 +1,6 @@
 package com.atridad.ascently.data.model
 
+import androidx.compose.runtime.Immutable
 import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.Index
@@ -12,65 +13,67 @@ enum class AttemptResult {
     SUCCESS,
     FALL,
     NO_PROGRESS,
-    FLASH
+    FLASH,
 }
 
 @Entity(
-        tableName = "attempts",
+    tableName = "attempts",
-        foreignKeys =
+    foreignKeys =
-                [
+    [
-                        ForeignKey(
+        ForeignKey(
-                                entity = ClimbSession::class,
+            entity = ClimbSession::class,
-                                parentColumns = ["id"],
+            parentColumns = ["id"],
-                                childColumns = ["sessionId"],
+            childColumns = ["sessionId"],
-                                onDelete = ForeignKey.CASCADE
+            onDelete = ForeignKey.CASCADE,
-                        ),
+        ),
-                        ForeignKey(
+        ForeignKey(
-                                entity = Problem::class,
+            entity = Problem::class,
-                                parentColumns = ["id"],
+            parentColumns = ["id"],
-                                childColumns = ["problemId"],
+            childColumns = ["problemId"],
-                                onDelete = ForeignKey.CASCADE
+            onDelete = ForeignKey.CASCADE,
-                        )],
+        ),
-        indices = [Index(value = ["sessionId"]), Index(value = ["problemId"])]
+    ],
+    indices = [Index(value = ["sessionId"]), Index(value = ["problemId"])],
 )
+@Immutable
 @Serializable
 data class Attempt(
-        @PrimaryKey val id: String,
+    @PrimaryKey val id: String,
-        val sessionId: String,
+    val sessionId: String,
-        val problemId: String,
+    val problemId: String,
-        val result: AttemptResult,
+    val result: AttemptResult,
-        val highestHold: String? = null,
+    val highestHold: String? = null,
-        val notes: String? = null,
+    val notes: String? = null,
-        val duration: Long? = null,
+    val duration: Long? = null,
-        val restTime: Long? = null,
+    val restTime: Long? = null,
-        val timestamp: String,
+    val timestamp: String,
-        val createdAt: String,
+    val createdAt: String,
-        val updatedAt: String
+    val updatedAt: String,
 ) {
     companion object {
         fun create(
-                sessionId: String,
+            sessionId: String,
-                problemId: String,
+            problemId: String,
-                result: AttemptResult,
+            result: AttemptResult,
-                highestHold: String? = null,
+            highestHold: String? = null,
-                notes: String? = null,
+            notes: String? = null,
-                duration: Long? = null,
+            duration: Long? = null,
-                restTime: Long? = null,
+            restTime: Long? = null,
-                timestamp: String = DateFormatUtils.nowISO8601()
+            timestamp: String = DateFormatUtils.nowISO8601(),
         ): Attempt {
             val now = DateFormatUtils.nowISO8601()
             return Attempt(
-                    id = java.util.UUID.randomUUID().toString(),
+                id = java.util.UUID.randomUUID().toString(),
-                    sessionId = sessionId,
+                sessionId = sessionId,
-                    problemId = problemId,
+                problemId = problemId,
-                    result = result,
+                result = result,
-                    highestHold = highestHold,
+                highestHold = highestHold,
-                    notes = notes,
+                notes = notes,
-                    duration = duration,
+                duration = duration,
-                    restTime = restTime,
+                restTime = restTime,
-                    timestamp = timestamp,
+                timestamp = timestamp,
-                    createdAt = now,
+                createdAt = now,
-                    updatedAt = now
+                updatedAt = now,
             )
         }
     }

android/app/src/main/java/com/atridad/ascently/data/model/ClimbSession.kt

@@ -1,5 +1,6 @@
 package com.atridad.ascently.data.model
 
+import androidx.compose.runtime.Immutable
 import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.Index
@@ -11,69 +12,75 @@ import kotlinx.serialization.Serializable
 enum class SessionStatus {
     ACTIVE,
     COMPLETED,
-    PAUSED
+    PAUSED,
 }
 
 @Entity(
-        tableName = "climb_sessions",
+    tableName = "climb_sessions",
-        foreignKeys =
+    foreignKeys =
-                [
+    [
-                        ForeignKey(
+        ForeignKey(
-                                entity = Gym::class,
+            entity = Gym::class,
-                                parentColumns = ["id"],
+            parentColumns = ["id"],
-                                childColumns = ["gymId"],
+            childColumns = ["gymId"],
-                                onDelete = ForeignKey.CASCADE
+            onDelete = ForeignKey.CASCADE,
-                        )],
+        ),
-        indices = [Index(value = ["gymId"])]
+    ],
+    indices = [Index(value = ["gymId"])],
 )
+@Immutable
 @Serializable
 data class ClimbSession(
-        @PrimaryKey val id: String,
+    @PrimaryKey val id: String,
-        val gymId: String,
+    val gymId: String,
-        val date: String,
+    val date: String,
-        val startTime: String? = null,
+    val startTime: String? = null,
-        val endTime: String? = null,
+    val endTime: String? = null,
-        val duration: Long? = null,
+    val duration: Long? = null,
-        val status: SessionStatus = SessionStatus.ACTIVE,
+    val status: SessionStatus = SessionStatus.ACTIVE,
-        val notes: String? = null,
+    val notes: String? = null,
-        val createdAt: String,
+    val createdAt: String,
-        val updatedAt: String
+    val updatedAt: String,
 ) {
     companion object {
         fun create(gymId: String, notes: String? = null): ClimbSession {
             val now = DateFormatUtils.nowISO8601()
             return ClimbSession(
-                    id = java.util.UUID.randomUUID().toString(),
+                id = java.util.UUID.randomUUID().toString(),
-                    gymId = gymId,
+                gymId = gymId,
-                    date = now,
+                date = now,
-                    startTime = now,
+                startTime = now,
-                    status = SessionStatus.ACTIVE,
+                status = SessionStatus.ACTIVE,
-                    notes = notes,
+                notes = notes,
-                    createdAt = now,
+                createdAt = now,
-                    updatedAt = now
+                updatedAt = now,
             )
         }
 
         fun ClimbSession.complete(): ClimbSession {
             val endTime = DateFormatUtils.nowISO8601()
             val durationMinutes =
-                    if (startTime != null) {
+                if (startTime != null) {
-                        try {
+                    try {
-                            val start = DateFormatUtils.parseISO8601(startTime)
+                        val start = DateFormatUtils.parseISO8601(startTime)
-                            val end = DateFormatUtils.parseISO8601(endTime)
+                        val end = DateFormatUtils.parseISO8601(endTime)
-                            if (start != null && end != null) {
+                        if (start != null && end != null) {
-                                java.time.Duration.between(start, end).toMinutes()
+                            java.time.Duration.between(start, end).toMinutes()
-                            } else null
+                        } else {
-                        } catch (_: Exception) {
                             null
                         }
-                    } else null
+                    } catch (_: Exception) {
+                        null
+                    }
+                } else {
+                    null
+                }
 
             return this.copy(
-                    endTime = endTime,
+                endTime = endTime,
-                    duration = durationMinutes,
+                duration = durationMinutes,
-                    status = SessionStatus.COMPLETED,
+                status = SessionStatus.COMPLETED,
-                    updatedAt = DateFormatUtils.nowISO8601()
+                updatedAt = DateFormatUtils.nowISO8601(),
             )
         }
     }

android/app/src/main/java/com/atridad/ascently/data/model/ClimbType.kt

@@ -5,12 +5,13 @@ import kotlinx.serialization.Serializable
 @Serializable
 enum class ClimbType {
     ROPE,
-    BOULDER;
+    BOULDER,
+    ;
 
     val displayName: String
         get() =
-                when (this) {
+            when (this) {
-                    ROPE -> "Rope"
+                ROPE -> "Rope"
-                    BOULDER -> "Bouldering"
+                BOULDER -> "Bouldering"
-                }
+            }
 }

android/app/src/main/java/com/atridad/ascently/data/model/DifficultySystem.kt

@@ -10,132 +10,133 @@ enum class DifficultySystem {
 
     // Rope
     YDS,
-    CUSTOM;
+    CUSTOM,
+    ;
 
     val displayName: String
         get() =
-                when (this) {
+            when (this) {
-                    V_SCALE -> "V Scale"
+                V_SCALE -> "V Scale"
-                    FONT -> "Font Scale"
+                FONT -> "Font Scale"
-                    YDS -> "YDS (Yosemite)"
+                YDS -> "YDS (Yosemite)"
-                    CUSTOM -> "Custom"
+                CUSTOM -> "Custom"
-                }
+            }
 
     val isBoulderingSystem: Boolean
         get() =
-                when (this) {
+            when (this) {
-                    V_SCALE, FONT -> true
+                V_SCALE, FONT -> true
-                    YDS -> false
+                YDS -> false
-                    CUSTOM -> true
+                CUSTOM -> true
-                }
+            }
 
     val isRopeSystem: Boolean
         get() =
-                when (this) {
+            when (this) {
-                    YDS -> true
+                YDS -> true
-                    V_SCALE, FONT -> false
+                V_SCALE, FONT -> false
-                    CUSTOM -> true
+                CUSTOM -> true
-                }
+            }
 
     val availableGrades: List<String>
         get() =
-                when (this) {
+            when (this) {
-                    V_SCALE ->
+                V_SCALE ->
-                            listOf(
+                    listOf(
-                                    "VB",
+                        "VB",
-                                    "V0",
+                        "V0",
-                                    "V1",
+                        "V1",
-                                    "V2",
+                        "V2",
-                                    "V3",
+                        "V3",
-                                    "V4",
+                        "V4",
-                                    "V5",
+                        "V5",
-                                    "V6",
+                        "V6",
-                                    "V7",
+                        "V7",
-                                    "V8",
+                        "V8",
-                                    "V9",
+                        "V9",
-                                    "V10",
+                        "V10",
-                                    "V11",
+                        "V11",
-                                    "V12",
+                        "V12",
-                                    "V13",
+                        "V13",
-                                    "V14",
+                        "V14",
-                                    "V15",
+                        "V15",
-                                    "V16",
+                        "V16",
-                                    "V17"
+                        "V17",
-                            )
+                    )
-                    FONT ->
+                FONT ->
-                            listOf(
+                    listOf(
-                                    "3",
+                        "3",
-                                    "4A",
+                        "4A",
-                                    "4B",
+                        "4B",
-                                    "4C",
+                        "4C",
-                                    "5A",
+                        "5A",
-                                    "5B",
+                        "5B",
-                                    "5C",
+                        "5C",
-                                    "6A",
+                        "6A",
-                                    "6A+",
+                        "6A+",
-                                    "6B",
+                        "6B",
-                                    "6B+",
+                        "6B+",
-                                    "6C",
+                        "6C",
-                                    "6C+",
+                        "6C+",
-                                    "7A",
+                        "7A",
-                                    "7A+",
+                        "7A+",
-                                    "7B",
+                        "7B",
-                                    "7B+",
+                        "7B+",
-                                    "7C",
+                        "7C",
-                                    "7C+",
+                        "7C+",
-                                    "8A",
+                        "8A",
-                                    "8A+",
+                        "8A+",
-                                    "8B",
+                        "8B",
-                                    "8B+",
+                        "8B+",
-                                    "8C",
+                        "8C",
-                                    "8C+"
+                        "8C+",
-                            )
+                    )
-                    YDS ->
+                YDS ->
-                            listOf(
+                    listOf(
-                                    "5.0",
+                        "5.0",
-                                    "5.1",
+                        "5.1",
-                                    "5.2",
+                        "5.2",
-                                    "5.3",
+                        "5.3",
-                                    "5.4",
+                        "5.4",
-                                    "5.5",
+                        "5.5",
-                                    "5.6",
+                        "5.6",
-                                    "5.7",
+                        "5.7",
-                                    "5.8",
+                        "5.8",
-                                    "5.9",
+                        "5.9",
-                                    "5.10a",
+                        "5.10a",
-                                    "5.10b",
+                        "5.10b",
-                                    "5.10c",
+                        "5.10c",
-                                    "5.10d",
+                        "5.10d",
-                                    "5.11a",
+                        "5.11a",
-                                    "5.11b",
+                        "5.11b",
-                                    "5.11c",
+                        "5.11c",
-                                    "5.11d",
+                        "5.11d",
-                                    "5.12a",
+                        "5.12a",
-                                    "5.12b",
+                        "5.12b",
-                                    "5.12c",
+                        "5.12c",
-                                    "5.12d",
+                        "5.12d",
-                                    "5.13a",
+                        "5.13a",
-                                    "5.13b",
+                        "5.13b",
-                                    "5.13c",
+                        "5.13c",
-                                    "5.13d",
+                        "5.13d",
-                                    "5.14a",
+                        "5.14a",
-                                    "5.14b",
+                        "5.14b",
-                                    "5.14c",
+                        "5.14c",
-                                    "5.14d",
+                        "5.14d",
-                                    "5.15a",
+                        "5.15a",
-                                    "5.15b",
+                        "5.15b",
-                                    "5.15c",
+                        "5.15c",
-                                    "5.15d"
+                        "5.15d",
-                            )
+                    )
-                    CUSTOM -> emptyList()
+                CUSTOM -> emptyList()
-                }
+            }
 
     companion object {
         fun systemsForClimbType(climbType: ClimbType): List<DifficultySystem> =
-                when (climbType) {
+            when (climbType) {
-                    ClimbType.BOULDER -> entries.filter { it.isBoulderingSystem }
+                ClimbType.BOULDER -> entries.filter { it.isBoulderingSystem }
-                    ClimbType.ROPE -> entries.filter { it.isRopeSystem }
+                ClimbType.ROPE -> entries.filter { it.isRopeSystem }
-                }
+            }
     }
 }
 
@@ -143,8 +144,8 @@ enum class DifficultySystem {
 data class DifficultyGrade(val system: DifficultySystem, val grade: String, val numericValue: Int) {
 
     constructor(
-            system: DifficultySystem,
+        system: DifficultySystem,
-            grade: String
+        grade: String,
     ) : this(system = system, grade = grade, numericValue = calculateNumericValue(system, grade))
 
     companion object {
@@ -155,79 +156,80 @@ data class DifficultyGrade(val system: DifficultySystem, val grade: String, val
                 }
                 DifficultySystem.FONT -> {
                     val fontMapping: Map<String, Int> =
-                            mapOf(
+                        mapOf(
-                                    "3" to 3,
+                            "3" to 3,
-                                    "4A" to 4,
+                            "4A" to 4,
-                                    "4B" to 5,
+                            "4B" to 5,
-                                    "4C" to 6,
+                            "4C" to 6,
-                                    "5A" to 7,
+                            "5A" to 7,
-                                    "5B" to 8,
+                            "5B" to 8,
-                                    "5C" to 9,
+                            "5C" to 9,
-                                    "6A" to 10,
+                            "6A" to 10,
-                                    "6A+" to 11,
+                            "6A+" to 11,
-                                    "6B" to 12,
+                            "6B" to 12,
-                                    "6B+" to 13,
+                            "6B+" to 13,
-                                    "6C" to 14,
+                            "6C" to 14,
-                                    "6C+" to 15,
+                            "6C+" to 15,
-                                    "7A" to 16,
+                            "7A" to 16,
-                                    "7A+" to 17,
+                            "7A+" to 17,
-                                    "7B" to 18,
+                            "7B" to 18,
-                                    "7B+" to 19,
+                            "7B+" to 19,
-                                    "7C" to 20,
+                            "7C" to 20,
-                                    "7C+" to 21,
+                            "7C+" to 21,
-                                    "8A" to 22,
+                            "8A" to 22,
-                                    "8A+" to 23,
+                            "8A+" to 23,
-                                    "8B" to 24,
+                            "8B" to 24,
-                                    "8B+" to 25,
+                            "8B+" to 25,
-                                    "8C" to 26,
+                            "8C" to 26,
-                                    "8C+" to 27
+                            "8C+" to 27,
-                            )
+                        )
                     fontMapping[grade] ?: 0
                 }
                 DifficultySystem.YDS -> {
                     val ydsMapping: Map<String, Int> =
-                            mapOf(
+                        mapOf(
-                                    "5.0" to 50,
+                            "5.0" to 50,
-                                    "5.1" to 51,
+                            "5.1" to 51,
-                                    "5.2" to 52,
+                            "5.2" to 52,
-                                    "5.3" to 53,
+                            "5.3" to 53,
-                                    "5.4" to 54,
+                            "5.4" to 54,
-                                    "5.5" to 55,
+                            "5.5" to 55,
-                                    "5.6" to 56,
+                            "5.6" to 56,
-                                    "5.7" to 57,
+                            "5.7" to 57,
-                                    "5.8" to 58,
+                            "5.8" to 58,
-                                    "5.9" to 59,
+                            "5.9" to 59,
-                                    "5.10a" to 60,
+                            "5.10a" to 60,
-                                    "5.10b" to 61,
+                            "5.10b" to 61,
-                                    "5.10c" to 62,
+                            "5.10c" to 62,
-                                    "5.10d" to 63,
+                            "5.10d" to 63,
-                                    "5.11a" to 64,
+                            "5.11a" to 64,
-                                    "5.11b" to 65,
+                            "5.11b" to 65,
-                                    "5.11c" to 66,
+                            "5.11c" to 66,
-                                    "5.11d" to 67,
+                            "5.11d" to 67,
-                                    "5.12a" to 68,
+                            "5.12a" to 68,
-                                    "5.12b" to 69,
+                            "5.12b" to 69,
-                                    "5.12c" to 70,
+                            "5.12c" to 70,
-                                    "5.12d" to 71,
+                            "5.12d" to 71,
-                                    "5.13a" to 72,
+                            "5.13a" to 72,
-                                    "5.13b" to 73,
+                            "5.13b" to 73,
-                                    "5.13c" to 74,
+                            "5.13c" to 74,
-                                    "5.13d" to 75,
+                            "5.13d" to 75,
-                                    "5.14a" to 76,
+                            "5.14a" to 76,
-                                    "5.14b" to 77,
+                            "5.14b" to 77,
-                                    "5.14c" to 78,
+                            "5.14c" to 78,
-                                    "5.14d" to 79,
+                            "5.14d" to 79,
-                                    "5.15a" to 80,
+                            "5.15a" to 80,
-                                    "5.15b" to 81,
+                            "5.15b" to 81,
-                                    "5.15c" to 82,
+                            "5.15c" to 82,
-                                    "5.15d" to 83
+                            "5.15d" to 83,
-                            )
+                        )
                     ydsMapping[grade] ?: 0
                 }
                 DifficultySystem.CUSTOM -> grade.toIntOrNull() ?: 0
             }
         }
     }
+
     /**
      * Compare this grade with another grade of the same system Returns negative if this grade is
      * easier, positive if harder, 0 if equal

android/app/src/main/java/com/atridad/ascently/data/model/Gym.kt

@@ -1,43 +1,45 @@
 package com.atridad.ascently.data.model
 
+import androidx.compose.runtime.Immutable
 import androidx.room.Entity
 import androidx.room.PrimaryKey
 import com.atridad.ascently.utils.DateFormatUtils
 import kotlinx.serialization.Serializable
 
+@Immutable
 @Entity(tableName = "gyms")
 @Serializable
 data class Gym(
-        @PrimaryKey val id: String,
+    @PrimaryKey val id: String,
-        val name: String,
+    val name: String,
-        val location: String? = null,
+    val location: String? = null,
-        val supportedClimbTypes: List<ClimbType>,
+    val supportedClimbTypes: List<ClimbType>,
-        val difficultySystems: List<DifficultySystem>,
+    val difficultySystems: List<DifficultySystem>,
-        val customDifficultyGrades: List<String> = emptyList(),
+    val customDifficultyGrades: List<String> = emptyList(),
-        val notes: String? = null,
+    val notes: String? = null,
-        val createdAt: String,
+    val createdAt: String,
-        val updatedAt: String
+    val updatedAt: String,
 ) {
     companion object {
         fun create(
-                name: String,
+            name: String,
-                location: String? = null,
+            location: String? = null,
-                supportedClimbTypes: List<ClimbType>,
+            supportedClimbTypes: List<ClimbType>,
-                difficultySystems: List<DifficultySystem>,
+            difficultySystems: List<DifficultySystem>,
-                customDifficultyGrades: List<String> = emptyList(),
+            customDifficultyGrades: List<String> = emptyList(),
-                notes: String? = null
+            notes: String? = null,
         ): Gym {
             val now = DateFormatUtils.nowISO8601()
             return Gym(
-                    id = java.util.UUID.randomUUID().toString(),
+                id = java.util.UUID.randomUUID().toString(),
-                    name = name,
+                name = name,
-                    location = location,
+                location = location,
-                    supportedClimbTypes = supportedClimbTypes,
+                supportedClimbTypes = supportedClimbTypes,
-                    difficultySystems = difficultySystems,
+                difficultySystems = difficultySystems,
-                    customDifficultyGrades = customDifficultyGrades,
+                customDifficultyGrades = customDifficultyGrades,
-                    notes = notes,
+                notes = notes,
-                    createdAt = now,
+                createdAt = now,
-                    updatedAt = now
+                updatedAt = now,
             )
         }
     }

android/app/src/main/java/com/atridad/ascently/data/model/Problem.kt

@@ -1,5 +1,6 @@
 package com.atridad.ascently.data.model
 
+import androidx.compose.runtime.Immutable
 import androidx.room.Entity
 import androidx.room.ForeignKey
 import androidx.room.Index
@@ -7,64 +8,66 @@ import androidx.room.PrimaryKey
 import com.atridad.ascently.utils.DateFormatUtils
 import kotlinx.serialization.Serializable
 
+@Immutable
 @Entity(
-        tableName = "problems",
+    tableName = "problems",
-        foreignKeys =
+    foreignKeys =
-                [
+    [
-                        ForeignKey(
+        ForeignKey(
-                                entity = Gym::class,
+            entity = Gym::class,
-                                parentColumns = ["id"],
+            parentColumns = ["id"],
-                                childColumns = ["gymId"],
+            childColumns = ["gymId"],
-                                onDelete = ForeignKey.CASCADE
+            onDelete = ForeignKey.CASCADE,
-                        )],
+        ),
-        indices = [Index(value = ["gymId"])]
+    ],
+    indices = [Index(value = ["gymId"])],
 )
 @Serializable
 data class Problem(
-        @PrimaryKey val id: String,
+    @PrimaryKey val id: String,
-        val gymId: String,
+    val gymId: String,
-        val name: String? = null,
+    val name: String? = null,
-        val description: String? = null,
+    val description: String? = null,
-        val climbType: ClimbType,
+    val climbType: ClimbType,
-        val difficulty: DifficultyGrade,
+    val difficulty: DifficultyGrade,
-        val tags: List<String> = emptyList(),
+    val tags: List<String> = emptyList(),
-        val location: String? = null,
+    val location: String? = null,
-        val imagePaths: List<String> = emptyList(),
+    val imagePaths: List<String> = emptyList(),
-        val isActive: Boolean = true,
+    val isActive: Boolean = true,
-        val dateSet: String? = null,
+    val dateSet: String? = null,
-        val notes: String? = null,
+    val notes: String? = null,
-        val createdAt: String,
+    val createdAt: String,
-        val updatedAt: String
+    val updatedAt: String,
 ) {
     companion object {
         fun create(
-                gymId: String,
+            gymId: String,
-                name: String? = null,
+            name: String? = null,
-                description: String? = null,
+            description: String? = null,
-                climbType: ClimbType,
+            climbType: ClimbType,
-                difficulty: DifficultyGrade,
+            difficulty: DifficultyGrade,
-                tags: List<String> = emptyList(),
+            tags: List<String> = emptyList(),
-                location: String? = null,
+            location: String? = null,
-                imagePaths: List<String> = emptyList(),
+            imagePaths: List<String> = emptyList(),
-                dateSet: String? = null,
+            dateSet: String? = null,
-                notes: String? = null
+            notes: String? = null,
         ): Problem {
             val now = DateFormatUtils.nowISO8601()
             return Problem(
-                    id = java.util.UUID.randomUUID().toString(),
+                id = java.util.UUID.randomUUID().toString(),
-                    gymId = gymId,
+                gymId = gymId,
-                    name = name,
+                name = name,
-                    description = description,
+                description = description,
-                    climbType = climbType,
+                climbType = climbType,
-                    difficulty = difficulty,
+                difficulty = difficulty,
-                    tags = tags,
+                tags = tags,
-                    location = location,
+                location = location,
-                    imagePaths = imagePaths,
+                imagePaths = imagePaths,
-                    isActive = true,
+                isActive = true,
-                    dateSet = dateSet,
+                dateSet = dateSet,
-                    notes = notes,
+                notes = notes,
-                    createdAt = now,
+                createdAt = now,
-                    updatedAt = now
+                updatedAt = now,
             )
         }
     }

android/app/src/main/java/com/atridad/ascently/data/repository/ClimbRepository.kt

@@ -12,13 +12,13 @@ import com.atridad.ascently.data.format.ClimbDataBackup
 import com.atridad.ascently.data.format.DeletedItem
 import com.atridad.ascently.data.model.*
 import com.atridad.ascently.data.state.DataStateManager
-import com.atridad.ascently.utils.DateFormatUtils
 import com.atridad.ascently.utils.AppLogger
+import com.atridad.ascently.utils.DateFormatUtils
 import com.atridad.ascently.utils.ZipExportImportUtils
-import java.io.File
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.first
 import kotlinx.serialization.json.Json
+import java.io.File
 
 class ClimbRepository(database: AscentlyDatabase, private val context: Context) {
     private val gymDao = database.gymDao()
@@ -161,7 +161,7 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
                     gyms = allGyms.map { BackupGym.fromGym(it) },
                     problems = allProblems.map { BackupProblem.fromProblem(it) },
                     sessions = allSessions.map { BackupClimbSession.fromClimbSession(it) },
-                    attempts = allAttempts.map { BackupAttempt.fromAttempt(it) }
+                    attempts = allAttempts.map { BackupAttempt.fromAttempt(it) },
                 )
 
             val referencedImagePaths = allProblems.flatMap { it.imagePaths }.toSet()
@@ -172,7 +172,7 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
                             val imageFile =
                                 com.atridad.ascently.utils.ImageUtils.getImageFile(
                                     context,
-                                    imagePath
+                                    imagePath,
                                 )
                             imageFile.exists() && imageFile.length() > 0
                         } catch (_: Exception) {
@@ -185,7 +185,7 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
                 context = context,
                 uri = uri,
                 exportData = backupData,
-                referencedImagePaths = validImagePaths
+                referencedImagePaths = validImagePaths,
             )
         } catch (e: Exception) {
             throw Exception("Export failed: ${e.message}")
@@ -229,7 +229,7 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
             val updatedBackupProblems =
                 ZipExportImportUtils.updateProblemImagePaths(
                     importData.problems,
-                    importResult.importedImagePaths
+                    importResult.importedImagePaths,
                 )
 
             updatedBackupProblems.forEach { backupProblem ->
@@ -237,7 +237,7 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
                     problemDao.insertProblem(backupProblem.toProblem())
                 } catch (e: Exception) {
                     throw Exception(
-                        "Failed to import problem '${backupProblem.name}': ${e.message}"
+                        "Failed to import problem '${backupProblem.name}': ${e.message}",
                     )
                 }
             }
@@ -279,7 +279,7 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
         currentDeletions.add(newDeletion)
 
         val json = json.encodeToString(newDeletion)
-        deletionPreferences.edit { putString("deleted_${itemId}", json) }
+        deletionPreferences.edit { putString("deleted_$itemId", json) }
     }
 
     fun getDeletedItems(): List<DeletedItem> {
@@ -308,20 +308,20 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
         gyms: List<Gym>,
         problems: List<Problem>,
         sessions: List<ClimbSession>,
-        attempts: List<Attempt>
+        attempts: List<Attempt>,
     ) {
         val gymIds = gyms.map { it.id }.toSet()
         val invalidProblems = problems.filter { it.gymId !in gymIds }
         if (invalidProblems.isNotEmpty()) {
             throw Exception(
-                "Data integrity error: ${invalidProblems.size} problems reference non-existent gyms"
+                "Data integrity error: ${invalidProblems.size} problems reference non-existent gyms",
             )
         }
 
         val invalidSessions = sessions.filter { it.gymId !in gymIds }
         if (invalidSessions.isNotEmpty()) {
             throw Exception(
-                "Data integrity error: ${invalidSessions.size} sessions reference non-existent gyms"
+                "Data integrity error: ${invalidSessions.size} sessions reference non-existent gyms",
             )
         }
 
@@ -332,7 +332,7 @@ class ClimbRepository(database: AscentlyDatabase, private val context: Context)
             attempts.filter { it.problemId !in problemIds || it.sessionId !in sessionIds }
         if (invalidAttempts.isNotEmpty()) {
             throw Exception(
-                "Data integrity error: ${invalidAttempts.size} attempts reference non-existent problems or sessions"
+                "Data integrity error: ${invalidAttempts.size} attempts reference non-existent problems or sessions",
             )
         }
     }

android/app/src/main/java/com/atridad/ascently/data/sync/AscentlySyncProvider.kt

@@ -0,0 +1,743 @@
+package com.atridad.ascently.data.sync
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import androidx.annotation.RequiresPermission
+import androidx.core.content.edit
+import com.atridad.ascently.data.format.BackupAttempt
+import com.atridad.ascently.data.format.BackupClimbSession
+import com.atridad.ascently.data.format.BackupGym
+import com.atridad.ascently.data.format.BackupProblem
+import com.atridad.ascently.data.format.ClimbDataBackup
+import com.atridad.ascently.data.repository.ClimbRepository
+import com.atridad.ascently.data.state.DataStateManager
+import com.atridad.ascently.utils.AppLogger
+import com.atridad.ascently.utils.DateFormatUtils
+import com.atridad.ascently.utils.ImageNamingUtils
+import com.atridad.ascently.utils.ImageUtils
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import java.io.IOException
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+import java.util.concurrent.TimeUnit
+
+class AscentlySyncProvider(
+    private val context: Context,
+    private val repository: ClimbRepository,
+) : SyncProvider {
+
+    override val type: SyncProviderType = SyncProviderType.SERVER
+
+    private val dataStateManager = DataStateManager(context)
+
+    companion object {
+        private const val TAG = "AscentlySyncProvider"
+    }
+
+    private val sharedPreferences: SharedPreferences =
+        context.getSharedPreferences("sync_preferences", Context.MODE_PRIVATE)
+
+    private val httpClient =
+        OkHttpClient.Builder()
+            .connectTimeout(45, TimeUnit.SECONDS)
+            .readTimeout(90, TimeUnit.SECONDS)
+            .writeTimeout(90, TimeUnit.SECONDS)
+            .build()
+
+    private val json = Json {
+        prettyPrint = true
+        ignoreUnknownKeys = true
+        explicitNulls = false
+        coerceInputValues = true
+    }
+
+    private val _isConnected = MutableStateFlow(false)
+    override val isConnected: StateFlow<Boolean> = _isConnected.asStateFlow()
+
+    private val _isConfigured = MutableStateFlow(false)
+    override val isConfigured: StateFlow<Boolean> = _isConfigured.asStateFlow()
+
+    private var isOfflineMode = false
+
+    private object Keys {
+        const val SERVER_URL = "server_url"
+        const val AUTH_TOKEN = "auth_token"
+        const val IS_CONNECTED = "is_connected"
+        const val LAST_SYNC_TIME = "last_sync_time"
+        const val OFFLINE_MODE = "offline_mode"
+    }
+
+    init {
+        loadInitialState()
+        updateConfiguredState()
+    }
+
+    private fun loadInitialState() {
+        _isConnected.value = sharedPreferences.getBoolean(Keys.IS_CONNECTED, false)
+        isOfflineMode = sharedPreferences.getBoolean(Keys.OFFLINE_MODE, false)
+    }
+
+    private fun updateConfiguredState() {
+        _isConfigured.value = serverUrl.isNotBlank() && authToken.isNotBlank()
+    }
+
+    var serverUrl: String
+        get() = sharedPreferences.getString(Keys.SERVER_URL, "") ?: ""
+        set(value) {
+            sharedPreferences.edit { putString(Keys.SERVER_URL, value) }
+            updateConfiguredState()
+            _isConnected.value = false
+            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, false) }
+        }
+
+    var authToken: String
+        get() = sharedPreferences.getString(Keys.AUTH_TOKEN, "") ?: ""
+        set(value) {
+            sharedPreferences.edit { putString(Keys.AUTH_TOKEN, value) }
+            updateConfiguredState()
+            _isConnected.value = false
+            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, false) }
+        }
+
+    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
+    private fun isNetworkAvailable(): Boolean {
+        val connectivityManager =
+            context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+        val network = connectivityManager.activeNetwork ?: return false
+        val activeNetwork = connectivityManager.getNetworkCapabilities(network) ?: return false
+        return when {
+            activeNetwork.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> true
+            activeNetwork.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> true
+            else -> false
+        }
+    }
+
+    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
+    override suspend fun sync() {
+        if (isOfflineMode) {
+            AppLogger.d(TAG) { "Sync skipped: Offline mode is enabled." }
+            return
+        }
+        if (!isNetworkAvailable()) {
+            AppLogger.d(TAG) { "Sync skipped: No internet connection." }
+            throw SyncException.NetworkError("No internet connection.")
+        }
+        if (!_isConfigured.value) {
+            throw SyncException.NotConfigured
+        }
+        if (!_isConnected.value) {
+            throw SyncException.NotConnected
+        }
+
+        val localBackup = createBackupFromRepository()
+        val serverBackup = downloadData()
+
+        val hasLocalData =
+            localBackup.gyms.isNotEmpty() ||
+                localBackup.problems.isNotEmpty() ||
+                localBackup.sessions.isNotEmpty() ||
+                localBackup.attempts.isNotEmpty()
+
+        val hasServerData =
+            serverBackup.gyms.isNotEmpty() ||
+                serverBackup.problems.isNotEmpty() ||
+                serverBackup.sessions.isNotEmpty() ||
+                serverBackup.attempts.isNotEmpty()
+
+        val lastSyncTimeStr = sharedPreferences.getString(Keys.LAST_SYNC_TIME, null)
+        if (hasLocalData && hasServerData && lastSyncTimeStr != null) {
+            AppLogger.d(TAG) { "Using delta sync for incremental updates" }
+            performDeltaSync(lastSyncTimeStr)
+        } else {
+            when {
+                !hasLocalData && hasServerData -> {
+                    AppLogger.d(TAG) { "No local data found, performing full restore from server" }
+                    val imagePathMapping = syncImagesFromServer(serverBackup)
+                    importBackupToRepository(serverBackup, imagePathMapping)
+                    AppLogger.d(TAG) { "Full restore completed" }
+                }
+
+                hasLocalData && !hasServerData -> {
+                    AppLogger.d(TAG) { "No server data found, uploading local data to server" }
+                    uploadData(localBackup)
+                    syncImagesForBackup(localBackup)
+                    AppLogger.d(TAG) { "Initial upload completed" }
+                }
+
+                hasLocalData && hasServerData -> {
+                    AppLogger.d(TAG) { "Both local and server data exist, merging (server wins)" }
+                    mergeDataSafely(serverBackup)
+                    AppLogger.d(TAG) { "Merge completed" }
+                }
+
+                else -> {
+                    AppLogger.d(TAG) { "No data to sync" }
+                }
+            }
+        }
+
+        val now = DateFormatUtils.nowISO8601()
+        sharedPreferences.edit { putString(Keys.LAST_SYNC_TIME, now) }
+    }
+
+    override fun disconnect() {
+        serverUrl = ""
+        authToken = ""
+        _isConnected.value = false
+        sharedPreferences.edit {
+            remove(Keys.LAST_SYNC_TIME)
+            putBoolean(Keys.IS_CONNECTED, false)
+        }
+        updateConfiguredState()
+    }
+
+    private suspend fun performDeltaSync(lastSyncTimeStr: String) {
+        AppLogger.d(TAG) { "Starting delta sync with lastSyncTime=$lastSyncTimeStr" }
+
+        val lastSyncDate = parseISO8601(lastSyncTimeStr) ?: Date(0)
+
+        val allGyms = repository.getAllGyms().first()
+        val modifiedGyms =
+            allGyms
+                .filter { gym -> parseISO8601(gym.updatedAt)?.after(lastSyncDate) == true }
+                .map { BackupGym.fromGym(it) }
+
+        val allProblems = repository.getAllProblems().first()
+        val modifiedProblems =
+            allProblems
+                .filter { problem ->
+                    parseISO8601(problem.updatedAt)?.after(lastSyncDate) == true
+                }
+                .map { problem ->
+                    val backupProblem = BackupProblem.fromProblem(problem)
+                    val normalizedImagePaths =
+                        problem.imagePaths.mapIndexed { index, _ ->
+                            ImageNamingUtils.generateImageFilename(problem.id, index)
+                        }
+                    if (normalizedImagePaths.isNotEmpty()) {
+                        backupProblem.copy(imagePaths = normalizedImagePaths)
+                    } else {
+                        backupProblem
+                    }
+                }
+
+        val allSessions = repository.getAllSessions().first()
+        val modifiedSessions =
+            allSessions
+                .filter { session ->
+                    parseISO8601(session.updatedAt)?.after(lastSyncDate) == true
+                }
+                .map { BackupClimbSession.fromClimbSession(it) }
+
+        val allAttempts = repository.getAllAttempts().first()
+        val modifiedAttempts =
+            allAttempts
+                .filter { attempt ->
+                    parseISO8601(attempt.createdAt)?.after(lastSyncDate) == true
+                }
+                .map { BackupAttempt.fromAttempt(it) }
+
+        val allDeletions = repository.getDeletedItems()
+        val modifiedDeletions =
+            allDeletions.filter { item ->
+                parseISO8601(item.deletedAt)?.after(lastSyncDate) == true
+            }
+
+        AppLogger.d(TAG) {
+            "Delta sync sending: gyms=${modifiedGyms.size}, problems=${modifiedProblems.size}, sessions=${modifiedSessions.size}, attempts=${modifiedAttempts.size}, deletions=${modifiedDeletions.size}"
+        }
+
+        val deltaRequest =
+            DeltaSyncRequest(
+                lastSyncTime = lastSyncTimeStr,
+                gyms = modifiedGyms,
+                problems = modifiedProblems,
+                sessions = modifiedSessions,
+                attempts = modifiedAttempts,
+                deletedItems = modifiedDeletions,
+            )
+
+        val requestBody =
+            json.encodeToString(DeltaSyncRequest.serializer(), deltaRequest)
+                .toRequestBody("application/json".toMediaType())
+
+        val request =
+            Request.Builder()
+                .url("$serverUrl/sync/delta")
+                .header("Authorization", "Bearer $authToken")
+                .post(requestBody)
+                .build()
+
+        val deltaResponse =
+            withContext(Dispatchers.IO) {
+                try {
+                    httpClient.newCall(request).execute().use { response ->
+                        if (response.isSuccessful) {
+                            val body = response.body?.string()
+                            if (!body.isNullOrEmpty()) {
+                                json.decodeFromString(DeltaSyncResponse.serializer(), body)
+                            } else {
+                                throw SyncException.InvalidResponse("Empty response body")
+                            }
+                        } else {
+                            handleHttpError(response.code)
+                        }
+                    }
+                } catch (e: IOException) {
+                    throw SyncException.NetworkError(e.message ?: "Network error")
+                }
+            }
+
+        AppLogger.d(TAG) {
+            "Delta sync received: gyms=${deltaResponse.gyms.size}, " +
+                "problems=${deltaResponse.problems.size}, sessions=${deltaResponse.sessions.size}, " +
+                "attempts=${deltaResponse.attempts.size}, deletions=${deltaResponse.deletedItems.size}"
+        }
+
+        applyDeltaResponse(deltaResponse)
+        syncModifiedImages(modifiedProblems)
+    }
+
+    private fun parseISO8601(dateString: String): Date? {
+        return try {
+            val format = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", Locale.US)
+            format.parse(dateString)
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    private suspend fun applyDeltaResponse(response: DeltaSyncResponse) {
+        // SyncService handles the "isSyncing" state to prevent recursive sync triggers
+        // when the repository is modified during a sync operation.
+
+        try {
+            // Merge and apply deletions first to prevent resurrection
+            val allDeletions = repository.getDeletedItems() + response.deletedItems
+            val uniqueDeletions = allDeletions.distinctBy { "${it.type}:${it.id}" }
+
+            AppLogger.d(TAG) { "Applying ${uniqueDeletions.size} deletion records before merging data" }
+            applyDeletions(uniqueDeletions)
+
+            // Build deleted item lookup set
+            val deletedItemSet = uniqueDeletions.map { "${it.type}:${it.id}" }.toSet()
+
+            // Download images for new/modified problems from server
+            val imagePathMapping = mutableMapOf<String, String>()
+            for (problem in response.problems) {
+                if (deletedItemSet.contains("problem:${problem.id}")) {
+                    continue
+                }
+                problem.imagePaths?.forEach { imagePath ->
+                    val serverFilename = imagePath.substringAfterLast('/')
+                    try {
+                        val localImagePath = downloadImage(serverFilename)
+                        if (localImagePath != null) {
+                            imagePathMapping[imagePath] = localImagePath
+                        }
+                    } catch (e: Exception) {
+                        AppLogger.w(TAG) { "Failed to download image $imagePath: ${e.message}" }
+                    }
+                }
+            }
+
+            // Merge gyms
+            val existingGyms = repository.getAllGyms().first()
+            for (backupGym in response.gyms) {
+                if (deletedItemSet.contains("gym:${backupGym.id}")) {
+                    continue
+                }
+                val existing = existingGyms.find { it.id == backupGym.id }
+                if (existing == null || backupGym.updatedAt >= existing.updatedAt) {
+                    val gym = backupGym.toGym()
+                    if (existing != null) {
+                        repository.updateGym(gym)
+                    } else {
+                        repository.insertGym(gym)
+                    }
+                }
+            }
+
+            // Merge problems
+            val existingProblems = repository.getAllProblems().first()
+            for (backupProblem in response.problems) {
+                if (deletedItemSet.contains("problem:${backupProblem.id}")) {
+                    continue
+                }
+                val updatedImagePaths =
+                    backupProblem.imagePaths?.map { oldPath ->
+                        imagePathMapping[oldPath] ?: oldPath
+                    }
+                val problemToMerge = backupProblem.copy(imagePaths = updatedImagePaths)
+                val problem = problemToMerge.toProblem()
+
+                val existing = existingProblems.find { it.id == backupProblem.id }
+                if (existing == null || backupProblem.updatedAt >= existing.updatedAt) {
+                    if (existing != null) {
+                        repository.updateProblem(problem)
+                    } else {
+                        repository.insertProblem(problem)
+                    }
+                }
+            }
+
+            // Merge sessions
+            val existingSessions = repository.getAllSessions().first()
+            for (backupSession in response.sessions) {
+                if (deletedItemSet.contains("session:${backupSession.id}")) {
+                    continue
+                }
+                val session = backupSession.toClimbSession()
+                val existing = existingSessions.find { it.id == backupSession.id }
+                if (existing == null || backupSession.updatedAt >= existing.updatedAt) {
+                    if (existing != null) {
+                        repository.updateSession(session)
+                    } else {
+                        repository.insertSession(session)
+                    }
+                }
+            }
+
+            // Merge attempts
+            val existingAttempts = repository.getAllAttempts().first()
+            for (backupAttempt in response.attempts) {
+                if (deletedItemSet.contains("attempt:${backupAttempt.id}")) {
+                    continue
+                }
+                val attempt = backupAttempt.toAttempt()
+                val existing = existingAttempts.find { it.id == backupAttempt.id }
+                if (existing == null || backupAttempt.createdAt >= existing.createdAt) {
+                    if (existing != null) {
+                        repository.updateAttempt(attempt)
+                    } else {
+                        repository.insertAttempt(attempt)
+                    }
+                }
+            }
+
+            // Apply deletions again for safety
+            applyDeletions(uniqueDeletions)
+
+            // Update deletion records
+            repository.clearDeletedItems()
+            uniqueDeletions.forEach { repository.trackDeletion(it.id, it.type) }
+        } catch (e: Exception) {
+            AppLogger.e(TAG, e) { "Error applying delta response" }
+            throw e
+        }
+    }
+
+    private suspend fun applyDeletions(
+        deletions: List<com.atridad.ascently.data.format.DeletedItem>,
+    ) {
+        val existingGyms = repository.getAllGyms().first()
+        val existingProblems = repository.getAllProblems().first()
+        val existingSessions = repository.getAllSessions().first()
+        val existingAttempts = repository.getAllAttempts().first()
+
+        for (item in deletions) {
+            when (item.type) {
+                "gym" -> {
+                    existingGyms.find { it.id == item.id }?.let { repository.deleteGym(it) }
+                }
+
+                "problem" -> {
+                    existingProblems.find { it.id == item.id }?.let { repository.deleteProblem(it) }
+                }
+
+                "session" -> {
+                    existingSessions.find { it.id == item.id }?.let { repository.deleteSession(it) }
+                }
+
+                "attempt" -> {
+                    existingAttempts.find { it.id == item.id }?.let { repository.deleteAttempt(it) }
+                }
+            }
+        }
+    }
+
+    private suspend fun syncModifiedImages(modifiedProblems: List<BackupProblem>) {
+        if (modifiedProblems.isEmpty()) return
+
+        AppLogger.d(TAG) { "Syncing images for ${modifiedProblems.size} modified problems" }
+
+        for (backupProblem in modifiedProblems) {
+            backupProblem.imagePaths?.forEach { imagePath ->
+                val filename = imagePath.substringAfterLast('/')
+                uploadImage(imagePath, filename)
+            }
+        }
+    }
+
+    private suspend fun downloadData(): ClimbDataBackup {
+        val request =
+            Request.Builder()
+                .url("$serverUrl/sync")
+                .header("Authorization", "Bearer $authToken")
+                .get()
+                .build()
+
+        return withContext(Dispatchers.IO) {
+            try {
+                httpClient.newCall(request).execute().use { response ->
+                    if (response.isSuccessful) {
+                        val body = response.body?.string()
+                        if (!body.isNullOrEmpty()) {
+                            json.decodeFromString(body)
+                        } else {
+                            ClimbDataBackup(
+                                exportedAt = DateFormatUtils.nowISO8601(),
+                                gyms = emptyList(),
+                                problems = emptyList(),
+                                sessions = emptyList(),
+                                attempts = emptyList(),
+                            )
+                        }
+                    } else {
+                        handleHttpError(response.code)
+                    }
+                }
+            } catch (e: IOException) {
+                throw SyncException.NetworkError(e.message ?: "Network error")
+            }
+        }
+    }
+
+    private suspend fun uploadData(backup: ClimbDataBackup) {
+        val requestBody =
+            json.encodeToString(backup).toRequestBody("application/json".toMediaType())
+
+        val request =
+            Request.Builder()
+                .url("$serverUrl/sync")
+                .header("Authorization", "Bearer $authToken")
+                .put(requestBody)
+                .build()
+
+        withContext(Dispatchers.IO) {
+            try {
+                httpClient.newCall(request).execute().use { response ->
+                    if (!response.isSuccessful) {
+                        handleHttpError(response.code)
+                    }
+                }
+            } catch (e: IOException) {
+                throw SyncException.NetworkError(e.message ?: "Network error")
+            }
+        }
+    }
+
+    private suspend fun syncImagesFromServer(backup: ClimbDataBackup): Map<String, String> {
+        val imagePathMapping = mutableMapOf<String, String>()
+        val totalImages = backup.problems.sumOf { it.imagePaths?.size ?: 0 }
+        AppLogger.d(TAG) { "Starting image download from server for $totalImages images" }
+
+        withContext(Dispatchers.IO) {
+            backup.problems.forEach { problem ->
+                problem.imagePaths?.forEach { imagePath ->
+                    val serverFilename = imagePath.substringAfterLast('/')
+                    try {
+                        val localImagePath = downloadImage(serverFilename)
+                        if (localImagePath != null) {
+                            imagePathMapping[imagePath] = localImagePath
+                        }
+                    } catch (_: SyncException.ImageNotFound) {
+                        AppLogger.w(TAG) { "Image not found on server: $imagePath" }
+                    } catch (e: CancellationException) {
+                        throw e
+                    } catch (e: Exception) {
+                        AppLogger.w(TAG) { "Failed to download image $imagePath: ${e.message}" }
+                    }
+                }
+            }
+        }
+        return imagePathMapping
+    }
+
+    private suspend fun downloadImage(serverFilename: String): String? {
+        val request =
+            Request.Builder()
+                .url("$serverUrl/images/download?filename=$serverFilename")
+                .header("Authorization", "Bearer $authToken")
+                .build()
+
+        return withContext(Dispatchers.IO) {
+            try {
+                httpClient.newCall(request).execute().use { response ->
+                    if (response.isSuccessful) {
+                        response.body?.bytes()?.let {
+                            ImageUtils.saveImageFromBytesWithFilename(context, it, serverFilename)
+                        }
+                    } else {
+                        if (response.code == 404) throw SyncException.ImageNotFound
+                        null
+                    }
+                }
+            } catch (e: IOException) {
+                AppLogger.e(TAG, e) { "Network error downloading image $serverFilename" }
+                null
+            }
+        }
+    }
+
+    private suspend fun syncImagesForBackup(backup: ClimbDataBackup) {
+        AppLogger.d(TAG) { "Starting image sync for backup with ${backup.problems.size} problems" }
+        withContext(Dispatchers.IO) {
+            backup.problems.forEach { problem ->
+                problem.imagePaths?.forEach { localPath ->
+                    val filename = localPath.substringAfterLast('/')
+                    uploadImage(localPath, filename)
+                }
+            }
+        }
+    }
+
+    private suspend fun uploadImage(localPath: String, filename: String) {
+        val file = ImageUtils.getImageFile(context, localPath)
+        if (!file.exists()) {
+            AppLogger.w(TAG) { "Local image file not found, cannot upload: $localPath" }
+            return
+        }
+
+        val requestBody = file.readBytes().toRequestBody("application/octet-stream".toMediaType())
+
+        val request =
+            Request.Builder()
+                .url("$serverUrl/images/upload?filename=$filename")
+                .header("Authorization", "Bearer $authToken")
+                .post(requestBody)
+                .build()
+
+        withContext(Dispatchers.IO) {
+            try {
+                httpClient.newCall(request).execute().use { response ->
+                    if (response.isSuccessful) {
+                        AppLogger.d(TAG) { "Successfully uploaded image: $filename" }
+                    } else {
+                        AppLogger.w(TAG) {
+                            "Failed to upload image $filename. Server responded with ${response.code}"
+                        }
+                    }
+                }
+            } catch (e: IOException) {
+                AppLogger.e(TAG, e) { "Network error uploading image $filename" }
+            }
+        }
+    }
+
+    private suspend fun createBackupFromRepository(): ClimbDataBackup {
+        return withContext(Dispatchers.Default) {
+            ClimbDataBackup(
+                exportedAt = dataStateManager.getLastModified(),
+                gyms = repository.getAllGyms().first().map { BackupGym.fromGym(it) },
+                problems =
+                repository.getAllProblems().first().map { problem ->
+                    val backupProblem = BackupProblem.fromProblem(problem)
+                    val normalizedImagePaths =
+                        problem.imagePaths.mapIndexed { index, _ ->
+                            ImageNamingUtils.generateImageFilename(
+                                problem.id,
+                                index,
+                            )
+                        }
+                    if (normalizedImagePaths.isNotEmpty()) {
+                        backupProblem.copy(imagePaths = normalizedImagePaths)
+                    } else {
+                        backupProblem
+                    }
+                },
+                sessions =
+                repository.getAllSessions().first().map {
+                    BackupClimbSession.fromClimbSession(it)
+                },
+                attempts =
+                repository.getAllAttempts().first().map {
+                    BackupAttempt.fromAttempt(it)
+                },
+                deletedItems = repository.getDeletedItems(),
+            )
+        }
+    }
+
+    private suspend fun importBackupToRepository(
+        backup: ClimbDataBackup,
+        imagePathMapping: Map<String, String>,
+    ) {
+        val gyms = backup.gyms.map { it.toGym() }
+        val problems =
+            backup.problems.map { backupProblem ->
+                val imagePaths = backupProblem.imagePaths
+                val updatedImagePaths =
+                    imagePaths?.map { oldPath -> imagePathMapping[oldPath] ?: oldPath }
+                backupProblem.copy(imagePaths = updatedImagePaths).toProblem()
+            }
+        val sessions = backup.sessions.map { it.toClimbSession() }
+        val attempts = backup.attempts.map { it.toAttempt() }
+
+        repository.resetAllData()
+
+        gyms.forEach { repository.insertGymWithoutSync(it) }
+        problems.forEach { repository.insertProblemWithoutSync(it) }
+        sessions.forEach { repository.insertSessionWithoutSync(it) }
+        attempts.forEach { repository.insertAttemptWithoutSync(it) }
+
+        repository.clearDeletedItems()
+    }
+
+    private suspend fun mergeDataSafely(serverBackup: ClimbDataBackup) {
+        AppLogger.d(TAG) { "Server data will overwrite local data. Performing full restore." }
+        val imagePathMapping = syncImagesFromServer(serverBackup)
+        importBackupToRepository(serverBackup, imagePathMapping)
+    }
+
+    private fun handleHttpError(code: Int): Nothing {
+        when (code) {
+            401 -> throw SyncException.Unauthorized
+            in 500..599 -> throw SyncException.ServerError(code)
+            else -> throw SyncException.InvalidResponse("HTTP error code: $code")
+        }
+    }
+
+    override suspend fun testConnection() {
+        if (!_isConfigured.value) {
+            _isConnected.value = false
+            throw SyncException.NotConfigured
+        }
+
+        val request =
+            Request.Builder()
+                .url("$serverUrl/sync")
+                .header("Authorization", "Bearer $authToken")
+                .head()
+                .build()
+        try {
+            withContext(Dispatchers.IO) {
+                httpClient.newCall(request).execute().use { response ->
+                    _isConnected.value = response.isSuccessful || response.code == 405
+                }
+            }
+            if (!_isConnected.value) {
+                throw SyncException.NotConnected
+            }
+        } catch (e: Exception) {
+            _isConnected.value = false
+            throw SyncException.NetworkError(e.message ?: "Connection error")
+        } finally {
+            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, _isConnected.value) }
+        }
+    }
+}

android/app/src/main/java/com/atridad/ascently/data/sync/DeltaSyncModels.kt

@@ -10,21 +10,21 @@ import kotlinx.serialization.Serializable
 /** Request structure for delta sync - sends only changes since last sync */
 @Serializable
 data class DeltaSyncRequest(
-        val lastSyncTime: String,
+    val lastSyncTime: String,
-        val gyms: List<BackupGym>,
+    val gyms: List<BackupGym>,
-        val problems: List<BackupProblem>,
+    val problems: List<BackupProblem>,
-        val sessions: List<BackupClimbSession>,
+    val sessions: List<BackupClimbSession>,
-        val attempts: List<BackupAttempt>,
+    val attempts: List<BackupAttempt>,
-        val deletedItems: List<DeletedItem>
+    val deletedItems: List<DeletedItem>,
 )
 
 /** Response structure for delta sync - receives only changes from server */
 @Serializable
 data class DeltaSyncResponse(
-        val serverTime: String,
+    val serverTime: String,
-        val gyms: List<BackupGym>,
+    val gyms: List<BackupGym>,
-        val problems: List<BackupProblem>,
+    val problems: List<BackupProblem>,
-        val sessions: List<BackupClimbSession>,
+    val sessions: List<BackupClimbSession>,
-        val attempts: List<BackupAttempt>,
+    val attempts: List<BackupAttempt>,
-        val deletedItems: List<DeletedItem>
+    val deletedItems: List<DeletedItem>,
 )

android/app/src/main/java/com/atridad/ascently/data/sync/SyncException.kt

@@ -0,0 +1,21 @@
+package com.atridad.ascently.data.sync
+
+import java.io.IOException
+import java.io.Serializable
+
+sealed class SyncException(message: String) : IOException(message), Serializable {
+    object NotConfigured :
+        SyncException("Sync is not configured. Please set server URL and auth token.")
+
+    object NotConnected : SyncException("Not connected to server. Please test connection first.")
+
+    object Unauthorized : SyncException("Unauthorized. Please check your auth token.")
+
+    object ImageNotFound : SyncException("Image not found on server")
+
+    data class ServerError(val code: Int) : SyncException("Server error: HTTP $code")
+    data class InvalidResponse(val details: String) :
+        SyncException("Invalid server response: $details")
+
+    data class NetworkError(val details: String) : SyncException("Network error: $details")
+}

android/app/src/main/java/com/atridad/ascently/data/sync/SyncProvider.kt

@@ -0,0 +1,18 @@
+package com.atridad.ascently.data.sync
+
+import kotlinx.coroutines.flow.StateFlow
+
+interface SyncProvider {
+    val type: SyncProviderType
+    val isConfigured: StateFlow<Boolean>
+    val isConnected: StateFlow<Boolean>
+
+    suspend fun sync()
+    suspend fun testConnection()
+    fun disconnect()
+}
+
+enum class SyncProviderType {
+    NONE,
+    SERVER,
+}

android/app/src/main/java/com/atridad/ascently/data/sync/SyncService.kt

@@ -2,27 +2,9 @@ package com.atridad.ascently.data.sync
 
 import android.content.Context
 import android.content.SharedPreferences
-import android.net.ConnectivityManager
-import android.net.NetworkCapabilities
-import androidx.annotation.RequiresPermission
 import androidx.core.content.edit
-import com.atridad.ascently.data.format.BackupAttempt
-import com.atridad.ascently.utils.AppLogger
-import com.atridad.ascently.data.format.BackupClimbSession
-import com.atridad.ascently.data.format.BackupGym
-import com.atridad.ascently.data.format.BackupProblem
-import com.atridad.ascently.data.format.ClimbDataBackup
 import com.atridad.ascently.data.repository.ClimbRepository
-import com.atridad.ascently.data.state.DataStateManager
+import com.atridad.ascently.utils.AppLogger
-import com.atridad.ascently.utils.DateFormatUtils
-import com.atridad.ascently.utils.ImageNamingUtils
-import com.atridad.ascently.utils.ImageUtils
-import java.io.IOException
-import java.io.Serializable
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.Locale
-import java.util.concurrent.TimeUnit
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -31,43 +13,21 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import kotlinx.coroutines.withContext
-import kotlinx.serialization.json.Json
-import okhttp3.MediaType.Companion.toMediaType
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.RequestBody.Companion.toRequestBody
 
 class SyncService(private val context: Context, private val repository: ClimbRepository) {
 
-    private val dataStateManager = DataStateManager(context)
-    private val syncMutex = Mutex()
     private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private val syncMutex = Mutex()
 
     companion object {
         private const val TAG = "SyncService"
     }
 
-    private val sharedPreferences: SharedPreferences =
+    // Currently we only support one provider, but this allows for future expansion
-        context.getSharedPreferences("sync_preferences", Context.MODE_PRIVATE)
+    private val provider: SyncProvider = AscentlySyncProvider(context, repository)
-
-    private val httpClient =
-        OkHttpClient.Builder()
-            .connectTimeout(45, TimeUnit.SECONDS)
-            .readTimeout(90, TimeUnit.SECONDS)
-            .writeTimeout(90, TimeUnit.SECONDS)
-            .build()
-
-    private val json = Json {
-        prettyPrint = true
-        ignoreUnknownKeys = true
-        explicitNulls = false
-        coerceInputValues = true
-    }
 
     // State
     private val _isSyncing = MutableStateFlow(false)
@@ -79,11 +39,9 @@ class SyncService(private val context: Context, private val repository: ClimbRep
     private val _syncError = MutableStateFlow<String?>(null)
     val syncError: StateFlow<String?> = _syncError.asStateFlow()
 
-    private val _isConnected = MutableStateFlow(false)
+    // Delegate to provider
-    val isConnected: StateFlow<Boolean> = _isConnected.asStateFlow()
+    val isConnected: StateFlow<Boolean> = provider.isConnected
-
+    val isConfiguredFlow: StateFlow<Boolean> = provider.isConfigured
-    private val _isConfigured = MutableStateFlow(false)
-    val isConfiguredFlow: StateFlow<Boolean> = _isConfigured.asStateFlow()
 
     private val _isTesting = MutableStateFlow(false)
     val isTesting: StateFlow<Boolean> = _isTesting.asStateFlow()
@@ -91,56 +49,40 @@ class SyncService(private val context: Context, private val repository: ClimbRep
     private val _isAutoSyncEnabled = MutableStateFlow(true)
     val isAutoSyncEnabled: StateFlow<Boolean> = _isAutoSyncEnabled.asStateFlow()
 
-    private var isOfflineMode = false
-
     // Debounced sync properties
     private var syncJob: Job? = null
     private var pendingChanges = false
     private val syncDebounceDelay = 2000L // 2 seconds
 
-    // Configuration keys
+    private val sharedPreferences: SharedPreferences =
+        context.getSharedPreferences("sync_preferences", Context.MODE_PRIVATE)
+
     private object Keys {
-        const val SERVER_URL = "server_url"
-        const val AUTH_TOKEN = "auth_token"
-        const val IS_CONNECTED = "is_connected"
         const val LAST_SYNC_TIME = "last_sync_time"
         const val AUTO_SYNC_ENABLED = "auto_sync_enabled"
-        const val OFFLINE_MODE = "offline_mode"
     }
 
     init {
         loadInitialState()
-        updateConfiguredState()
         repository.setAutoSyncCallback { serviceScope.launch { triggerAutoSync() } }
     }
 
     private fun loadInitialState() {
         _lastSyncTime.value = sharedPreferences.getString(Keys.LAST_SYNC_TIME, null)
-        _isConnected.value = sharedPreferences.getBoolean(Keys.IS_CONNECTED, false)
         _isAutoSyncEnabled.value = sharedPreferences.getBoolean(Keys.AUTO_SYNC_ENABLED, true)
-        isOfflineMode = sharedPreferences.getBoolean(Keys.OFFLINE_MODE, false)
-    }
-
-    private fun updateConfiguredState() {
-        _isConfigured.value = serverUrl.isNotBlank() && authToken.isNotBlank()
     }
 
+    // Proxy properties for Ascently provider configuration
     var serverUrl: String
-        get() = sharedPreferences.getString(Keys.SERVER_URL, "") ?: ""
+        get() = (provider as? AscentlySyncProvider)?.serverUrl ?: ""
         set(value) {
-            sharedPreferences.edit { putString(Keys.SERVER_URL, value) }
+            (provider as? AscentlySyncProvider)?.serverUrl = value
-            updateConfiguredState()
-            _isConnected.value = false
-            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, false) }
         }
 
     var authToken: String
-        get() = sharedPreferences.getString(Keys.AUTH_TOKEN, "") ?: ""
+        get() = (provider as? AscentlySyncProvider)?.authToken ?: ""
         set(value) {
-            sharedPreferences.edit { putString(Keys.AUTH_TOKEN, value) }
+            (provider as? AscentlySyncProvider)?.authToken = value
-            updateConfiguredState()
-            _isConnected.value = false
-            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, false) }
         }
 
     fun setAutoSyncEnabled(enabled: Boolean) {
@@ -148,93 +90,20 @@ class SyncService(private val context: Context, private val repository: ClimbRep
         sharedPreferences.edit { putBoolean(Keys.AUTO_SYNC_ENABLED, enabled) }
     }
 
-    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
-    private fun isNetworkAvailable(): Boolean {
-        val connectivityManager =
-            context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
-        val network = connectivityManager.activeNetwork ?: return false
-        val activeNetwork = connectivityManager.getNetworkCapabilities(network) ?: return false
-        return when {
-            activeNetwork.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> true
-            activeNetwork.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> true
-            else -> false
-        }
-    }
-
-    @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE)
     suspend fun syncWithServer() {
-        if (isOfflineMode) {
+        if (!isConfiguredFlow.value) {
-            AppLogger.d(TAG) { "Sync skipped: Offline mode is enabled." }
-            return
-        }
-        if (!isNetworkAvailable()) {
-            _syncError.value = "No internet connection."
-            AppLogger.d(TAG) { "Sync skipped: No internet connection." }
-            return
-        }
-        if (!_isConfigured.value) {
             throw SyncException.NotConfigured
         }
-        if (!_isConnected.value) {
-            throw SyncException.NotConnected
-        }
 
         syncMutex.withLock {
             _isSyncing.value = true
             _syncError.value = null
 
             try {
-                val localBackup = createBackupFromRepository()
+                provider.sync()
-                val serverBackup = downloadData()
 
-                val hasLocalData =
+                // Update last sync time from shared prefs (provider updates it)
-                    localBackup.gyms.isNotEmpty() ||
+                _lastSyncTime.value = sharedPreferences.getString(Keys.LAST_SYNC_TIME, null)
-                            localBackup.problems.isNotEmpty() ||
-                            localBackup.sessions.isNotEmpty() ||
-                            localBackup.attempts.isNotEmpty()
-
-                val hasServerData =
-                    serverBackup.gyms.isNotEmpty() ||
-                            serverBackup.problems.isNotEmpty() ||
-                            serverBackup.sessions.isNotEmpty() ||
-                            serverBackup.attempts.isNotEmpty()
-
-                // If both client and server have been synced before, use delta sync
-                val lastSyncTimeStr = sharedPreferences.getString(Keys.LAST_SYNC_TIME, null)
-                if (hasLocalData && hasServerData && lastSyncTimeStr != null) {
-                    AppLogger.d(TAG) { "Using delta sync for incremental updates" }
-                    performDeltaSync(lastSyncTimeStr)
-                } else {
-                    when {
-                        !hasLocalData && hasServerData -> {
-                            AppLogger.d(TAG) { "No local data found, performing full restore from server" }
-                            val imagePathMapping = syncImagesFromServer(serverBackup)
-                            importBackupToRepository(serverBackup, imagePathMapping)
-                            AppLogger.d(TAG) { "Full restore completed" }
-                        }
-
-                        hasLocalData && !hasServerData -> {
-                            AppLogger.d(TAG) { "No server data found, uploading local data to server" }
-                            uploadData(localBackup)
-                            syncImagesForBackup(localBackup)
-                            AppLogger.d(TAG) { "Initial upload completed" }
-                        }
-
-                        hasLocalData && hasServerData -> {
-                            AppLogger.d(TAG) { "Both local and server data exist, merging (server wins)" }
-                            mergeDataSafely(serverBackup)
-                            AppLogger.d(TAG) { "Merge completed" }
-                        }
-
-                        else -> {
-                            AppLogger.d(TAG) { "No data to sync" }
-                        }
-                    }
-                }
-
-                val now = DateFormatUtils.nowISO8601()
-                _lastSyncTime.value = now
-                sharedPreferences.edit { putString(Keys.LAST_SYNC_TIME, now) }
             } catch (e: Exception) {
                 _syncError.value = e.message
                 throw e
@@ -244,550 +113,21 @@ class SyncService(private val context: Context, private val repository: ClimbRep
         }
     }
 
-    private suspend fun performDeltaSync(lastSyncTimeStr: String) {
-        AppLogger.d(TAG) { "Starting delta sync with lastSyncTime=$lastSyncTimeStr" }
-
-        // Parse last sync time to filter modified items
-        val lastSyncDate = parseISO8601(lastSyncTimeStr) ?: Date(0)
-
-        // Collect items modified since last sync
-        val allGyms = repository.getAllGyms().first()
-        val modifiedGyms =
-            allGyms
-                .filter { gym -> parseISO8601(gym.updatedAt)?.after(lastSyncDate) == true }
-                .map { BackupGym.fromGym(it) }
-
-        val allProblems = repository.getAllProblems().first()
-        val modifiedProblems =
-            allProblems
-                .filter { problem ->
-                    parseISO8601(problem.updatedAt)?.after(lastSyncDate) == true
-                }
-                .map { problem ->
-                    val backupProblem = BackupProblem.fromProblem(problem)
-                    val normalizedImagePaths =
-                        problem.imagePaths.mapIndexed { index, _ ->
-                            ImageNamingUtils.generateImageFilename(problem.id, index)
-                        }
-                    if (normalizedImagePaths.isNotEmpty()) {
-                        backupProblem.copy(imagePaths = normalizedImagePaths)
-                    } else {
-                        backupProblem
-                    }
-                }
-
-        val allSessions = repository.getAllSessions().first()
-        val modifiedSessions =
-            allSessions
-                .filter { session ->
-                    parseISO8601(session.updatedAt)?.after(lastSyncDate) == true
-                }
-                .map { BackupClimbSession.fromClimbSession(it) }
-
-        val allAttempts = repository.getAllAttempts().first()
-        val modifiedAttempts =
-            allAttempts
-                .filter { attempt ->
-                    parseISO8601(attempt.createdAt)?.after(lastSyncDate) == true
-                }
-                .map { BackupAttempt.fromAttempt(it) }
-
-        val allDeletions = repository.getDeletedItems()
-        val modifiedDeletions =
-            allDeletions.filter { item ->
-                parseISO8601(item.deletedAt)?.after(lastSyncDate) == true
-            }
-
-        AppLogger.d(TAG) {
-            "Delta sync sending: gyms=${modifiedGyms.size}, problems=${modifiedProblems.size}, sessions=${modifiedSessions.size}, attempts=${modifiedAttempts.size}, deletions=${modifiedDeletions.size}"
-        }
-
-        // Create delta request
-        val deltaRequest =
-            DeltaSyncRequest(
-                lastSyncTime = lastSyncTimeStr,
-                gyms = modifiedGyms,
-                problems = modifiedProblems,
-                sessions = modifiedSessions,
-                attempts = modifiedAttempts,
-                deletedItems = modifiedDeletions
-            )
-
-        val requestBody =
-            json.encodeToString(DeltaSyncRequest.serializer(), deltaRequest)
-                .toRequestBody("application/json".toMediaType())
-
-        val request =
-            Request.Builder()
-                .url("$serverUrl/sync/delta")
-                .header("Authorization", "Bearer $authToken")
-                .post(requestBody)
-                .build()
-
-        val deltaResponse =
-            withContext(Dispatchers.IO) {
-                try {
-                    httpClient.newCall(request).execute().use { response ->
-                        if (response.isSuccessful) {
-                            val body = response.body?.string()
-                            if (!body.isNullOrEmpty()) {
-                                json.decodeFromString(DeltaSyncResponse.serializer(), body)
-                            } else {
-                                throw SyncException.InvalidResponse("Empty response body")
-                            }
-                        } else {
-                            handleHttpError(response.code)
-                        }
-                    }
-                } catch (e: IOException) {
-                    throw SyncException.NetworkError(e.message ?: "Network error")
-                }
-            }
-
-        AppLogger.d(TAG) {
-            "Delta sync received: gyms=${deltaResponse.gyms.size}, problems=${deltaResponse.problems.size}, sessions=${deltaResponse.sessions.size}, attempts=${deltaResponse.attempts.size}, deletions=${deltaResponse.deletedItems.size}"
-        }
-
-        // Apply server changes to local data
-        applyDeltaResponse(deltaResponse)
-
-        // Sync only modified problem images
-        syncModifiedImages(modifiedProblems)
-    }
-
-    private fun parseISO8601(dateString: String): Date? {
-        return try {
-            val format = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", Locale.US)
-            format.parse(dateString)
-        } catch (e: Exception) {
-            null
-        }
-    }
-
-    private suspend fun applyDeltaResponse(response: DeltaSyncResponse) {
-        // Temporarily disable auto-sync to prevent recursive sync triggers
-        repository.setAutoSyncCallback(null)
-
-        try {
-            // Merge and apply deletions first to prevent resurrection
-            val allDeletions = repository.getDeletedItems() + response.deletedItems
-            val uniqueDeletions = allDeletions.distinctBy { "${it.type}:${it.id}" }
-
-            AppLogger.d(TAG) { "Applying ${uniqueDeletions.size} deletion records before merging data" }
-            applyDeletions(uniqueDeletions)
-
-            // Build deleted item lookup set
-            val deletedItemSet = uniqueDeletions.map { "${it.type}:${it.id}" }.toSet()
-
-            // Download images for new/modified problems from server
-            val imagePathMapping = mutableMapOf<String, String>()
-            for (problem in response.problems) {
-                if (deletedItemSet.contains("problem:${problem.id}")) {
-                    continue
-                }
-                problem.imagePaths?.forEach { imagePath ->
-                    val serverFilename = imagePath.substringAfterLast('/')
-                    try {
-                        val localImagePath = downloadImage(serverFilename)
-                        if (localImagePath != null) {
-                            imagePathMapping[imagePath] = localImagePath
-                        }
-                    } catch (e: Exception) {
-                        AppLogger.w(TAG) { "Failed to download image $imagePath: ${e.message}" }
-                    }
-                }
-            }
-
-            // Merge gyms
-            val existingGyms = repository.getAllGyms().first()
-            for (backupGym in response.gyms) {
-                if (deletedItemSet.contains("gym:${backupGym.id}")) {
-                    continue
-                }
-                val existing = existingGyms.find { it.id == backupGym.id }
-                if (existing == null || backupGym.updatedAt >= existing.updatedAt) {
-                    val gym = backupGym.toGym()
-                    if (existing != null) {
-                        repository.updateGym(gym)
-                    } else {
-                        repository.insertGym(gym)
-                    }
-                }
-            }
-
-            // Merge problems
-            val existingProblems = repository.getAllProblems().first()
-            for (backupProblem in response.problems) {
-                if (deletedItemSet.contains("problem:${backupProblem.id}")) {
-                    continue
-                }
-                val updatedImagePaths =
-                    backupProblem.imagePaths?.map { oldPath ->
-                        imagePathMapping[oldPath] ?: oldPath
-                    }
-                val problemToMerge = backupProblem.copy(imagePaths = updatedImagePaths)
-                val problem = problemToMerge.toProblem()
-
-                val existing = existingProblems.find { it.id == backupProblem.id }
-                if (existing == null || backupProblem.updatedAt >= existing.updatedAt) {
-                    if (existing != null) {
-                        repository.updateProblem(problem)
-                    } else {
-                        repository.insertProblem(problem)
-                    }
-                }
-            }
-
-            // Merge sessions
-            val existingSessions = repository.getAllSessions().first()
-            for (backupSession in response.sessions) {
-                if (deletedItemSet.contains("session:${backupSession.id}")) {
-                    continue
-                }
-                val session = backupSession.toClimbSession()
-                val existing = existingSessions.find { it.id == backupSession.id }
-                if (existing == null || backupSession.updatedAt >= existing.updatedAt) {
-                    if (existing != null) {
-                        repository.updateSession(session)
-                    } else {
-                        repository.insertSession(session)
-                    }
-                }
-            }
-
-            // Merge attempts
-            val existingAttempts = repository.getAllAttempts().first()
-            for (backupAttempt in response.attempts) {
-                if (deletedItemSet.contains("attempt:${backupAttempt.id}")) {
-                    continue
-                }
-                val attempt = backupAttempt.toAttempt()
-                val existing = existingAttempts.find { it.id == backupAttempt.id }
-                if (existing == null || backupAttempt.createdAt >= existing.createdAt) {
-                    if (existing != null) {
-                        repository.updateAttempt(attempt)
-                    } else {
-                        repository.insertAttempt(attempt)
-                    }
-                }
-            }
-
-            // Apply deletions again for safety
-            applyDeletions(uniqueDeletions)
-
-            // Update deletion records
-            repository.clearDeletedItems()
-            uniqueDeletions.forEach { repository.trackDeletion(it.id, it.type) }
-        } finally {
-            // Re-enable auto-sync
-            repository.setAutoSyncCallback { serviceScope.launch { triggerAutoSync() } }
-        }
-    }
-
-    private suspend fun applyDeletions(
-        deletions: List<com.atridad.ascently.data.format.DeletedItem>
-    ) {
-        val existingGyms = repository.getAllGyms().first()
-        val existingProblems = repository.getAllProblems().first()
-        val existingSessions = repository.getAllSessions().first()
-        val existingAttempts = repository.getAllAttempts().first()
-
-        for (item in deletions) {
-            when (item.type) {
-                "gym" -> {
-                    existingGyms.find { it.id == item.id }?.let { repository.deleteGym(it) }
-                }
-
-                "problem" -> {
-                    existingProblems.find { it.id == item.id }?.let { repository.deleteProblem(it) }
-                }
-
-                "session" -> {
-                    existingSessions.find { it.id == item.id }?.let { repository.deleteSession(it) }
-                }
-
-                "attempt" -> {
-                    existingAttempts.find { it.id == item.id }?.let { repository.deleteAttempt(it) }
-                }
-            }
-        }
-    }
-
-    private suspend fun syncModifiedImages(modifiedProblems: List<BackupProblem>) {
-        if (modifiedProblems.isEmpty()) return
-
-        AppLogger.d(TAG) { "Syncing images for ${modifiedProblems.size} modified problems" }
-
-        for (backupProblem in modifiedProblems) {
-            backupProblem.imagePaths?.forEach { imagePath ->
-                val filename = imagePath.substringAfterLast('/')
-                uploadImage(imagePath, filename)
-            }
-        }
-    }
-
-    private suspend fun downloadData(): ClimbDataBackup {
-        val request =
-            Request.Builder()
-                .url("$serverUrl/sync")
-                .header("Authorization", "Bearer $authToken")
-                .get()
-                .build()
-
-        return withContext(Dispatchers.IO) {
-            try {
-                httpClient.newCall(request).execute().use { response ->
-                    if (response.isSuccessful) {
-                        val body = response.body?.string()
-                        if (!body.isNullOrEmpty()) {
-                            json.decodeFromString(body)
-                        } else {
-                            ClimbDataBackup(
-                                exportedAt = DateFormatUtils.nowISO8601(),
-                                gyms = emptyList(),
-                                problems = emptyList(),
-                                sessions = emptyList(),
-                                attempts = emptyList()
-                            )
-                        }
-                    } else {
-                        handleHttpError(response.code)
-                    }
-                }
-            } catch (e: IOException) {
-                throw SyncException.NetworkError(e.message ?: "Network error")
-            }
-        }
-    }
-
-    private suspend fun uploadData(backup: ClimbDataBackup) {
-        val requestBody =
-            json.encodeToString(backup).toRequestBody("application/json".toMediaType())
-
-        val request =
-            Request.Builder()
-                .url("$serverUrl/sync")
-                .header("Authorization", "Bearer $authToken")
-                .put(requestBody)
-                .build()
-
-        withContext(Dispatchers.IO) {
-            try {
-                httpClient.newCall(request).execute().use { response ->
-                    if (!response.isSuccessful) {
-                        handleHttpError(response.code)
-                    }
-                }
-            } catch (e: IOException) {
-                throw SyncException.NetworkError(e.message ?: "Network error")
-            }
-        }
-    }
-
-    private suspend fun syncImagesFromServer(backup: ClimbDataBackup): Map<String, String> {
-        val imagePathMapping = mutableMapOf<String, String>()
-        val totalImages = backup.problems.sumOf { it.imagePaths?.size ?: 0 }
-        AppLogger.d(TAG) { "Starting image download from server for $totalImages images" }
-
-        withContext(Dispatchers.IO) {
-            backup.problems.forEach { problem ->
-                problem.imagePaths?.forEach { imagePath ->
-                    val serverFilename = imagePath.substringAfterLast('/')
-                    try {
-                        val localImagePath = downloadImage(serverFilename)
-                        if (localImagePath != null) {
-                            imagePathMapping[imagePath] = localImagePath
-                        }
-                    } catch (_: SyncException.ImageNotFound) {
-                        AppLogger.w(TAG) { "Image not found on server: $imagePath" }
-                    } catch (e: Exception) {
-                        AppLogger.w(TAG) { "Failed to download image $imagePath: ${e.message}" }
-                    }
-                }
-            }
-        }
-        return imagePathMapping
-    }
-
-    private suspend fun downloadImage(serverFilename: String): String? {
-        val request =
-            Request.Builder()
-                .url("$serverUrl/images/download?filename=$serverFilename")
-                .header("Authorization", "Bearer $authToken")
-                .build()
-
-        return withContext(Dispatchers.IO) {
-            try {
-                httpClient.newCall(request).execute().use { response ->
-                    if (response.isSuccessful) {
-                        response.body?.bytes()?.let {
-                            ImageUtils.saveImageFromBytesWithFilename(context, it, serverFilename)
-                        }
-                    } else {
-                        if (response.code == 404) throw SyncException.ImageNotFound
-                        null
-                    }
-                }
-            } catch (e: IOException) {
-                AppLogger.e(TAG, e) { "Network error downloading image $serverFilename" }
-                null
-            }
-        }
-    }
-
-    private suspend fun syncImagesForBackup(backup: ClimbDataBackup) {
-        AppLogger.d(TAG) { "Starting image sync for backup with ${backup.problems.size} problems" }
-        withContext(Dispatchers.IO) {
-            backup.problems.forEach { problem ->
-                problem.imagePaths?.forEach { localPath ->
-                    val filename = localPath.substringAfterLast('/')
-                    uploadImage(localPath, filename)
-                }
-            }
-        }
-    }
-
-    private suspend fun uploadImage(localPath: String, filename: String) {
-        val file = ImageUtils.getImageFile(context, localPath)
-        if (!file.exists()) {
-            AppLogger.w(TAG) { "Local image file not found, cannot upload: $localPath" }
-            return
-        }
-
-        val requestBody = file.readBytes().toRequestBody("application/octet-stream".toMediaType())
-
-        val request =
-            Request.Builder()
-                .url("$serverUrl/images/upload?filename=$filename")
-                .header("Authorization", "Bearer $authToken")
-                .post(requestBody)
-                .build()
-
-        withContext(Dispatchers.IO) {
-            try {
-                httpClient.newCall(request).execute().use { response ->
-                    if (response.isSuccessful) {
-                        AppLogger.d(TAG) { "Successfully uploaded image: $filename" }
-                    } else {
-                        AppLogger.w(TAG) {
-                            "Failed to upload image $filename. Server responded with ${response.code}"
-                        }
-                    }
-                }
-            } catch (e: IOException) {
-                AppLogger.e(TAG, e) { "Network error uploading image $filename" }
-            }
-        }
-    }
-
-    private suspend fun createBackupFromRepository(): ClimbDataBackup {
-        return withContext(Dispatchers.Default) {
-            ClimbDataBackup(
-                exportedAt = dataStateManager.getLastModified(),
-                gyms = repository.getAllGyms().first().map { BackupGym.fromGym(it) },
-                problems =
-                    repository.getAllProblems().first().map { problem ->
-                        val backupProblem = BackupProblem.fromProblem(problem)
-                        val normalizedImagePaths =
-                            problem.imagePaths.mapIndexed { index, _ ->
-                                ImageNamingUtils.generateImageFilename(
-                                    problem.id,
-                                    index
-                                )
-                            }
-                        if (normalizedImagePaths.isNotEmpty()) {
-                            backupProblem.copy(imagePaths = normalizedImagePaths)
-                        } else {
-                            backupProblem
-                        }
-                    },
-                sessions =
-                    repository.getAllSessions().first().map {
-                        BackupClimbSession.fromClimbSession(it)
-                    },
-                attempts =
-                    repository.getAllAttempts().first().map {
-                        BackupAttempt.fromAttempt(it)
-                    },
-                deletedItems = repository.getDeletedItems()
-            )
-        }
-    }
-
-    private suspend fun importBackupToRepository(
-        backup: ClimbDataBackup,
-        imagePathMapping: Map<String, String>
-    ) {
-        val gyms = backup.gyms.map { it.toGym() }
-        val problems =
-            backup.problems.map { backupProblem ->
-                val imagePaths = backupProblem.imagePaths
-                val updatedImagePaths =
-                    imagePaths?.map { oldPath -> imagePathMapping[oldPath] ?: oldPath }
-                backupProblem.copy(imagePaths = updatedImagePaths).toProblem()
-            }
-        val sessions = backup.sessions.map { it.toClimbSession() }
-        val attempts = backup.attempts.map { it.toAttempt() }
-
-        repository.resetAllData()
-
-        gyms.forEach { repository.insertGymWithoutSync(it) }
-        problems.forEach { repository.insertProblemWithoutSync(it) }
-        sessions.forEach { repository.insertSessionWithoutSync(it) }
-        attempts.forEach { repository.insertAttemptWithoutSync(it) }
-
-        repository.clearDeletedItems()
-    }
-
-    private suspend fun mergeDataSafely(serverBackup: ClimbDataBackup) {
-        AppLogger.d(TAG) { "Server data will overwrite local data. Performing full restore." }
-        val imagePathMapping = syncImagesFromServer(serverBackup)
-        importBackupToRepository(serverBackup, imagePathMapping)
-    }
-
-    private fun handleHttpError(code: Int): Nothing {
-        when (code) {
-            401 -> throw SyncException.Unauthorized
-            in 500..599 -> throw SyncException.ServerError(code)
-            else -> throw SyncException.InvalidResponse("HTTP error code: $code")
-        }
-    }
-
     suspend fun testConnection() {
-        if (!_isConfigured.value) {
-            _isConnected.value = false
-            _syncError.value = "Server URL or Auth Token is not set."
-            return
-        }
         _isTesting.value = true
         _syncError.value = null
-
-        val request =
-            Request.Builder()
-                .url("$serverUrl/sync")
-                .header("Authorization", "Bearer $authToken")
-                .head()
-                .build()
         try {
-            withContext(Dispatchers.IO) {
+            provider.testConnection()
-                httpClient.newCall(request).execute().use { response ->
-                    _isConnected.value = response.isSuccessful || response.code == 405
-                }
-            }
-            if (!_isConnected.value) {
-                _syncError.value = "Connection failed. Check URL and token."
-            }
         } catch (e: Exception) {
-            _isConnected.value = false
             _syncError.value = "Connection error: ${e.message}"
+            throw e
         } finally {
-            sharedPreferences.edit { putBoolean(Keys.IS_CONNECTED, _isConnected.value) }
             _isTesting.value = false
         }
     }
 
     fun triggerAutoSync() {
-        if (!_isConfigured.value || !_isConnected.value || !_isAutoSyncEnabled.value) {
+        if (!isConfiguredFlow.value || !isConnected.value || !_isAutoSyncEnabled.value) {
             return
         }
         if (_isSyncing.value) {
@@ -812,30 +152,9 @@ class SyncService(private val context: Context, private val repository: ClimbRep
 
     fun clearConfiguration() {
         syncJob?.cancel()
-        serverUrl = ""
+        provider.disconnect()
-        authToken = ""
         setAutoSyncEnabled(true)
         _lastSyncTime.value = null
-        _isConnected.value = false
         _syncError.value = null
-        sharedPreferences.edit { clear() }
-        updateConfiguredState()
     }
 }
-
-sealed class SyncException(message: String) : IOException(message), Serializable {
-    object NotConfigured :
-        SyncException("Sync is not configured. Please set server URL and auth token.")
-
-    object NotConnected : SyncException("Not connected to server. Please test connection first.")
-
-    object Unauthorized : SyncException("Unauthorized. Please check your auth token.")
-
-    object ImageNotFound : SyncException("Image not found on server")
-
-    data class ServerError(val code: Int) : SyncException("Server error: HTTP $code")
-    data class InvalidResponse(val details: String) :
-        SyncException("Invalid server response: $details")
-
-    data class NetworkError(val details: String) : SyncException("Network error: $details")
-}

android/app/src/main/java/com/atridad/ascently/navigation/BottomNavigationItem.kt

@@ -7,30 +7,30 @@ import androidx.compose.ui.graphics.vector.ImageVector
 data class BottomNavigationItem(val screen: Screen, val icon: ImageVector, val label: String)
 
 val bottomNavigationItems =
-        listOf(
+    listOf(
-                BottomNavigationItem(
+        BottomNavigationItem(
-                        screen = Screen.Sessions,
+            screen = Screen.Sessions,
-                        icon = Icons.Default.PlayArrow,
+            icon = Icons.Default.PlayArrow,
-                        label = "Sessions"
+            label = "Sessions",
-                ),
+        ),
-                BottomNavigationItem(
+        BottomNavigationItem(
-                        screen = Screen.Problems,
+            screen = Screen.Problems,
-                        icon = Icons.Default.Star,
+            icon = Icons.Default.Star,
-                        label = "Problems"
+            label = "Problems",
-                ),
+        ),
-                BottomNavigationItem(
+        BottomNavigationItem(
-                        screen = Screen.Analytics,
+            screen = Screen.Analytics,
-                        icon = Icons.Default.Info,
+            icon = Icons.Default.Info,
-                        label = "Analytics"
+            label = "Analytics",
-                ),
+        ),
-                BottomNavigationItem(
+        BottomNavigationItem(
-                        screen = Screen.Gyms,
+            screen = Screen.Gyms,
-                        icon = Icons.Default.LocationOn,
+            icon = Icons.Default.LocationOn,
-                        label = "Gyms"
+            label = "Gyms",
-                ),
+        ),
-                BottomNavigationItem(
+        BottomNavigationItem(
-                        screen = Screen.Settings,
+            screen = Screen.Settings,
-                        icon = Icons.Default.Settings,
+            icon = Icons.Default.Settings,
-                        label = "Settings"
+            label = "Settings",
-                )
+        ),
-        )
+    )

android/app/src/main/java/com/atridad/ascently/service/SessionTrackingService.kt

@@ -6,6 +6,8 @@ import android.app.PendingIntent
 import android.app.Service
 import android.content.Context
 import android.content.Intent
+import android.os.Build
+import android.os.Bundle
 import android.os.IBinder
 import androidx.core.app.NotificationCompat
 import com.atridad.ascently.MainActivity
@@ -13,12 +15,14 @@ import com.atridad.ascently.R
 import com.atridad.ascently.data.database.AscentlyDatabase
 import com.atridad.ascently.data.repository.ClimbRepository
 import com.atridad.ascently.utils.AppLogger
+import com.atridad.ascently.utils.DateFormatUtils
 import com.atridad.ascently.widget.ClimbStatsWidgetProvider
-import java.time.LocalDateTime
-import java.time.temporal.ChronoUnit
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.runBlocking
+import java.time.LocalDateTime
+import java.time.ZoneId
+import java.time.temporal.ChronoUnit
 
 class SessionTrackingService : Service() {
 
@@ -209,33 +213,8 @@ class SessionTrackingService : Service() {
                 repository.getAttemptsBySession(sessionId).firstOrNull() ?: emptyList()
             }
 
-            val duration =
+            val notificationBuilder =
-                session.startTime?.let { startTime ->
-                    try {
-                        val start = LocalDateTime.parse(startTime)
-                        val now = LocalDateTime.now()
-                        val totalSeconds = ChronoUnit.SECONDS.between(start, now)
-                        val hours = totalSeconds / 3600
-                        val minutes = (totalSeconds % 3600) / 60
-                        val seconds = totalSeconds % 60
-
-                        when {
-                            hours > 0 -> "${hours}h ${minutes}m ${seconds}s"
-                            minutes > 0 -> "${minutes}m ${seconds}s"
-                            else -> "${totalSeconds}s"
-                        }
-                    } catch (_: Exception) {
-                        "Active"
-                    }
-                }
-                    ?: "Active"
-
-            val notification =
                 NotificationCompat.Builder(this, CHANNEL_ID)
-                    .setContentTitle("Climbing Session Active")
-                    .setContentText(
-                        "${gym?.name ?: "Gym"} • $duration • ${attempts.size} attempts"
-                    )
                     .setSmallIcon(R.drawable.ic_mountains)
                     .setOngoing(true)
                     .setAutoCancel(false)
@@ -246,14 +225,70 @@ class SessionTrackingService : Service() {
                     .addAction(
                         R.drawable.ic_mountains,
                         "Open Session",
-                        createOpenAppIntent()
+                        createOpenAppIntent(),
                     )
                     .addAction(
                         android.R.drawable.ic_menu_close_clear_cancel,
                         "End Session",
-                        createStopPendingIntent(sessionId)
+                        createStopPendingIntent(sessionId),
                     )
-                    .build()
+
+            // Use Live Update
+            if (Build.VERSION.SDK_INT >= 36) {
+                val startTimeMillis =
+                    session.startTime?.let { startTime ->
+                        try {
+                            DateFormatUtils.parseISO8601(startTime)?.toEpochMilli()
+                                ?: System.currentTimeMillis()
+                        } catch (_: Exception) {
+                            System.currentTimeMillis()
+                        }
+                    }
+                        ?: System.currentTimeMillis()
+
+                notificationBuilder
+                    .setContentTitle("Climbing Session Active")
+                    .setContentText(
+                        "${gym?.name ?: "Gym"} • ${attempts.size} attempts",
+                    )
+                    .setWhen(startTimeMillis)
+                    .setUsesChronometer(true)
+                    .setShowWhen(true)
+
+                val extras = Bundle()
+                extras.putBoolean("android.extra.REQUEST_PROMOTED_ONGOING", true)
+                notificationBuilder.setExtras(extras)
+            } else {
+                // Fallback for older versions
+                val duration =
+                    session.startTime?.let { startTime ->
+                        try {
+                            val start = DateFormatUtils.parseISO8601(startTime)
+                            val now = java.time.Instant.now()
+                            val totalSeconds = if (start != null) ChronoUnit.SECONDS.between(start, now) else 0L
+                            val hours = totalSeconds / 3600
+                            val minutes = (totalSeconds % 3600) / 60
+                            val seconds = totalSeconds % 60
+
+                            when {
+                                hours > 0 -> "${hours}h ${minutes}m ${seconds}s"
+                                minutes > 0 -> "${minutes}m ${seconds}s"
+                                else -> "${totalSeconds}s"
+                            }
+                        } catch (_: Exception) {
+                            "Active"
+                        }
+                    }
+                        ?: "Active"
+
+                notificationBuilder
+                    .setContentTitle("Climbing Session Active")
+                    .setContentText(
+                        "${gym?.name ?: "Gym"} • $duration • ${attempts.size} attempts",
+                    )
+            }
+
+            val notification = notificationBuilder.build()
 
             startForeground(NOTIFICATION_ID, notification)
 
@@ -274,7 +309,7 @@ class SessionTrackingService : Service() {
             this,
             0,
             intent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
         )
     }
 
@@ -284,7 +319,7 @@ class SessionTrackingService : Service() {
             this,
             1,
             intent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
         )
     }
 
@@ -293,7 +328,7 @@ class SessionTrackingService : Service() {
             NotificationChannel(
                 CHANNEL_ID,
                 "Session Tracking",
-                NotificationManager.IMPORTANCE_DEFAULT
+                NotificationManager.IMPORTANCE_DEFAULT,
             )
                 .apply {
                     description = "Shows active climbing session information"

android/app/src/main/java/com/atridad/ascently/ui/AscentlyApp.kt

@@ -35,7 +35,7 @@ import com.atridad.ascently.utils.NotificationPermissionUtils
 fun AscentlyApp(
     shortcutAction: String? = null,
     lastUsedGymId: String? = null,
-    onShortcutActionProcessed: () -> Unit = {}
+    onShortcutActionProcessed: () -> Unit = {},
 ) {
     val navController = rememberNavController()
     val context = LocalContext.current
@@ -53,7 +53,7 @@ fun AscentlyApp(
 
     val permissionLauncher =
         rememberLauncherForActivityResult(
-            contract = ActivityResultContracts.RequestPermission()
+            contract = ActivityResultContracts.RequestPermission(),
         ) { isGranted: Boolean ->
             if (!isGranted) {
                 showNotificationPermissionDialog = false
@@ -90,7 +90,7 @@ fun AscentlyApp(
             context = context,
             hasActiveSession = activeSession != null,
             hasGyms = gyms.isNotEmpty(),
-            lastUsedGym = if (activeSession == null && gyms.size > 1) lastUsedGym else null
+            lastUsedGym = if (activeSession == null && gyms.size > 1) lastUsedGym else null,
         )
     }
 
@@ -121,7 +121,7 @@ fun AscentlyApp(
             if (activeSession == null) {
                 if (NotificationPermissionUtils.shouldRequestNotificationPermission() &&
                     !NotificationPermissionUtils.isNotificationPermissionGranted(
-                        context
+                        context,
                     )
                 ) {
                     AppLogger.d("AscentlyApp") { "Showing notification permission dialog" }
@@ -160,20 +160,20 @@ fun AscentlyApp(
             fabConfig?.let { config ->
                 FloatingActionButton(
                     onClick = config.onClick,
-                    containerColor = MaterialTheme.colorScheme.primary
+                    containerColor = MaterialTheme.colorScheme.primary,
                 ) {
                     Icon(
                         imageVector = config.icon,
-                        contentDescription = config.contentDescription
+                        contentDescription = config.contentDescription,
                     )
                 }
             }
-        }
+        },
     ) { innerPadding ->
         NavHost(
             navController = navController,
             startDestination = Screen.Sessions,
-            modifier = Modifier.padding(innerPadding)
+            modifier = Modifier.padding(innerPadding),
         ) {
             composable<Screen.Sessions> {
                 LaunchedEffect(gyms, activeSession) {
@@ -187,14 +187,14 @@ fun AscentlyApp(
                                             .shouldRequestNotificationPermission() &&
                                         !NotificationPermissionUtils
                                             .isNotificationPermissionGranted(
-                                                context
+                                                context,
                                             )
                                     ) {
                                         showNotificationPermissionDialog = true
                                     } else {
                                         navController.navigate(Screen.AddEditSession())
                                     }
-                                }
+                                },
                             )
                         } else {
                             null
@@ -204,7 +204,7 @@ fun AscentlyApp(
                     viewModel = viewModel,
                     onNavigateToSessionDetail = { sessionId ->
                         navController.navigate(Screen.SessionDetail(sessionId))
-                    }
+                    },
                 )
             }
 
@@ -217,7 +217,7 @@ fun AscentlyApp(
                                 contentDescription = "Add Problem",
                                 onClick = {
                                     navController.navigate(Screen.AddEditProblem())
-                                }
+                                },
                             )
                         } else {
                             null
@@ -227,7 +227,7 @@ fun AscentlyApp(
                     viewModel = viewModel,
                     onNavigateToProblemDetail = { problemId ->
                         navController.navigate(Screen.ProblemDetail(problemId))
-                    }
+                    },
                 )
             }
 
@@ -242,14 +242,14 @@ fun AscentlyApp(
                         FabConfig(
                             icon = Icons.Default.Add,
                             contentDescription = "Add Gym",
-                            onClick = { navController.navigate(Screen.AddEditGym()) }
+                            onClick = { navController.navigate(Screen.AddEditGym()) },
                         )
                 }
                 GymsScreen(
                     viewModel = viewModel,
                     onNavigateToGymDetail = { gymId ->
                         navController.navigate(Screen.GymDetail(gymId))
-                    }
+                    },
                 )
             }
 
@@ -267,7 +267,7 @@ fun AscentlyApp(
                     onNavigateBack = { navController.popBackStack() },
                     onNavigateToProblemDetail = { problemId ->
                         navController.navigate(Screen.ProblemDetail(problemId))
-                    }
+                    },
                 )
             }
 
@@ -280,7 +280,7 @@ fun AscentlyApp(
                     onNavigateBack = { navController.popBackStack() },
                     onNavigateToEdit = { problemId ->
                         navController.navigate(Screen.AddEditProblem(problemId = problemId))
-                    }
+                    },
                 )
             }
 
@@ -299,7 +299,7 @@ fun AscentlyApp(
                     },
                     onNavigateToProblemDetail = { problemId ->
                         navController.navigate(Screen.ProblemDetail(problemId))
-                    }
+                    },
                 )
             }
 
@@ -309,7 +309,7 @@ fun AscentlyApp(
                 AddEditGymScreen(
                     gymId = args.gymId,
                     viewModel = viewModel,
-                    onNavigateBack = { navController.popBackStack() }
+                    onNavigateBack = { navController.popBackStack() },
                 )
             }
 
@@ -320,7 +320,7 @@ fun AscentlyApp(
                     problemId = args.problemId,
                     gymId = args.gymId,
                     viewModel = viewModel,
-                    onNavigateBack = { navController.popBackStack() }
+                    onNavigateBack = { navController.popBackStack() },
                 )
             }
 
@@ -331,7 +331,7 @@ fun AscentlyApp(
                     sessionId = args.sessionId,
                     gymId = args.gymId,
                     viewModel = viewModel,
-                    onNavigateBack = { navController.popBackStack() }
+                    onNavigateBack = { navController.popBackStack() },
                 )
             }
         }
@@ -341,9 +341,9 @@ fun AscentlyApp(
                 onDismiss = { showNotificationPermissionDialog = false },
                 onRequestPermission = {
                     permissionLauncher.launch(
-                        NotificationPermissionUtils.getNotificationPermissionString()
+                        NotificationPermissionUtils.getNotificationPermissionString(),
                     )
-                }
+                },
             )
         }
     }
@@ -377,7 +377,7 @@ fun AscentlyBottomNavigation(navController: NavHostController) {
                         // Don't restore state - always start fresh when switching tabs
                         restoreState = false
                     }
-                }
+                },
             )
         }
     }
@@ -386,5 +386,5 @@ fun AscentlyBottomNavigation(navController: NavHostController) {
 data class FabConfig(
     val icon: androidx.compose.ui.graphics.vector.ImageVector,
     val contentDescription: String,
-    val onClick: () -> Unit
+    val onClick: () -> Unit,
 )

android/app/src/main/java/com/atridad/ascently/ui/components/ActiveSessionBanner.kt

@@ -13,8 +13,9 @@ import androidx.compose.ui.unit.dp
 import com.atridad.ascently.data.model.ClimbSession
 import com.atridad.ascently.data.model.Gym
 import com.atridad.ascently.ui.theme.CustomIcons
+import com.atridad.ascently.utils.DateFormatUtils
 import kotlinx.coroutines.delay
-import java.time.LocalDateTime
+import java.time.Instant
 import java.time.temporal.ChronoUnit
 
 @Composable
@@ -22,102 +23,113 @@ fun ActiveSessionBanner(
     activeSession: ClimbSession?,
     gym: Gym?,
     onSessionClick: () -> Unit,
-    onEndSession: () -> Unit
+    onEndSession: () -> Unit,
+    modifier: Modifier = Modifier,
 ) {
-    if (activeSession != null) {
+    if (activeSession == null) return
-        // Add a timer that updates every second for real-time duration counting
-        var currentTime by remember { mutableStateOf(LocalDateTime.now()) }
 
-        LaunchedEffect(Unit) {
+    val sessionId = activeSession.id
-            while (true) {
+    val startTimeString = activeSession.startTime
-                delay(1000) // Update every second
+    val gymName = gym?.name ?: "Unknown Gym"
-                currentTime = LocalDateTime.now()
+
-            }
+    var elapsedSeconds by remember(sessionId) { mutableLongStateOf(0L) }
+
+    LaunchedEffect(sessionId, startTimeString) {
+        if (startTimeString == null) return@LaunchedEffect
+
+        while (true) {
+            elapsedSeconds = calculateElapsedSeconds(startTimeString)
+            delay(1000)
         }
+    }
 
-        Card(
+    val durationText = remember(elapsedSeconds) {
+        formatDuration(elapsedSeconds)
+    }
+
+    Card(
+        modifier = modifier
+            .fillMaxWidth()
+            .clickable { onSessionClick() },
+        colors = CardDefaults.cardColors(
+            containerColor = MaterialTheme.colorScheme.primaryContainer,
+        ),
+    ) {
+        Row(
             modifier = Modifier
                 .fillMaxWidth()
-                .clickable { onSessionClick() },
+                .padding(16.dp),
-            colors = CardDefaults.cardColors(
+            horizontalArrangement = Arrangement.SpaceBetween,
-                containerColor = MaterialTheme.colorScheme.primaryContainer
+            verticalAlignment = Alignment.CenterVertically,
-            )
         ) {
-            Row(
+            Column(modifier = Modifier.weight(1f)) {
-                modifier = Modifier
+                Row(verticalAlignment = Alignment.CenterVertically) {
-                    .fillMaxWidth()
-                    .padding(16.dp),
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Column(modifier = Modifier.weight(1f)) {
-                    Row(
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        Icon(
-                            Icons.Default.PlayArrow,
-                            contentDescription = "Active session",
-                            tint = MaterialTheme.colorScheme.primary,
-                            modifier = Modifier.size(16.dp)
-                        )
-                        Spacer(modifier = Modifier.width(8.dp))
-                        Text(
-                            text = "Active Session",
-                            style = MaterialTheme.typography.titleSmall,
-                            fontWeight = FontWeight.Bold,
-                            color = MaterialTheme.colorScheme.onPrimaryContainer
-                        )
-                    }
-                    
-                    Spacer(modifier = Modifier.height(4.dp))
-                    
-                    Text(
-                        text = gym?.name ?: "Unknown Gym",
-                        style = MaterialTheme.typography.bodyMedium,
-                        color = MaterialTheme.colorScheme.onPrimaryContainer
-                    )
-                    
-                    activeSession.startTime?.let { startTime ->
-                        val duration = calculateDuration(startTime, currentTime)
-                        Text(
-                            text = duration,
-                            style = MaterialTheme.typography.bodySmall,
-                            color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.8f)
-                        )
-                    }
-                }
-                
-                IconButton(
-                    onClick = onEndSession,
-                    colors = IconButtonDefaults.iconButtonColors(
-                        containerColor = MaterialTheme.colorScheme.error,
-                        contentColor = MaterialTheme.colorScheme.onError
-                    )
-                ) {
                     Icon(
-                        imageVector = CustomIcons.Stop(MaterialTheme.colorScheme.onError),
+                        Icons.Default.PlayArrow,
-                        contentDescription = "End session"
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.size(16.dp),
+                    )
+                    Spacer(modifier = Modifier.width(8.dp))
+                    Text(
+                        text = "Active Session",
+                        style = MaterialTheme.typography.titleSmall,
+                        fontWeight = FontWeight.Bold,
+                        color = MaterialTheme.colorScheme.onPrimaryContainer,
                     )
                 }
+
+                Spacer(modifier = Modifier.height(4.dp))
+
+                Text(
+                    text = gymName,
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.onPrimaryContainer,
+                )
+
+                if (startTimeString != null) {
+                    Text(
+                        text = durationText,
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.8f),
+                    )
+                }
+            }
+
+            FilledIconButton(
+                onClick = onEndSession,
+                colors = IconButtonDefaults.filledIconButtonColors(
+                    containerColor = MaterialTheme.colorScheme.error,
+                    contentColor = MaterialTheme.colorScheme.onError,
+                ),
+            ) {
+                Icon(
+                    imageVector = CustomIcons.Stop(MaterialTheme.colorScheme.onError),
+                    contentDescription = "End session",
+                )
             }
         }
     }
 }
 
-private fun calculateDuration(startTimeString: String, currentTime: LocalDateTime): String {
+private fun calculateElapsedSeconds(startTimeString: String): Long {
     return try {
-        val startTime = LocalDateTime.parse(startTimeString)
+        val startTime = DateFormatUtils.parseISO8601(startTimeString) ?: return 0L
-        val totalSeconds = ChronoUnit.SECONDS.between(startTime, currentTime)
+        val now = Instant.now()
-        val hours = totalSeconds / 3600
+        ChronoUnit.SECONDS.between(startTime, now).coerceAtLeast(0)
-        val minutes = (totalSeconds % 3600) / 60
-        val seconds = totalSeconds % 60
-        
-        when {
-            hours > 0 -> "${hours}h ${minutes}m ${seconds}s"
-            minutes > 0 -> "${minutes}m ${seconds}s"
-            else -> "${totalSeconds}s"
-        }
     } catch (_: Exception) {
-        "Active"
+        0L
+    }
+}
+
+private fun formatDuration(totalSeconds: Long): String {
+    val hours = totalSeconds / 3600
+    val minutes = (totalSeconds % 3600) / 60
+    val seconds = totalSeconds % 60
+
+    return when {
+        hours > 0 -> "${hours}h ${minutes}m ${seconds}s"
+        minutes > 0 -> "${minutes}m ${seconds}s"
+        else -> "${seconds}s"
     }
 }

android/app/src/main/java/com/atridad/ascently/ui/components/BarChart.kt

@@ -23,25 +23,25 @@ data class BarChartDataPoint(val label: String, val value: Int, val gradeNumeric
 
 /** Configuration for bar chart styling */
 data class BarChartStyle(
-        val barColor: Color,
+    val barColor: Color,
-        val gridColor: Color,
+    val gridColor: Color,
-        val textColor: Color,
+    val textColor: Color,
-        val backgroundColor: Color
+    val backgroundColor: Color,
 )
 
 /** Custom Bar Chart for displaying grade distribution */
 @Composable
 fun BarChart(
-        data: List<BarChartDataPoint>,
+    data: List<BarChartDataPoint>,
-        modifier: Modifier = Modifier,
+    modifier: Modifier = Modifier,
-        style: BarChartStyle =
+    style: BarChartStyle =
-                BarChartStyle(
+        BarChartStyle(
-                        barColor = MaterialTheme.colorScheme.primary,
+            barColor = MaterialTheme.colorScheme.primary,
-                        gridColor = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f),
+            gridColor = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f),
-                        textColor = MaterialTheme.colorScheme.onSurfaceVariant,
+            textColor = MaterialTheme.colorScheme.onSurfaceVariant,
-                        backgroundColor = MaterialTheme.colorScheme.surface
+            backgroundColor = MaterialTheme.colorScheme.surface,
-                ),
+        ),
-        showGrid: Boolean = true
+    showGrid: Boolean = true,
 ) {
     val textMeasurer = rememberTextMeasurer()
     val density = LocalDensity.current
@@ -68,42 +68,44 @@ fun BarChart(
 
             // Draw background
             drawRect(
-                    color = style.backgroundColor,
+                color = style.backgroundColor,
-                    topLeft = Offset(padding, padding),
+                topLeft = Offset(padding, padding),
-                    size = androidx.compose.ui.geometry.Size(chartWidth, chartHeight)
+                size = androidx.compose.ui.geometry.Size(chartWidth, chartHeight),
             )
 
             // Draw grid
             if (showGrid) {
                 drawGrid(
-                        padding = padding,
+                    padding = padding,
-                        chartWidth = chartWidth,
+                    chartWidth = chartWidth,
-                        chartHeight = chartHeight,
+                    chartHeight = chartHeight,
-                        gridColor = style.gridColor,
+                    gridColor = style.gridColor,
-                        maxValue = maxValue,
+                    maxValue = maxValue,
-                        textMeasurer = textMeasurer,
+                    textMeasurer = textMeasurer,
-                        textColor = style.textColor
+                    textColor = style.textColor,
                 )
             }
 
             // Draw bars and labels
             sortedData.forEachIndexed { index, dataPoint ->
                 val barHeight =
-                        if (maxValue > 0) {
+                    if (maxValue > 0) {
-                            (dataPoint.value.toFloat() / maxValue.toFloat()) * chartHeight * 0.8f
+                        (dataPoint.value.toFloat() / maxValue.toFloat()) * chartHeight * 0.8f
-                        } else 0f
+                    } else {
+                        0f
+                    }
 
                 val barX =
-                        padding +
+                    padding +
-                                barSpacing +
+                        barSpacing +
-                                index * (barWidth + barSpacing / (barCount - 1).coerceAtLeast(1))
+                        index * (barWidth + barSpacing / (barCount - 1).coerceAtLeast(1))
                 val barY = padding + chartHeight - barHeight
 
                 // Draw bar
                 drawRect(
-                        color = style.barColor,
+                    color = style.barColor,
-                        topLeft = Offset(barX, barY),
+                    topLeft = Offset(barX, barY),
-                        size = androidx.compose.ui.geometry.Size(barWidth, barHeight)
+                    size = androidx.compose.ui.geometry.Size(barWidth, barHeight),
                 )
 
                 // Draw value on bar
@@ -114,24 +116,24 @@ fun BarChart(
 
                     // Position text
                     val textY =
-                            if (barHeight > textSize.size.height + 8.dp.toPx()) {
+                        if (barHeight > textSize.size.height + 8.dp.toPx()) {
-                                barY + 8.dp.toPx()
+                            barY + 8.dp.toPx()
-                            } else {
+                        } else {
-                                barY - 4.dp.toPx()
+                            barY - 4.dp.toPx()
-                            }
+                        }
 
                     val textColor =
-                            if (barHeight > textSize.size.height + 8.dp.toPx()) {
+                        if (barHeight > textSize.size.height + 8.dp.toPx()) {
-                                Color.White
+                            Color.White
-                            } else {
+                        } else {
-                                style.textColor
+                            style.textColor
-                            }
+                        }
 
                     drawText(
-                            textMeasurer = textMeasurer,
+                        textMeasurer = textMeasurer,
-                            text = valueText,
+                        text = valueText,
-                            style = textStyle.copy(color = textColor),
+                        style = textStyle.copy(color = textColor),
-                            topLeft = Offset(barX + barWidth / 2f - textSize.size.width / 2f, textY)
+                        topLeft = Offset(barX + barWidth / 2f - textSize.size.width / 2f, textY),
                     )
                 }
 
@@ -141,14 +143,14 @@ fun BarChart(
                 val labelTextSize = textMeasurer.measure(gradeText, labelTextStyle)
 
                 drawText(
-                        textMeasurer = textMeasurer,
+                    textMeasurer = textMeasurer,
-                        text = gradeText,
+                    text = gradeText,
-                        style = labelTextStyle,
+                    style = labelTextStyle,
-                        topLeft =
+                    topLeft =
-                                Offset(
+                    Offset(
-                                        barX + barWidth / 2f - labelTextSize.size.width / 2f,
+                        barX + barWidth / 2f - labelTextSize.size.width / 2f,
-                                        padding + chartHeight + 8.dp.toPx()
+                        padding + chartHeight + 8.dp.toPx(),
-                                )
+                    ),
                 )
             }
         }
@@ -156,37 +158,37 @@ fun BarChart(
 }
 
 private fun DrawScope.drawGrid(
-        padding: Float,
+    padding: Float,
-        chartWidth: Float,
+    chartWidth: Float,
-        chartHeight: Float,
+    chartHeight: Float,
-        gridColor: Color,
+    gridColor: Color,
-        maxValue: Int,
+    maxValue: Int,
-        textMeasurer: TextMeasurer,
+    textMeasurer: TextMeasurer,
-        textColor: Color
+    textColor: Color,
 ) {
     val textStyle = TextStyle(color = textColor, fontSize = 10.sp)
 
     // Horizontal grid lines
     val gridLines =
-            when {
+        when {
-                maxValue <= 5 -> (0..maxValue).toList()
+            maxValue <= 5 -> (0..maxValue).toList()
-                maxValue <= 10 -> (0..maxValue step 2).toList()
+            maxValue <= 10 -> (0..maxValue step 2).toList()
-                maxValue <= 20 -> (0..maxValue step 5).toList()
+            maxValue <= 20 -> (0..maxValue step 5).toList()
-                else -> {
+            else -> {
-                    val step = (maxValue / 5).coerceAtLeast(1)
+                val step = (maxValue / 5).coerceAtLeast(1)
-                    (0..maxValue step step).toList()
+                (0..maxValue step step).toList()
-                }
             }
+        }
 
     gridLines.forEach { value ->
         val y = padding + chartHeight - (value.toFloat() / maxValue.toFloat()) * chartHeight * 0.8f
 
         // Draw grid line
         drawLine(
-                color = gridColor,
+            color = gridColor,
-                start = Offset(padding, y),
+            start = Offset(padding, y),
-                end = Offset(padding + chartWidth, y),
+            end = Offset(padding + chartWidth, y),
-                strokeWidth = 1.dp.toPx()
+            strokeWidth = 1.dp.toPx(),
         )
 
         // Draw Y-axis label
@@ -194,14 +196,14 @@ private fun DrawScope.drawGrid(
             val text = value.toString()
             val textSize = textMeasurer.measure(text, textStyle)
             drawText(
-                    textMeasurer = textMeasurer,
+                textMeasurer = textMeasurer,
-                    text = text,
+                text = text,
-                    style = textStyle,
+                style = textStyle,
-                    topLeft =
+                topLeft =
-                            Offset(
+                Offset(
-                                    padding - textSize.size.width - 8.dp.toPx(),
+                    padding - textSize.size.width - 8.dp.toPx(),
-                                    y - textSize.size.height / 2f
+                    y - textSize.size.height / 2f,
-                            )
+                ),
             )
         }
     }

android/app/src/main/java/com/atridad/ascently/ui/components/FullscreenImageViewer.kt

@@ -40,44 +40,44 @@ fun FullscreenImageViewer(imagePaths: List<String>, initialIndex: Int = 0, onDis
     LaunchedEffect(pagerState.currentPage) {
         if (imagePaths.size > 1) {
             thumbnailListState.animateScrollToItem(
-                    index = pagerState.currentPage,
+                index = pagerState.currentPage,
-                    scrollOffset = -200
+                scrollOffset = -200,
             )
         }
     }
 
     Dialog(
-            onDismissRequest = onDismiss,
+        onDismissRequest = onDismiss,
-            properties =
+        properties =
-                    DialogProperties(usePlatformDefaultWidth = false, decorFitsSystemWindows = true)
+        DialogProperties(usePlatformDefaultWidth = false, decorFitsSystemWindows = true),
     ) {
         Box(modifier = Modifier.fillMaxSize().background(Color.Black).systemBarsPadding()) {
             // Main image pager
             HorizontalPager(state = pagerState, modifier = Modifier.fillMaxSize()) { page ->
                 OrientationAwareImage(
-                        imagePath = imagePaths[page],
+                    imagePath = imagePaths[page],
-                        contentDescription = "Full screen image",
+                    contentDescription = "Full screen image",
-                        modifier = Modifier.fillMaxSize(),
+                    modifier = Modifier.fillMaxSize(),
-                        contentScale = ContentScale.Fit
+                    contentScale = ContentScale.Fit,
                 )
             }
 
             // Top bar with back button and counter
             Surface(
-                    modifier = Modifier.fillMaxWidth().align(Alignment.TopStart),
+                modifier = Modifier.fillMaxWidth().align(Alignment.TopStart),
-                    color = Color.Black.copy(alpha = 0.6f)
+                color = Color.Black.copy(alpha = 0.6f),
             ) {
                 Row(
-                        modifier =
+                    modifier =
-                                Modifier.fillMaxWidth().padding(horizontal = 4.dp, vertical = 8.dp),
+                    Modifier.fillMaxWidth().padding(horizontal = 4.dp, vertical = 8.dp),
-                        verticalAlignment = Alignment.CenterVertically
+                    verticalAlignment = Alignment.CenterVertically,
                 ) {
                     // Back button
                     IconButton(onClick = onDismiss) {
                         Icon(
-                                imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                            imageVector = Icons.AutoMirrored.Filled.ArrowBack,
-                                contentDescription = "Close",
+                            contentDescription = "Close",
-                                tint = Color.White
+                            tint = Color.White,
                         )
                     }
 
@@ -86,9 +86,9 @@ fun FullscreenImageViewer(imagePaths: List<String>, initialIndex: Int = 0, onDis
                     // Image counter
                     if (imagePaths.size > 1) {
                         Text(
-                                text = "${pagerState.currentPage + 1} / ${imagePaths.size}",
+                            text = "${pagerState.currentPage + 1} / ${imagePaths.size}",
-                                color = Color.White,
+                            color = Color.White,
-                                style = MaterialTheme.typography.bodyMedium
+                            style = MaterialTheme.typography.bodyMedium,
                         )
                     }
 
@@ -99,56 +99,56 @@ fun FullscreenImageViewer(imagePaths: List<String>, initialIndex: Int = 0, onDis
             // Thumbnail strip at bottom (if multiple images)
             if (imagePaths.size > 1) {
                 Surface(
-                        modifier = Modifier.fillMaxWidth().align(Alignment.BottomCenter),
+                    modifier = Modifier.fillMaxWidth().align(Alignment.BottomCenter),
-                        color = Color.Black.copy(alpha = 0.6f)
+                    color = Color.Black.copy(alpha = 0.6f),
                 ) {
                     LazyRow(
-                            state = thumbnailListState,
+                        state = thumbnailListState,
-                            modifier = Modifier.padding(vertical = 12.dp),
+                        modifier = Modifier.padding(vertical = 12.dp),
-                            horizontalArrangement = Arrangement.spacedBy(8.dp),
+                        horizontalArrangement = Arrangement.spacedBy(8.dp),
-                            contentPadding = PaddingValues(horizontal = 16.dp)
+                        contentPadding = PaddingValues(horizontal = 16.dp),
                     ) {
                         itemsIndexed(imagePaths) { index, imagePath ->
                             val isSelected = index == pagerState.currentPage
 
                             Box(
-                                    modifier =
+                                modifier =
-                                            Modifier.size(48.dp)
+                                Modifier.size(48.dp)
-                                                    .clip(RoundedCornerShape(8.dp))
+                                    .clip(RoundedCornerShape(8.dp))
-                                                    .clickable {
+                                    .clickable {
-                                                        coroutineScope.launch {
+                                        coroutineScope.launch {
-                                                            pagerState.animateScrollToPage(index)
+                                            pagerState.animateScrollToPage(index)
-                                                        }
+                                        }
-                                                    }
+                                    },
                             ) {
                                 OrientationAwareImage(
-                                        imagePath = imagePath,
+                                    imagePath = imagePath,
-                                        contentDescription = "Thumbnail ${index + 1}",
+                                    contentDescription = "Thumbnail ${index + 1}",
-                                        modifier = Modifier.fillMaxSize(),
+                                    modifier = Modifier.fillMaxSize(),
-                                        contentScale = ContentScale.Crop
+                                    contentScale = ContentScale.Crop,
                                 )
 
                                 // Selection indicator
                                 if (isSelected) {
                                     Box(
-                                            modifier =
+                                        modifier =
-                                                    Modifier.fillMaxSize()
+                                        Modifier.fillMaxSize()
-                                                            .background(
+                                            .background(
-                                                                    Color.White.copy(alpha = 0.3f),
+                                                Color.White.copy(alpha = 0.3f),
-                                                                    RoundedCornerShape(8.dp)
+                                                RoundedCornerShape(8.dp),
-                                                            )
+                                            ),
                                     )
                                     Box(
-                                            modifier =
+                                        modifier =
-                                                    Modifier.fillMaxSize()
+                                        Modifier.fillMaxSize()
-                                                            .background(
+                                            .background(
-                                                                    Color.Transparent,
+                                                Color.Transparent,
-                                                                    RoundedCornerShape(8.dp)
+                                                RoundedCornerShape(8.dp),
-                                                            )
+                                            )
-                                                            .clip(RoundedCornerShape(8.dp))
+                                            .clip(RoundedCornerShape(8.dp))
-                                                            .background(
+                                            .background(
-                                                                    Color.White.copy(alpha = 0.2f)
+                                                Color.White.copy(alpha = 0.2f),
-                                                            )
+                                            ),
                                     )
                                 }
                             }

android/app/src/main/java/com/atridad/ascently/ui/components/ImageDisplay.kt

@@ -15,10 +15,10 @@ import androidx.compose.ui.unit.dp
 
 @Composable
 fun ImageDisplay(
-        imagePaths: List<String>,
+    imagePaths: List<String>,
-        modifier: Modifier = Modifier,
+    modifier: Modifier = Modifier,
-        imageSize: Int = 120,
+    imageSize: Int = 120,
-        onImageClick: ((Int) -> Unit)? = null
+    onImageClick: ((Int) -> Unit)? = null,
 ) {
     LocalContext.current
 
@@ -26,15 +26,15 @@ fun ImageDisplay(
         LazyRow(modifier = modifier, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
             itemsIndexed(imagePaths) { index, imagePath ->
                 OrientationAwareImage(
-                        imagePath = imagePath,
+                    imagePath = imagePath,
-                        contentDescription = "Problem photo",
+                    contentDescription = "Problem photo",
-                        modifier =
+                    modifier =
-                                Modifier.size(imageSize.dp)
+                    Modifier.size(imageSize.dp)
-                                        .clip(RoundedCornerShape(8.dp))
+                        .clip(RoundedCornerShape(8.dp))
-                                        .clickable(enabled = onImageClick != null) {
+                        .clickable(enabled = onImageClick != null) {
-                                            onImageClick?.invoke(index)
+                            onImageClick?.invoke(index)
-                                        },
+                        },
-                        contentScale = ContentScale.Crop
+                    contentScale = ContentScale.Crop,
                 )
             }
         }
@@ -43,17 +43,17 @@ fun ImageDisplay(
 
 @Composable
 fun ImageDisplaySection(
-        imagePaths: List<String>,
+    imagePaths: List<String>,
-        modifier: Modifier = Modifier,
+    modifier: Modifier = Modifier,
-        title: String = "Photos",
+    title: String = "Photos",
-        onImageClick: ((Int) -> Unit)? = null
+    onImageClick: ((Int) -> Unit)? = null,
 ) {
     if (imagePaths.isNotEmpty()) {
         Column(modifier = modifier) {
             Text(
-                    text = title,
+                text = title,
-                    style = MaterialTheme.typography.titleMedium,
+                style = MaterialTheme.typography.titleMedium,
-                    color = MaterialTheme.colorScheme.onSurface
+                color = MaterialTheme.colorScheme.onSurface,
             )
 
             Spacer(modifier = Modifier.height(8.dp))

android/app/src/main/java/com/atridad/ascently/ui/components/ImagePicker.kt

@@ -32,10 +32,10 @@ import java.util.*
 
 @Composable
 fun ImagePicker(
-        imageUris: List<String>,
+    imageUris: List<String>,
-        onImagesChanged: (List<String>) -> Unit,
+    onImagesChanged: (List<String>) -> Unit,
-        modifier: Modifier = Modifier,
+    modifier: Modifier = Modifier,
-        maxImages: Int = 5
+    maxImages: Int = 5,
 ) {
     val context = LocalContext.current
     var tempImageUris by remember { mutableStateOf(imageUris) }
@@ -44,83 +44,83 @@ fun ImagePicker(
 
     // Image picker launcher
     val imagePickerLauncher =
-            rememberLauncherForActivityResult(
+        rememberLauncherForActivityResult(
-                    contract = ActivityResultContracts.GetMultipleContents()
+            contract = ActivityResultContracts.GetMultipleContents(),
-            ) { uris ->
+        ) { uris ->
-                if (uris.isNotEmpty()) {
+            if (uris.isNotEmpty()) {
-                    val currentCount = tempImageUris.size
+                val currentCount = tempImageUris.size
-                    val remainingSlots = maxImages - currentCount
+                val remainingSlots = maxImages - currentCount
-                    val urisToProcess = uris.take(remainingSlots)
+                val urisToProcess = uris.take(remainingSlots)
 
-                    // Process images
+                // Process images
-                    val newImagePaths = mutableListOf<String>()
+                val newImagePaths = mutableListOf<String>()
-                    urisToProcess.forEach { uri ->
+                urisToProcess.forEach { uri ->
-                        val imagePath = ImageUtils.saveTemporaryImageFromUri(context, uri)
+                    val imagePath = ImageUtils.saveTemporaryImageFromUri(context, uri)
-                        if (imagePath != null) {
+                    if (imagePath != null) {
-                            newImagePaths.add(imagePath)
+                        newImagePaths.add(imagePath)
-                        }
                     }
+                }
 
-                    if (newImagePaths.isNotEmpty()) {
+                if (newImagePaths.isNotEmpty()) {
-                        val updatedUris = tempImageUris + newImagePaths
+                    val updatedUris = tempImageUris + newImagePaths
+                    tempImageUris = updatedUris
+                    onImagesChanged(updatedUris)
+                }
+            }
+        }
+
+    // Camera launcher
+    val cameraLauncher =
+        rememberLauncherForActivityResult(contract = ActivityResultContracts.TakePicture()) {
+                success ->
+            if (success) {
+                cameraImageUri?.let { uri ->
+                    val imagePath = ImageUtils.saveTemporaryImageFromUri(context, uri)
+                    if (imagePath != null) {
+                        val updatedUris = tempImageUris + imagePath
                         tempImageUris = updatedUris
                         onImagesChanged(updatedUris)
                     }
                 }
             }
-
+        }
-    // Camera launcher
-    val cameraLauncher =
-            rememberLauncherForActivityResult(contract = ActivityResultContracts.TakePicture()) {
-                    success ->
-                if (success) {
-                    cameraImageUri?.let { uri ->
-                        val imagePath = ImageUtils.saveTemporaryImageFromUri(context, uri)
-                        if (imagePath != null) {
-                            val updatedUris = tempImageUris + imagePath
-                            tempImageUris = updatedUris
-                            onImagesChanged(updatedUris)
-                        }
-                    }
-                }
-            }
 
     // Camera permission launcher
     val cameraPermissionLauncher =
-            rememberLauncherForActivityResult(
+        rememberLauncherForActivityResult(
-                    contract = ActivityResultContracts.RequestPermission()
+            contract = ActivityResultContracts.RequestPermission(),
-            ) { isGranted ->
+        ) { isGranted ->
-                if (isGranted) {
+            if (isGranted) {
-                    // Create image file for camera
+                // Create image file for camera
-                    val imageFile = createImageFile(context)
+                val imageFile = createImageFile(context)
-                    val uri =
+                val uri =
-                            FileProvider.getUriForFile(
+                    FileProvider.getUriForFile(
-                                    context,
+                        context,
-                                    "${context.packageName}.fileprovider",
+                        "${context.packageName}.fileprovider",
-                                    imageFile
+                        imageFile,
-                            )
+                    )
-                    cameraImageUri = uri
+                cameraImageUri = uri
-                    cameraLauncher.launch(uri)
+                cameraLauncher.launch(uri)
-                }
             }
+        }
 
     Column(modifier = modifier) {
         Row(
-                modifier = Modifier.fillMaxWidth(),
+            modifier = Modifier.fillMaxWidth(),
-                horizontalArrangement = Arrangement.SpaceBetween,
+            horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically
+            verticalAlignment = Alignment.CenterVertically,
         ) {
             Text(
-                    text = "Photos (${tempImageUris.size}/$maxImages)",
+                text = "Photos (${tempImageUris.size}/$maxImages)",
-                    style = MaterialTheme.typography.titleMedium
+                style = MaterialTheme.typography.titleMedium,
             )
 
             if (tempImageUris.size < maxImages) {
                 TextButton(onClick = { showImageSourceDialog = true }) {
                     Icon(
-                            Icons.Default.Add,
+                        Icons.Default.Add,
-                            contentDescription = null,
+                        contentDescription = null,
-                            modifier = Modifier.size(16.dp)
+                        modifier = Modifier.size(16.dp),
                     )
                     Spacer(modifier = Modifier.width(4.dp))
                     Text("Add Photos")
@@ -134,42 +134,42 @@ fun ImagePicker(
             LazyRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                 items(tempImageUris) { imagePath ->
                     ImageItem(
-                            imagePath = imagePath,
+                        imagePath = imagePath,
-                            onRemove = {
+                        onRemove = {
-                                val updatedUris = tempImageUris.filter { it != imagePath }
+                            val updatedUris = tempImageUris.filter { it != imagePath }
-                                tempImageUris = updatedUris
+                            tempImageUris = updatedUris
-                                onImagesChanged(updatedUris)
+                            onImagesChanged(updatedUris)
 
-                                // Delete the image file
+                            // Delete the image file
-                                ImageUtils.deleteImage(context, imagePath)
+                            ImageUtils.deleteImage(context, imagePath)
-                            }
+                        },
                     )
                 }
             }
         } else {
             Spacer(modifier = Modifier.height(8.dp))
             Card(
-                    modifier = Modifier.fillMaxWidth().height(100.dp),
+                modifier = Modifier.fillMaxWidth().height(100.dp),
-                    colors =
+                colors =
-                            CardDefaults.cardColors(
+                CardDefaults.cardColors(
-                                    containerColor =
+                    containerColor =
-                                            MaterialTheme.colorScheme.surfaceVariant.copy(
+                    MaterialTheme.colorScheme.surfaceVariant.copy(
-                                                    alpha = 0.3f
+                        alpha = 0.3f,
-                                            )
+                    ),
-                            )
+                ),
             ) {
                 Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
                     Column(horizontalAlignment = Alignment.CenterHorizontally) {
                         Icon(
-                                Icons.Default.Add,
+                            Icons.Default.Add,
-                                contentDescription = null,
+                            contentDescription = null,
-                                tint = MaterialTheme.colorScheme.onSurfaceVariant
+                            tint = MaterialTheme.colorScheme.onSurfaceVariant,
                         )
                         Spacer(modifier = Modifier.height(4.dp))
                         Text(
-                                text = "Add photos of this problem",
+                            text = "Add photos of this problem",
-                                style = MaterialTheme.typography.bodySmall,
+                            style = MaterialTheme.typography.bodySmall,
-                                color = MaterialTheme.colorScheme.onSurfaceVariant
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
                         )
                     }
                 }
@@ -179,67 +179,68 @@ fun ImagePicker(
         // Image Source Selection Dialog
         if (showImageSourceDialog) {
             AlertDialog(
-                    onDismissRequest = { showImageSourceDialog = false },
+                onDismissRequest = { showImageSourceDialog = false },
-                    title = { Text("Add Photo") },
+                title = { Text("Add Photo") },
-                    text = { Text("Choose how you'd like to add a photo") },
+                text = { Text("Choose how you'd like to add a photo") },
-                    confirmButton = {
+                confirmButton = {
-                        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                    Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
-                            TextButton(
+                        TextButton(
-                                    onClick = {
+                            onClick = {
-                                        showImageSourceDialog = false
+                                showImageSourceDialog = false
-                                        imagePickerLauncher.launch("image/*")
+                                imagePickerLauncher.launch("image/*")
-                                    }
+                            },
-                            ) {
+                        ) {
-                                Icon(
+                            Icon(
-                                        Icons.Default.PhotoLibrary,
+                                Icons.Default.PhotoLibrary,
-                                        contentDescription = null,
+                                contentDescription = null,
-                                        modifier = Modifier.size(16.dp)
+                                modifier = Modifier.size(16.dp),
-                                )
+                            )
-                                Spacer(modifier = Modifier.width(4.dp))
+                            Spacer(modifier = Modifier.width(4.dp))
-                                Text("Gallery")
+                            Text("Gallery")
-                            }
+                        }
-
+
-                            TextButton(
+                        TextButton(
-                                    onClick = {
+                            onClick = {
-                                        showImageSourceDialog = false
+                                showImageSourceDialog = false
-                                        when (ContextCompat.checkSelfPermission(
+                                when (
-                                                        context,
+                                    ContextCompat.checkSelfPermission(
-                                                        Manifest.permission.CAMERA
+                                        context,
-                                                )
+                                        Manifest.permission.CAMERA,
-                                        ) {
+                                    )
-                                            PackageManager.PERMISSION_GRANTED -> {
+                                ) {
-                                                // Create image file for camera
+                                    PackageManager.PERMISSION_GRANTED -> {
-                                                val imageFile = createImageFile(context)
+                                        // Create image file for camera
-                                                val uri =
+                                        val imageFile = createImageFile(context)
-                                                        FileProvider.getUriForFile(
+                                        val uri =
-                                                                context,
+                                            FileProvider.getUriForFile(
-                                                                "${context.packageName}.fileprovider",
+                                                context,
-                                                                imageFile
+                                                "${context.packageName}.fileprovider",
-                                                        )
+                                                imageFile,
-                                                cameraImageUri = uri
+                                            )
-                                                cameraLauncher.launch(uri)
+                                        cameraImageUri = uri
-                                            }
+                                        cameraLauncher.launch(uri)
-                                            else -> {
+                                    }
-                                                cameraPermissionLauncher.launch(
+                                    else -> {
-                                                        Manifest.permission.CAMERA
+                                        cameraPermissionLauncher.launch(
-                                                )
+                                            Manifest.permission.CAMERA,
-                                            }
+                                        )
-                                        }
+                                    }
-                                    }
+                                }
-                            ) {
+                            },
-                                Icon(
+                        ) {
-                                        Icons.Default.CameraAlt,
+                            Icon(
-                                        contentDescription = null,
+                                Icons.Default.CameraAlt,
-                                        modifier = Modifier.size(16.dp)
+                                contentDescription = null,
-                                )
+                                modifier = Modifier.size(16.dp),
-                                Spacer(modifier = Modifier.width(4.dp))
+                            )
-                                Text("Camera")
+                            Spacer(modifier = Modifier.width(4.dp))
-                            }
+                            Text("Camera")
                         }
-                    },
-                    dismissButton = {
-                        TextButton(onClick = { showImageSourceDialog = false }) { Text("Cancel") }
                     }
+                },
+                dismissButton = {
+                    TextButton(onClick = { showImageSourceDialog = false }) { Text("Cancel") }
+                },
             )
         }
     }
@@ -259,25 +260,25 @@ private fun ImageItem(imagePath: String, onRemove: () -> Unit, modifier: Modifie
 
     Box(modifier = modifier.size(80.dp)) {
         OrientationAwareImage(
-                imagePath = imagePath,
+            imagePath = imagePath,
-                contentDescription = "Problem photo",
+            contentDescription = "Problem photo",
-                modifier = Modifier.fillMaxSize().clip(RoundedCornerShape(8.dp)),
+            modifier = Modifier.fillMaxSize().clip(RoundedCornerShape(8.dp)),
-                contentScale = ContentScale.Crop
+            contentScale = ContentScale.Crop,
         )
 
         IconButton(onClick = onRemove, modifier = Modifier.align(Alignment.TopEnd).size(24.dp)) {
             Card(
-                    shape = RoundedCornerShape(12.dp),
+                shape = RoundedCornerShape(12.dp),
-                    colors =
+                colors =
-                            CardDefaults.cardColors(
+                CardDefaults.cardColors(
-                                    containerColor = MaterialTheme.colorScheme.errorContainer
+                    containerColor = MaterialTheme.colorScheme.errorContainer,
-                            )
+                ),
             ) {
                 Icon(
-                        Icons.Default.Close,
+                    Icons.Default.Close,
-                        contentDescription = "Remove photo",
+                    contentDescription = "Remove photo",
-                        modifier = Modifier.fillMaxSize().padding(2.dp),
+                    modifier = Modifier.fillMaxSize().padding(2.dp),
-                        tint = MaterialTheme.colorScheme.onErrorContainer
+                    tint = MaterialTheme.colorScheme.onErrorContainer,
                 )
             }
         }

android/app/src/main/java/com/atridad/ascently/ui/components/LineChart.kt

@@ -25,7 +25,7 @@ import androidx.compose.ui.unit.sp
 data class ChartDataPoint(
     val x: Float,
     val y: Float,
-    val label: String? = null
+    val label: String? = null,
 )
 
 /**
@@ -37,7 +37,7 @@ data class ChartStyle(
     val lineWidth: Float = 3f,
     val gridColor: Color,
     val textColor: Color,
-    val backgroundColor: Color
+    val backgroundColor: Color,
 )
 
 /**
@@ -52,11 +52,11 @@ fun LineChart(
         fillColor = MaterialTheme.colorScheme.primary.copy(alpha = 0.2f),
         gridColor = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f),
         textColor = MaterialTheme.colorScheme.onSurfaceVariant,
-        backgroundColor = MaterialTheme.colorScheme.surface
+        backgroundColor = MaterialTheme.colorScheme.surface,
     ),
     showGrid: Boolean = true,
     xAxisFormatter: (Float) -> String = { it.toString() },
-    yAxisFormatter: (Float) -> String = { it.toString() }
+    yAxisFormatter: (Float) -> String = { it.toString() },
 ) {
     val textMeasurer = rememberTextMeasurer()
     val density = LocalDensity.current
@@ -65,7 +65,7 @@ fun LineChart(
         Canvas(
             modifier = Modifier
                 .fillMaxSize()
-                .padding(16.dp)
+                .padding(16.dp),
         ) {
             if (data.isEmpty()) return@Canvas
 
@@ -102,7 +102,7 @@ fun LineChart(
             drawRect(
                 color = style.backgroundColor,
                 topLeft = Offset(padding, padding),
-                size = androidx.compose.ui.geometry.Size(chartWidth, chartHeight)
+                size = androidx.compose.ui.geometry.Size(chartWidth, chartHeight),
             )
 
             // Draw grid
@@ -120,7 +120,7 @@ fun LineChart(
                     textColor = style.textColor,
                     xAxisFormatter = xAxisFormatter,
                     yAxisFormatter = yAxisFormatter,
-                    actualDataPoints = data
+                    actualDataPoints = data,
                 )
             }
 
@@ -130,7 +130,7 @@ fun LineChart(
                     points = screenPoints,
                     padding = padding,
                     chartHeight = chartHeight,
-                    fillColor = style.fillColor
+                    fillColor = style.fillColor,
                 )
             }
 
@@ -139,7 +139,7 @@ fun LineChart(
                 drawLine(
                     points = screenPoints,
                     lineColor = style.lineColor,
-                    lineWidth = style.lineWidth
+                    lineWidth = style.lineWidth,
                 )
             }
 
@@ -149,20 +149,20 @@ fun LineChart(
                 drawCircle(
                     color = style.lineColor,
                     radius = 8f,
-                    center = point
+                    center = point,
                 )
                 // Draw inner circle (white center)
                 drawCircle(
                     color = style.backgroundColor,
                     radius = 5f,
-                    center = point
+                    center = point,
                 )
                 // Draw border for better visibility
                 drawCircle(
                     color = style.lineColor,
                     radius = 8f,
                     center = point,
-                    style = Stroke(width = 2f)
+                    style = Stroke(width = 2f),
                 )
             }
         }
@@ -182,11 +182,11 @@ private fun DrawScope.drawGrid(
     textColor: Color,
     xAxisFormatter: (Float) -> String,
     yAxisFormatter: (Float) -> String,
-    actualDataPoints: List<ChartDataPoint>
+    actualDataPoints: List<ChartDataPoint>,
 ) {
     val textStyle = TextStyle(
         color = textColor,
-        fontSize = 10.sp
+        fontSize = 10.sp,
     )
 
     // Draw vertical grid lines (X-axis) - only at integer values for sessions
@@ -203,7 +203,7 @@ private fun DrawScope.drawGrid(
                 color = gridColor,
                 start = Offset(x, padding),
                 end = Offset(x, padding + chartHeight),
-                strokeWidth = 1.dp.toPx()
+                strokeWidth = 1.dp.toPx(),
             )
 
             // X-axis labels removed per user request
@@ -226,7 +226,7 @@ private fun DrawScope.drawGrid(
                     color = gridColor,
                     start = Offset(padding, y),
                     end = Offset(padding + chartWidth, y),
-                    strokeWidth = 1.dp.toPx()
+                    strokeWidth = 1.dp.toPx(),
                 )
 
                 // Draw label
@@ -238,8 +238,8 @@ private fun DrawScope.drawGrid(
                     style = textStyle,
                     topLeft = Offset(
                         padding - textSize.size.width - 8.dp.toPx(),
-                        y - textSize.size.height / 2f
+                        y - textSize.size.height / 2f,
-                    )
+                    ),
                 )
             }
         }
@@ -250,7 +250,7 @@ private fun DrawScope.drawAreaFill(
     points: List<Offset>,
     padding: Float,
     chartHeight: Float,
-    fillColor: Color
+    fillColor: Color,
 ) {
     val bottomY = padding + chartHeight // This represents the bottom of the chart area
 
@@ -274,14 +274,14 @@ private fun DrawScope.drawAreaFill(
 
     drawPath(
         path = path,
-        color = fillColor
+        color = fillColor,
     )
 }
 
 private fun DrawScope.drawLine(
     points: List<Offset>,
     lineColor: Color,
-    lineWidth: Float
+    lineWidth: Float,
 ) {
     val path = Path().apply {
         moveTo(points.first().x, points.first().y)
@@ -296,7 +296,7 @@ private fun DrawScope.drawLine(
         style = Stroke(
             width = lineWidth,
             cap = StrokeCap.Round,
-            join = StrokeJoin.Round
+            join = StrokeJoin.Round,
-        )
+        ),
     )
 }

android/app/src/main/java/com/atridad/ascently/ui/components/NotificationPermissionDialog.kt

@@ -15,59 +15,59 @@ import androidx.compose.ui.window.DialogProperties
 @Composable
 fun NotificationPermissionDialog(onDismiss: () -> Unit, onRequestPermission: () -> Unit) {
     Dialog(
-            onDismissRequest = onDismiss,
+        onDismissRequest = onDismiss,
-            properties = DialogProperties(dismissOnBackPress = false, dismissOnClickOutside = false)
+        properties = DialogProperties(dismissOnBackPress = false, dismissOnClickOutside = false),
     ) {
         Card(
-                modifier = Modifier.fillMaxWidth().padding(16.dp),
+            modifier = Modifier.fillMaxWidth().padding(16.dp),
-                shape = MaterialTheme.shapes.medium
+            shape = MaterialTheme.shapes.medium,
         ) {
             Column(
-                    modifier = Modifier.padding(24.dp),
+                modifier = Modifier.padding(24.dp),
-                    horizontalAlignment = Alignment.CenterHorizontally
+                horizontalAlignment = Alignment.CenterHorizontally,
             ) {
                 Icon(
-                        imageVector = Icons.Default.Notifications,
+                    imageVector = Icons.Default.Notifications,
-                        contentDescription = "Notifications",
+                    contentDescription = "Notifications",
-                        modifier = Modifier.size(48.dp),
+                    modifier = Modifier.size(48.dp),
-                        tint = MaterialTheme.colorScheme.primary
+                    tint = MaterialTheme.colorScheme.primary,
                 )
 
                 Spacer(modifier = Modifier.height(16.dp))
 
                 Text(
-                        text = "Enable Notifications",
+                    text = "Enable Notifications",
-                        style = MaterialTheme.typography.headlineSmall,
+                    style = MaterialTheme.typography.headlineSmall,
-                        fontWeight = MaterialTheme.typography.headlineSmall.fontWeight,
+                    fontWeight = MaterialTheme.typography.headlineSmall.fontWeight,
-                        textAlign = TextAlign.Center
+                    textAlign = TextAlign.Center,
                 )
 
                 Spacer(modifier = Modifier.height(12.dp))
 
                 Text(
-                        text =
+                    text =
-                                "Ascently needs notification permission to show your active climbing session. This helps you track your progress and ensures the session doesn't get interrupted.",
+                    "Ascently needs notification permission to show your active climbing session. This helps you track your progress and ensures the session doesn't get interrupted.",
-                        style = MaterialTheme.typography.bodyMedium,
+                    style = MaterialTheme.typography.bodyMedium,
-                        textAlign = TextAlign.Center,
+                    textAlign = TextAlign.Center,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                 )
 
                 Spacer(modifier = Modifier.height(24.dp))
 
                 Row(
-                        modifier = Modifier.fillMaxWidth(),
+                    modifier = Modifier.fillMaxWidth(),
-                        horizontalArrangement = Arrangement.spacedBy(12.dp)
+                    horizontalArrangement = Arrangement.spacedBy(12.dp),
                 ) {
                     TextButton(onClick = onDismiss, modifier = Modifier.weight(1f)) {
                         Text("Not Now")
                     }
 
                     Button(
-                            onClick = {
+                        onClick = {
-                                onRequestPermission()
+                            onRequestPermission()
-                                onDismiss()
+                            onDismiss()
-                            },
+                        },
-                            modifier = Modifier.weight(1f)
+                        modifier = Modifier.weight(1f),
                     ) { Text("Enable") }
                 }
             }

android/app/src/main/java/com/atridad/ascently/ui/components/OrientationAwareImage.kt

@@ -16,39 +16,39 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.unit.dp
 import androidx.exifinterface.media.ExifInterface
 import com.atridad.ascently.utils.ImageUtils
-import java.io.File
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
+import java.io.File
 
 @Composable
 fun OrientationAwareImage(
-        imagePath: String,
+    imagePath: String,
-        modifier: Modifier = Modifier,
+    modifier: Modifier = Modifier,
-        contentDescription: String? = null,
+    contentDescription: String? = null,
-        contentScale: ContentScale = ContentScale.Fit
+    contentScale: ContentScale = ContentScale.Fit,
 ) {
     val context = LocalContext.current
     var imageBitmap by
-            remember(imagePath) { mutableStateOf<androidx.compose.ui.graphics.ImageBitmap?>(null) }
+        remember(imagePath) { mutableStateOf<androidx.compose.ui.graphics.ImageBitmap?>(null) }
     var isLoading by remember(imagePath) { mutableStateOf(true) }
 
     LaunchedEffect(imagePath) {
         isLoading = true
         val bitmap =
-                withContext(Dispatchers.IO) {
+            withContext(Dispatchers.IO) {
-                    try {
+                try {
-                        val imageFile = ImageUtils.getImageFile(context, imagePath)
+                    val imageFile = ImageUtils.getImageFile(context, imagePath)
-                        if (!imageFile.exists()) return@withContext null
+                    if (!imageFile.exists()) return@withContext null
 
-                        val originalBitmap =
+                    val originalBitmap =
-                                BitmapFactory.decodeFile(imageFile.absolutePath)
+                        BitmapFactory.decodeFile(imageFile.absolutePath)
-                                        ?: return@withContext null
+                            ?: return@withContext null
-                        val correctedBitmap = correctImageOrientation(imageFile, originalBitmap)
+                    val correctedBitmap = correctImageOrientation(imageFile, originalBitmap)
-                        correctedBitmap.asImageBitmap()
+                    correctedBitmap.asImageBitmap()
-                    } catch (_: Exception) {
+                } catch (_: Exception) {
-                        null
+                    null
-                    }
                 }
+            }
         imageBitmap = bitmap
         isLoading = false
     }
@@ -59,10 +59,10 @@ fun OrientationAwareImage(
         } else {
             imageBitmap?.let { bitmap ->
                 Image(
-                        bitmap = bitmap,
+                    bitmap = bitmap,
-                        contentDescription = contentDescription,
+                    contentDescription = contentDescription,
-                        modifier = Modifier.fillMaxSize(),
+                    modifier = Modifier.fillMaxSize(),
-                        contentScale = contentScale
+                    contentScale = contentScale,
                 )
             }
         }
@@ -70,16 +70,16 @@ fun OrientationAwareImage(
 }
 
 private fun correctImageOrientation(
-        imageFile: File,
+    imageFile: File,
-        bitmap: android.graphics.Bitmap
+    bitmap: android.graphics.Bitmap,
 ): android.graphics.Bitmap {
     return try {
         val exif = ExifInterface(imageFile.absolutePath)
         val orientation =
-                exif.getAttributeInt(
+            exif.getAttributeInt(
-                        ExifInterface.TAG_ORIENTATION,
+                ExifInterface.TAG_ORIENTATION,
-                        ExifInterface.ORIENTATION_NORMAL
+                ExifInterface.ORIENTATION_NORMAL,
-                )
+            )
 
         val matrix = Matrix()
         var needsTransform = false
@@ -124,15 +124,15 @@ private fun correctImageOrientation(
             bitmap
         } else {
             val rotatedBitmap =
-                    android.graphics.Bitmap.createBitmap(
+                android.graphics.Bitmap.createBitmap(
-                            bitmap,
+                    bitmap,
-                            0,
+                    0,
-                            0,
+                    0,
-                            bitmap.width,
+                    bitmap.width,
-                            bitmap.height,
+                    bitmap.height,
-                            matrix,
+                    matrix,
-                            true
+                    true,
-                    )
+                )
             if (rotatedBitmap != bitmap) {
                 bitmap.recycle()
             }

android/app/src/main/java/com/atridad/ascently/ui/components/SyncIndicator.kt

@@ -26,23 +26,23 @@ fun SyncIndicator(isSyncing: StateFlow<Boolean>, modifier: Modifier = Modifier)
     val syncing by isSyncing.collectAsState()
 
     AnimatedVisibility(
-            visible = syncing,
+        visible = syncing,
-            enter = scaleIn() + fadeIn(),
+        enter = scaleIn() + fadeIn(),
-            exit = scaleOut() + fadeOut(),
+        exit = scaleOut() + fadeOut(),
-            modifier = modifier
+        modifier = modifier,
     ) {
         Box(
-                modifier =
+            modifier =
-                        Modifier.size(28.dp)
+            Modifier.size(28.dp)
-                                .clip(CircleShape)
+                .clip(CircleShape)
-                                .background(MaterialTheme.colorScheme.primaryContainer, CircleShape)
+                .background(MaterialTheme.colorScheme.primaryContainer, CircleShape)
-                                .padding(6.dp),
+                .padding(6.dp),
-                contentAlignment = Alignment.Center
+            contentAlignment = Alignment.Center,
         ) {
             CircularProgressIndicator(
-                    modifier = Modifier.size(16.dp),
+                modifier = Modifier.size(16.dp),
-                    strokeWidth = 2.dp,
+                strokeWidth = 2.dp,
-                    color = MaterialTheme.colorScheme.primary
+                color = MaterialTheme.colorScheme.primary,
             )
         }
     }

android/app/src/main/java/com/atridad/ascently/ui/health/HealthConnectCard.kt

@@ -36,19 +36,19 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
 
     // Permission launcher
     val permissionLauncher =
-            rememberLauncherForActivityResult(
+        rememberLauncherForActivityResult(
-                    contract = healthConnectManager.getPermissionRequestContract()
+            contract = healthConnectManager.getPermissionRequestContract(),
-            ) { _ ->
+        ) { _ ->
-                coroutineScope.launch {
+            coroutineScope.launch {
-                    val allGranted = healthConnectManager.hasAllPermissions()
+                val allGranted = healthConnectManager.hasAllPermissions()
-                    if (!allGranted) {
+                if (!allGranted) {
-                        errorMessage =
+                    errorMessage =
-                                "Some Health Connect permissions were not granted. Please grant all permissions to enable syncing."
+                        "Some Health Connect permissions were not granted. Please grant all permissions to enable syncing."
-                    } else {
+                } else {
-                        errorMessage = null
+                    errorMessage = null
-                    }
                 }
             }
+        }
 
     // Check Health Connect availability on first load
     LaunchedEffect(Unit) {
@@ -62,7 +62,7 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
                         errorMessage = "Health Connect is not available on this device"
                     } else if (!isCompatible) {
                         errorMessage =
-                                "Health Connect API compatibility issue. Please update your device or the app."
+                            "Health Connect API compatibility issue. Please update your device or the app."
                     }
                 }
             } catch (e: Exception) {
@@ -73,32 +73,32 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
     }
 
     Card(
-            modifier = modifier.fillMaxWidth(),
+        modifier = modifier.fillMaxWidth(),
-            shape = RoundedCornerShape(16.dp),
+        shape = RoundedCornerShape(16.dp),
-            colors =
+        colors =
-                    CardDefaults.cardColors(
+        CardDefaults.cardColors(
-                            containerColor = MaterialTheme.colorScheme.surfaceVariant
+            containerColor = MaterialTheme.colorScheme.surfaceVariant,
-                    )
+        ),
     ) {
         Column(
-                modifier = Modifier.fillMaxWidth().padding(20.dp),
+            modifier = Modifier.fillMaxWidth().padding(20.dp),
-                horizontalAlignment = Alignment.CenterHorizontally
+            horizontalAlignment = Alignment.CenterHorizontally,
         ) {
             // Header with icon and title
             Row(
                 modifier = Modifier.fillMaxWidth(),
-                verticalAlignment = Alignment.CenterVertically
+                verticalAlignment = Alignment.CenterVertically,
             ) {
                 Icon(
                     imageVector = Icons.Default.HealthAndSafety,
                     contentDescription = null,
                     modifier = Modifier.size(32.dp),
                     tint =
-                        if (isHealthConnectAvailable && isEnabled && hasPermissions) {
+                    if (isHealthConnectAvailable && isEnabled && hasPermissions) {
-                            MaterialTheme.colorScheme.primary
+                        MaterialTheme.colorScheme.primary
-                        } else {
+                    } else {
-                            MaterialTheme.colorScheme.onSurfaceVariant
+                        MaterialTheme.colorScheme.onSurfaceVariant
-                        }
+                    },
                 )
 
                 Spacer(modifier = Modifier.width(12.dp))
@@ -108,40 +108,40 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
                         text = "Health Connect",
                         style = MaterialTheme.typography.titleMedium,
                         fontWeight = FontWeight.Bold,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                     )
 
                     Text(
                         text =
-                            when {
+                        when {
-                                isLoading -> "Checking availability..."
+                            isLoading -> "Checking availability..."
-                                !isCompatible -> "API Issue"
+                            !isCompatible -> "API Issue"
-                                !isHealthConnectAvailable -> "Not available"
+                            !isHealthConnectAvailable -> "Not available"
-                                isEnabled && hasPermissions -> "Connected"
+                            isEnabled && hasPermissions -> "Connected"
-                                isEnabled && !hasPermissions -> "Needs permissions"
+                            isEnabled && !hasPermissions -> "Needs permissions"
-                                else -> "Disabled"
+                            else -> "Disabled"
-                            },
+                        },
                         style = MaterialTheme.typography.bodySmall,
                         color =
-                            when {
+                        when {
-                                isLoading ->
+                            isLoading ->
-                                    MaterialTheme.colorScheme.onSurfaceVariant.copy(
+                                MaterialTheme.colorScheme.onSurfaceVariant.copy(
-                                        alpha = 0.7f
+                                    alpha = 0.7f,
-                                    )
+                                )
 
-                                !isCompatible -> MaterialTheme.colorScheme.error
+                            !isCompatible -> MaterialTheme.colorScheme.error
-                                !isHealthConnectAvailable -> MaterialTheme.colorScheme.error
+                            !isHealthConnectAvailable -> MaterialTheme.colorScheme.error
-                                isEnabled && hasPermissions ->
+                            isEnabled && hasPermissions ->
-                                    MaterialTheme.colorScheme.primary
+                                MaterialTheme.colorScheme.primary
 
-                                isEnabled && !hasPermissions ->
+                            isEnabled && !hasPermissions ->
-                                    MaterialTheme.colorScheme.tertiary
+                                MaterialTheme.colorScheme.tertiary
 
-                                else ->
+                            else ->
-                                    MaterialTheme.colorScheme.onSurfaceVariant.copy(
+                                MaterialTheme.colorScheme.onSurfaceVariant.copy(
-                                        alpha = 0.7f
+                                    alpha = 0.7f,
-                                    )
+                                )
-                            }
+                        },
                     )
                 }
 
@@ -167,7 +167,7 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
                             }
                         }
                     },
-                    enabled = isHealthConnectAvailable && !isLoading && isCompatible
+                    enabled = isHealthConnectAvailable && !isLoading && isCompatible,
                 )
             }
 
@@ -179,7 +179,7 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
                     style = MaterialTheme.typography.bodyMedium,
                     color = MaterialTheme.colorScheme.onSurfaceVariant,
                     textAlign = TextAlign.Center,
-                    modifier = Modifier.fillMaxWidth()
+                    modifier = Modifier.fillMaxWidth(),
                 )
 
                 if (!hasPermissions) {
@@ -187,12 +187,12 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
                     Card(
                         shape = RoundedCornerShape(12.dp),
                         colors =
-                            CardDefaults.cardColors(
+                        CardDefaults.cardColors(
-                                containerColor =
+                            containerColor =
-                                    MaterialTheme.colorScheme.errorContainer.copy(
+                            MaterialTheme.colorScheme.errorContainer.copy(
-                                        alpha = 0.3f
+                                alpha = 0.3f,
-                                    )
+                            ),
-                            )
+                        ),
                     ) {
                         Column(modifier = Modifier.fillMaxWidth().padding(16.dp)) {
                             Row(verticalAlignment = Alignment.CenterVertically) {
@@ -200,7 +200,7 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
                                     imageVector = Icons.Default.Warning,
                                     contentDescription = null,
                                     modifier = Modifier.size(20.dp),
-                                    tint = MaterialTheme.colorScheme.error
+                                    tint = MaterialTheme.colorScheme.error,
                                 )
 
                                 Spacer(modifier = Modifier.width(8.dp))
@@ -209,7 +209,7 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
                                     text = "Permissions needed",
                                     style = MaterialTheme.typography.bodyMedium,
                                     fontWeight = FontWeight.Medium,
-                                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                                 )
                             }
 
@@ -217,12 +217,12 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
 
                             Text(
                                 text =
-                                    "Grant Health Connect permissions to sync your climbing sessions",
+                                "Grant Health Connect permissions to sync your climbing sessions",
                                 style = MaterialTheme.typography.bodySmall,
                                 color =
-                                    MaterialTheme.colorScheme.onSurfaceVariant.copy(
+                                MaterialTheme.colorScheme.onSurfaceVariant.copy(
-                                        alpha = 0.8f
+                                    alpha = 0.8f,
-                                    )
+                                ),
                             )
 
                             Spacer(modifier = Modifier.height(8.dp))
@@ -243,7 +243,7 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
                                         }
                                     }
                                 },
-                                modifier = Modifier.fillMaxWidth()
+                                modifier = Modifier.fillMaxWidth(),
                             ) { Text("Grant Permissions") }
                         }
                     }
@@ -251,10 +251,10 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
                     Spacer(modifier = Modifier.height(16.dp))
                     Text(
                         text =
-                            "Sync your climbing sessions to Samsung Health, Google Fit, and other fitness apps through Health Connect.",
+                        "Sync your climbing sessions to Samsung Health, Google Fit, and other fitness apps through Health Connect.",
                         style = MaterialTheme.typography.bodyMedium,
                         textAlign = TextAlign.Center,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.8f)
+                        color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.8f),
                     )
                 }
                 errorMessage?.let { error ->
@@ -263,22 +263,22 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
                     Card(
                         shape = RoundedCornerShape(8.dp),
                         colors =
-                            CardDefaults.cardColors(
+                        CardDefaults.cardColors(
-                                containerColor =
+                            containerColor =
-                                    MaterialTheme.colorScheme.errorContainer.copy(
+                            MaterialTheme.colorScheme.errorContainer.copy(
-                                        alpha = 0.5f
+                                alpha = 0.5f,
-                                    )
+                            ),
-                            )
+                        ),
                     ) {
                         Row(
                             modifier = Modifier.fillMaxWidth().padding(12.dp),
-                            verticalAlignment = Alignment.CenterVertically
+                            verticalAlignment = Alignment.CenterVertically,
                         ) {
                             Icon(
                                 imageVector = Icons.Default.Warning,
                                 contentDescription = null,
                                 modifier = Modifier.size(16.dp),
-                                tint = MaterialTheme.colorScheme.error
+                                tint = MaterialTheme.colorScheme.error,
                             )
 
                             Spacer(modifier = Modifier.width(8.dp))
@@ -286,7 +286,7 @@ fun HealthConnectCard(modifier: Modifier = Modifier) {
                             Text(
                                 text = error,
                                 style = MaterialTheme.typography.bodySmall,
-                                color = MaterialTheme.colorScheme.onErrorContainer
+                                color = MaterialTheme.colorScheme.onErrorContainer,
                             )
                         }
                     }

android/app/src/main/java/com/atridad/ascently/ui/screens/AnalyticsScreen.kt

@@ -27,27 +27,37 @@ fun AnalyticsScreen(viewModel: ClimbViewModel) {
     val attempts by viewModel.attempts.collectAsState()
     val gyms by viewModel.gyms.collectAsState()
 
+    val gradeDistributionData = remember(sessions, problems, attempts) {
+        calculateGradeDistribution(sessions, problems, attempts)
+    }
+
+    val favoriteGym = remember(sessions, gyms) {
+        sessions.groupBy { it.gymId }.maxByOrNull { it.value.size }?.let { (gymId, sessionList) ->
+            gyms.find { it.id == gymId }?.name to sessionList.size
+        }
+    }
+
     LazyColumn(
-            modifier = Modifier.fillMaxSize().padding(16.dp),
+        modifier = Modifier.fillMaxSize().padding(16.dp),
-            verticalArrangement = Arrangement.spacedBy(16.dp)
+        verticalArrangement = Arrangement.spacedBy(16.dp),
     ) {
         item {
             Row(
-                    modifier = Modifier.fillMaxWidth(),
+                modifier = Modifier.fillMaxWidth(),
-                    verticalAlignment = Alignment.CenterVertically,
+                verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.spacedBy(12.dp)
+                horizontalArrangement = Arrangement.spacedBy(12.dp),
             ) {
                 Icon(
-                        painter = painterResource(id = R.drawable.ic_mountains),
+                    painter = painterResource(id = R.drawable.ic_mountains),
-                        contentDescription = "Ascently Logo",
+                    contentDescription = "Ascently Logo",
-                        modifier = Modifier.size(32.dp),
+                    modifier = Modifier.size(32.dp),
-                        tint = MaterialTheme.colorScheme.primary
+                    tint = MaterialTheme.colorScheme.primary,
                 )
                 Text(
-                        text = "Analytics",
+                    text = "Analytics",
-                        style = MaterialTheme.typography.headlineMedium,
+                    style = MaterialTheme.typography.headlineMedium,
-                        fontWeight = FontWeight.Bold,
+                    fontWeight = FontWeight.Bold,
-                        modifier = Modifier.weight(1f)
+                    modifier = Modifier.weight(1f),
                 )
                 SyncIndicator(isSyncing = viewModel.syncService.isSyncing)
             }
@@ -56,30 +66,23 @@ fun AnalyticsScreen(viewModel: ClimbViewModel) {
         // Overall Stats
         item {
             OverallStatsCard(
-                    totalSessions = sessions.size,
+                totalSessions = sessions.size,
-                    totalProblems = problems.size,
+                totalProblems = problems.size,
-                    totalAttempts = attempts.size,
+                totalAttempts = attempts.size,
-                    totalGyms = gyms.size
+                totalGyms = gyms.size,
             )
         }
 
         // Grade Distribution Chart
         item {
-            val gradeDistributionData = calculateGradeDistribution(sessions, problems, attempts)
             GradeDistributionChartCard(gradeDistributionData = gradeDistributionData)
         }
 
         // Favorite Gym
         item {
-            val favoriteGym =
-                    sessions.groupBy { it.gymId }.maxByOrNull { it.value.size }?.let {
-                            (gymId, sessions) ->
-                        gyms.find { it.id == gymId }?.name to sessions.size
-                    }
-
             FavoriteGymCard(
-                    gymName = favoriteGym?.first ?: "No sessions yet",
+                gymName = favoriteGym?.first ?: "No sessions yet",
-                    sessionCount = favoriteGym?.second ?: 0
+                sessionCount = favoriteGym?.second ?: 0,
             )
         }
 
@@ -96,16 +99,16 @@ fun OverallStatsCard(totalSessions: Int, totalProblems: Int, totalAttempts: Int,
     Card(modifier = Modifier.fillMaxWidth()) {
         Column(modifier = Modifier.fillMaxWidth().padding(16.dp)) {
             Text(
-                    text = "Overall Stats",
+                text = "Overall Stats",
-                    style = MaterialTheme.typography.titleMedium,
+                style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.Bold
+                fontWeight = FontWeight.Bold,
             )
 
             Spacer(modifier = Modifier.height(12.dp))
 
             Row(
-                    modifier = Modifier.fillMaxWidth(),
+                modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.SpaceEvenly
+                horizontalArrangement = Arrangement.SpaceEvenly,
             ) {
                 StatItem(label = "Sessions", value = totalSessions.toString())
                 StatItem(label = "Problems", value = totalProblems.toString())
@@ -121,113 +124,113 @@ fun OverallStatsCard(totalSessions: Int, totalProblems: Int, totalAttempts: Int,
 fun GradeDistributionChartCard(gradeDistributionData: List<GradeDistributionDataPoint>) {
     // Find all grading systems that have been used in the data
     val usedSystems =
-            remember(gradeDistributionData) {
+        remember(gradeDistributionData) {
-                gradeDistributionData.map { it.difficultySystem }.distinct()
+            gradeDistributionData.map { it.difficultySystem }.distinct()
-            }
+        }
 
     var selectedSystem by
-            remember(usedSystems) {
+        remember(usedSystems) {
-                mutableStateOf(usedSystems.firstOrNull() ?: DifficultySystem.V_SCALE)
+            mutableStateOf(usedSystems.firstOrNull() ?: DifficultySystem.V_SCALE)
-            }
+        }
     var expanded by remember { mutableStateOf(false) }
     var showAllTime by remember { mutableStateOf(true) }
 
     Card(modifier = Modifier.fillMaxWidth()) {
         Column(modifier = Modifier.fillMaxWidth().padding(16.dp)) {
             Text(
-                    text = "Grade Distribution",
+                text = "Grade Distribution",
-                    style = MaterialTheme.typography.titleMedium,
+                style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.Bold
+                fontWeight = FontWeight.Bold,
             )
 
             Spacer(modifier = Modifier.height(12.dp))
 
             // Toggles section
             Row(
-                    modifier = Modifier.fillMaxWidth(),
+                modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.SpaceBetween,
+                horizontalArrangement = Arrangement.SpaceBetween,
-                    verticalAlignment = Alignment.CenterVertically
+                verticalAlignment = Alignment.CenterVertically,
             ) {
                 // Time period toggle
                 Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                     // All Time button
                     FilterChip(
-                            onClick = { showAllTime = true },
+                        onClick = { showAllTime = true },
-                            label = {
+                        label = {
-                                Text("All Time", style = MaterialTheme.typography.bodySmall)
+                            Text("All Time", style = MaterialTheme.typography.bodySmall)
-                            },
+                        },
-                            selected = showAllTime,
+                        selected = showAllTime,
-                            colors =
+                        colors =
-                                    FilterChipDefaults.filterChipColors(
+                        FilterChipDefaults.filterChipColors(
-                                            selectedContainerColor =
+                            selectedContainerColor =
-                                                    MaterialTheme.colorScheme.primary,
+                            MaterialTheme.colorScheme.primary,
-                                            selectedLabelColor = MaterialTheme.colorScheme.onPrimary
+                            selectedLabelColor = MaterialTheme.colorScheme.onPrimary,
-                                    )
+                        ),
                     )
 
                     // 7 Days button
                     FilterChip(
-                            onClick = { showAllTime = false },
+                        onClick = { showAllTime = false },
-                            label = { Text("7 Days", style = MaterialTheme.typography.bodySmall) },
+                        label = { Text("7 Days", style = MaterialTheme.typography.bodySmall) },
-                            selected = !showAllTime,
+                        selected = !showAllTime,
-                            colors =
+                        colors =
-                                    FilterChipDefaults.filterChipColors(
+                        FilterChipDefaults.filterChipColors(
-                                            selectedContainerColor =
+                            selectedContainerColor =
-                                                    MaterialTheme.colorScheme.primary,
+                            MaterialTheme.colorScheme.primary,
-                                            selectedLabelColor = MaterialTheme.colorScheme.onPrimary
+                            selectedLabelColor = MaterialTheme.colorScheme.onPrimary,
-                                    )
+                        ),
                     )
                 }
 
                 // Scale selector dropdown
                 if (usedSystems.size > 1) {
                     ExposedDropdownMenuBox(
-                            expanded = expanded,
+                        expanded = expanded,
-                            onExpandedChange = { expanded = !expanded }
+                        onExpandedChange = { expanded = !expanded },
                     ) {
                         OutlinedTextField(
-                                value =
+                            value =
-                                        when (selectedSystem) {
+                            when (selectedSystem) {
-                                            DifficultySystem.V_SCALE -> "V-Scale"
+                                DifficultySystem.V_SCALE -> "V-Scale"
-                                            DifficultySystem.FONT -> "Font"
+                                DifficultySystem.FONT -> "Font"
-                                            DifficultySystem.YDS -> "YDS"
+                                DifficultySystem.YDS -> "YDS"
-                                            DifficultySystem.CUSTOM -> "Custom"
+                                DifficultySystem.CUSTOM -> "Custom"
-                                        },
+                            },
-                                onValueChange = {},
+                            onValueChange = {},
-                                readOnly = true,
+                            readOnly = true,
-                                trailingIcon = {
+                            trailingIcon = {
-                                    ExposedDropdownMenuDefaults.TrailingIcon(expanded = expanded)
+                                ExposedDropdownMenuDefaults.TrailingIcon(expanded = expanded)
-                                },
+                            },
-                                modifier =
+                            modifier =
-                                        Modifier.menuAnchor(
+                            Modifier.menuAnchor(
-                                                        type =
+                                type =
-                                                                ExposedDropdownMenuAnchorType
+                                ExposedDropdownMenuAnchorType
-                                                                        .PrimaryNotEditable,
+                                    .PrimaryNotEditable,
-                                                        enabled = true
+                                enabled = true,
-                                                )
+                            )
-                                                .width(120.dp),
+                                .width(120.dp),
-                                textStyle = MaterialTheme.typography.bodyMedium
+                            textStyle = MaterialTheme.typography.bodyMedium,
                         )
                         ExposedDropdownMenu(
-                                expanded = expanded,
+                            expanded = expanded,
-                                onDismissRequest = { expanded = false }
+                            onDismissRequest = { expanded = false },
                         ) {
                             usedSystems.forEach { system ->
                                 DropdownMenuItem(
-                                        text = {
+                                    text = {
-                                            Text(
+                                        Text(
-                                                    when (system) {
+                                            when (system) {
-                                                        DifficultySystem.V_SCALE -> "V-Scale"
+                                                DifficultySystem.V_SCALE -> "V-Scale"
-                                                        DifficultySystem.FONT -> "Font"
+                                                DifficultySystem.FONT -> "Font"
-                                                        DifficultySystem.YDS -> "YDS"
+                                                DifficultySystem.YDS -> "YDS"
-                                                        DifficultySystem.CUSTOM -> "Custom"
+                                                DifficultySystem.CUSTOM -> "Custom"
-                                                    }
+                                            },
-                                            )
+                                        )
-                                        },
+                                    },
-                                        onClick = {
+                                    onClick = {
-                                            selectedSystem = system
+                                        selectedSystem = system
-                                            expanded = false
+                                        expanded = false
-                                        }
+                                    },
                                 )
                             }
                         }
@@ -239,89 +242,91 @@ fun GradeDistributionChartCard(gradeDistributionData: List<GradeDistributionData
 
             // Filter grade distribution data by selected scale and time period
             val filteredGradeData =
-                    remember(gradeDistributionData, selectedSystem, showAllTime) {
+                remember(gradeDistributionData, selectedSystem, showAllTime) {
-                        val systemFiltered =
+                    val systemFiltered =
-                                gradeDistributionData.filter {
+                        gradeDistributionData.filter {
-                                    it.difficultySystem == selectedSystem
+                            it.difficultySystem == selectedSystem
-                                }
+                        }
 
-                        if (showAllTime) {
+                    if (showAllTime) {
-                            systemFiltered
+                        systemFiltered
-                        } else {
+                    } else {
-                            // Filter for last 7 days
+                        // Filter for last 7 days
-                            val sevenDaysAgo = LocalDateTime.now().minusDays(7)
+                        val sevenDaysAgo = LocalDateTime.now().minusDays(7)
-                            systemFiltered.filter { dataPoint ->
+                        systemFiltered.filter { dataPoint ->
-                                try {
+                            try {
-                                    val attemptDate =
+                                val attemptDate =
-                                            DateFormatUtils.parseToLocalDateTime(dataPoint.date)
+                                    DateFormatUtils.parseToLocalDateTime(dataPoint.date)
-                                    attemptDate?.isAfter(sevenDaysAgo) == true
+                                attemptDate?.isAfter(sevenDaysAgo) == true
-                                } catch (_: Exception) {
+                            } catch (_: Exception) {
-                                    // If date parsing fails, include the data point
+                                // If date parsing fails, include the data point
-                                    true
+                                true
-                                }
                             }
                         }
                     }
+                }
 
             if (filteredGradeData.isNotEmpty()) {
                 // Group by grade and sum counts
                 val gradeGroups =
-                        filteredGradeData
+                    filteredGradeData
-                                .groupBy { it.grade }
+                        .groupBy { it.grade }
-                                .mapValues { (_, dataPoints) -> dataPoints.sumOf { it.count } }
+                        .mapValues { (_, dataPoints) -> dataPoints.sumOf { it.count } }
-                                .map { (grade, count) ->
+                        .map { (grade, count) ->
-                                    val firstDataPoint =
+                            val firstDataPoint =
-                                            filteredGradeData.first { it.grade == grade }
+                                filteredGradeData.first { it.grade == grade }
-                                    BarChartDataPoint(
+                            BarChartDataPoint(
-                                            label = grade,
+                                label = grade,
-                                            value = count,
+                                value = count,
-                                            gradeNumeric = firstDataPoint.gradeNumeric
+                                gradeNumeric = firstDataPoint.gradeNumeric,
-                                    )
+                            )
-                                }
+                        }
 
                 BarChart(data = gradeGroups, modifier = Modifier.fillMaxWidth().height(220.dp))
 
                 Spacer(modifier = Modifier.height(8.dp))
 
                 Text(
-                        text =
+                    text =
-                                "Successful climbs by ${when(selectedSystem) {
+                    "Successful climbs by ${when (selectedSystem) {
                         DifficultySystem.V_SCALE -> "V-grade"
                         DifficultySystem.FONT -> "Font grade"
                         DifficultySystem.YDS -> "YDS grade"
                         DifficultySystem.CUSTOM -> "custom grade"
                     }}",
-                        style = MaterialTheme.typography.bodySmall,
+                    style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                 )
             } else {
                 Column(
-                        modifier = Modifier.fillMaxWidth().height(220.dp),
+                    modifier = Modifier.fillMaxWidth().height(220.dp),
-                        horizontalAlignment = Alignment.CenterHorizontally,
+                    horizontalAlignment = Alignment.CenterHorizontally,
-                        verticalArrangement = Arrangement.Center
+                    verticalArrangement = Arrangement.Center,
                 ) {
                     Icon(
-                            painter = painterResource(id = R.drawable.ic_mountains),
+                        painter = painterResource(id = R.drawable.ic_mountains),
-                            contentDescription = "No data",
+                        contentDescription = "No data",
-                            modifier = Modifier.size(48.dp),
+                        modifier = Modifier.size(48.dp),
-                            tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f)
+                        tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f),
                     )
 
                     Spacer(modifier = Modifier.height(8.dp))
 
                     Text(
-                            text = "No data available.",
+                        text = "No data available.",
-                            style = MaterialTheme.typography.bodyMedium,
+                        style = MaterialTheme.typography.bodyMedium,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                     )
 
                     Text(
-                            text =
+                        text =
-                                    if (showAllTime)
+                        if (showAllTime) {
-                                            "Complete some climbs to see your grade distribution!"
+                            "Complete some climbs to see your grade distribution!"
-                                    else "No climbs in the last 7 days",
+                        } else {
-                            style = MaterialTheme.typography.bodySmall,
+                            "No climbs in the last 7 days"
-                            color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.7f)
+                        },
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.7f),
                     )
                 }
             }
@@ -334,24 +339,24 @@ fun FavoriteGymCard(gymName: String, sessionCount: Int) {
     Card(modifier = Modifier.fillMaxWidth()) {
         Column(modifier = Modifier.fillMaxWidth().padding(16.dp)) {
             Text(
-                    text = "Favorite Gym",
+                text = "Favorite Gym",
-                    style = MaterialTheme.typography.titleMedium,
+                style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.Bold
+                fontWeight = FontWeight.Bold,
             )
 
             Spacer(modifier = Modifier.height(8.dp))
 
             Text(
-                    text = gymName,
+                text = gymName,
-                    style = MaterialTheme.typography.titleLarge,
+                style = MaterialTheme.typography.titleLarge,
-                    fontWeight = FontWeight.Medium
+                fontWeight = FontWeight.Medium,
             )
 
             if (sessionCount > 0) {
                 Text(
-                        text = "$sessionCount sessions",
+                    text = "$sessionCount sessions",
-                        style = MaterialTheme.typography.bodyMedium,
+                    style = MaterialTheme.typography.bodyMedium,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                 )
             }
         }
@@ -363,39 +368,39 @@ fun RecentActivityCard(recentSessions: Int) {
     Card(modifier = Modifier.fillMaxWidth()) {
         Column(modifier = Modifier.fillMaxWidth().padding(16.dp)) {
             Text(
-                    text = "Recent Activity",
+                text = "Recent Activity",
-                    style = MaterialTheme.typography.titleMedium,
+                style = MaterialTheme.typography.titleMedium,
-                    fontWeight = FontWeight.Bold
+                fontWeight = FontWeight.Bold,
             )
 
             Spacer(modifier = Modifier.height(8.dp))
 
             Text(
-                    text =
+                text =
-                            if (recentSessions > 0) {
+                if (recentSessions > 0) {
-                                "You've had $recentSessions recent sessions"
+                    "You've had $recentSessions recent sessions"
-                            } else {
+                } else {
-                                "No recent activity"
+                    "No recent activity"
-                            },
+                },
-                    style = MaterialTheme.typography.bodyMedium
+                style = MaterialTheme.typography.bodyMedium,
             )
         }
     }
 }
 
 data class GradeDistributionDataPoint(
-        val date: String,
+    val date: String,
-        val grade: String,
+    val grade: String,
-        val gradeNumeric: Int,
+    val gradeNumeric: Int,
-        val count: Int,
+    val count: Int,
-        val climbType: ClimbType,
+    val climbType: ClimbType,
-        val difficultySystem: DifficultySystem
+    val difficultySystem: DifficultySystem,
 )
 
 fun calculateGradeDistribution(
-        sessions: List<com.atridad.ascently.data.model.ClimbSession>,
+    sessions: List<com.atridad.ascently.data.model.ClimbSession>,
-        problems: List<com.atridad.ascently.data.model.Problem>,
+    problems: List<com.atridad.ascently.data.model.Problem>,
-        attempts: List<com.atridad.ascently.data.model.Attempt>
+    attempts: List<com.atridad.ascently.data.model.Attempt>,
 ): List<GradeDistributionDataPoint> {
     if (sessions.isEmpty() || problems.isEmpty() || attempts.isEmpty()) {
         return emptyList()
@@ -403,9 +408,9 @@ fun calculateGradeDistribution(
 
     // Get all successful attempts
     val successfulAttempts =
-            attempts.filter {
+        attempts.filter {
-                it.result == AttemptResult.SUCCESS || it.result == AttemptResult.FLASH
+            it.result == AttemptResult.SUCCESS || it.result == AttemptResult.FLASH
-            }
+        }
 
     if (successfulAttempts.isEmpty()) {
         return emptyList()
@@ -426,18 +431,18 @@ fun calculateGradeDistribution(
                 gradeDistribution[key] = existing.copy(count = existing.count + 1)
             } else {
                 gradeDistribution[key] =
-                        GradeDistributionDataPoint(
+                    GradeDistributionDataPoint(
-                                date = attempt.timestamp,
+                        date = attempt.timestamp,
-                                grade = problem.difficulty.grade,
+                        grade = problem.difficulty.grade,
-                                gradeNumeric =
+                        gradeNumeric =
-                                        gradeToNumeric(
+                        gradeToNumeric(
-                                                problem.difficulty.system,
+                            problem.difficulty.system,
-                                                problem.difficulty.grade
+                            problem.difficulty.grade,
-                                        ),
+                        ),
-                                count = 1,
+                        count = 1,
-                                climbType = problem.climbType,
+                        climbType = problem.climbType,
-                                difficultySystem = problem.difficulty.system
+                        difficultySystem = problem.difficulty.system,
-                        )
+                    )
             }
         }
     }

android/app/src/main/java/com/atridad/ascently/ui/screens/GymsScreen.kt

@@ -22,21 +22,21 @@ fun GymsScreen(viewModel: ClimbViewModel, onNavigateToGymDetail: (String) -> Uni
 
     Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
         Row(
-                modifier = Modifier.fillMaxWidth(),
+            modifier = Modifier.fillMaxWidth(),
-                verticalAlignment = Alignment.CenterVertically,
+            verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.spacedBy(12.dp)
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
         ) {
             Icon(
-                    painter = painterResource(id = R.drawable.ic_mountains),
+                painter = painterResource(id = R.drawable.ic_mountains),
-                    contentDescription = "Ascently Logo",
+                contentDescription = "Ascently Logo",
-                    modifier = Modifier.size(32.dp),
+                modifier = Modifier.size(32.dp),
-                    tint = MaterialTheme.colorScheme.primary
+                tint = MaterialTheme.colorScheme.primary,
             )
             Text(
-                    text = "Climbing Gyms",
+                text = "Climbing Gyms",
-                    style = MaterialTheme.typography.headlineMedium,
+                style = MaterialTheme.typography.headlineMedium,
-                    fontWeight = FontWeight.Bold,
+                fontWeight = FontWeight.Bold,
-                    modifier = Modifier.weight(1f)
+                modifier = Modifier.weight(1f),
             )
             SyncIndicator(isSyncing = viewModel.syncService.isSyncing)
         }
@@ -45,14 +45,14 @@ fun GymsScreen(viewModel: ClimbViewModel, onNavigateToGymDetail: (String) -> Uni
 
         if (gyms.isEmpty()) {
             EmptyStateMessage(
-                    title = "No Gyms Added",
+                title = "No Gyms Added",
-                    message = "Add your favorite climbing gyms to start tracking your progress!",
+                message = "Add your favorite climbing gyms to start tracking your progress!",
-                    onActionClick = {},
+                onActionClick = {},
-                    actionText = ""
+                actionText = "",
             )
         } else {
             LazyColumn {
-                items(gyms) { gym ->
+                items(gyms, key = { it.id }) { gym ->
                     GymCard(gym = gym, onClick = { onNavigateToGymDetail(gym.id) })
                     Spacer(modifier = Modifier.height(8.dp))
                 }
@@ -67,17 +67,17 @@ fun GymCard(gym: Gym, onClick: () -> Unit) {
     Card(onClick = onClick, modifier = Modifier.fillMaxWidth()) {
         Column(modifier = Modifier.fillMaxWidth().padding(16.dp)) {
             Text(
-                    text = gym.name,
+                text = gym.name,
-                    style = MaterialTheme.typography.titleLarge,
+                style = MaterialTheme.typography.titleLarge,
-                    fontWeight = FontWeight.Bold
+                fontWeight = FontWeight.Bold,
             )
 
             gym.location?.let { location ->
                 Spacer(modifier = Modifier.height(4.dp))
                 Text(
-                        text = location,
+                    text = location,
-                        style = MaterialTheme.typography.bodyMedium,
+                    style = MaterialTheme.typography.bodyMedium,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                 )
             }
 
@@ -86,9 +86,9 @@ fun GymCard(gym: Gym, onClick: () -> Unit) {
             Row {
                 gym.supportedClimbTypes.forEach { climbType ->
                     AssistChip(
-                            onClick = {},
+                        onClick = {},
-                            label = { Text(climbType.displayName) },
+                        label = { Text(climbType.displayName) },
-                            modifier = Modifier.padding(end = 4.dp)
+                        modifier = Modifier.padding(end = 4.dp),
                     )
                 }
             }
@@ -96,10 +96,10 @@ fun GymCard(gym: Gym, onClick: () -> Unit) {
             if (gym.difficultySystems.isNotEmpty()) {
                 Spacer(modifier = Modifier.height(4.dp))
                 Text(
-                        text =
+                    text =
-                                "Systems: ${gym.difficultySystems.joinToString(", ") { it.displayName }}",
+                    "Systems: ${gym.difficultySystems.joinToString(", ") { it.displayName }}",
-                        style = MaterialTheme.typography.bodySmall,
+                    style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                 )
             }
 
@@ -107,10 +107,10 @@ fun GymCard(gym: Gym, onClick: () -> Unit) {
                 if (notes.isNotBlank()) {
                     Spacer(modifier = Modifier.height(8.dp))
                     Text(
-                            text = notes,
+                        text = notes,
-                            style = MaterialTheme.typography.bodySmall,
+                        style = MaterialTheme.typography.bodySmall,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-                            maxLines = 2
+                        maxLines = 2,
                     )
                 }
             }

android/app/src/main/java/com/atridad/ascently/ui/screens/ProblemsScreen.kt

@@ -35,35 +35,36 @@ fun ProblemsScreen(viewModel: ClimbViewModel, onNavigateToProblemDetail: (String
     var selectedGym by remember { mutableStateOf<Gym?>(null) }
 
     // Apply filters
-    val filteredProblems =
+    val filteredProblems = remember(problems, selectedClimbType, selectedGym) {
-            problems.filter { problem ->
+        problems.filter { problem ->
-                val climbTypeMatch = selectedClimbType?.let { it == problem.climbType } != false
+            val climbTypeMatch = selectedClimbType?.let { it == problem.climbType } != false
-                val gymMatch = selectedGym?.let { it.id == problem.gymId } != false
+            val gymMatch = selectedGym?.let { it.id == problem.gymId } != false
-                climbTypeMatch && gymMatch
+            climbTypeMatch && gymMatch
-            }
+        }
+    }
 
     // Separate active and inactive problems
-    val activeProblems = filteredProblems.filter { it.isActive }
+    val activeProblems = remember(filteredProblems) { filteredProblems.filter { it.isActive } }
-    val inactiveProblems = filteredProblems.filter { !it.isActive }
+    val inactiveProblems = remember(filteredProblems) { filteredProblems.filter { !it.isActive } }
-    val sortedProblems = activeProblems + inactiveProblems
+    val sortedProblems = remember(activeProblems, inactiveProblems) { activeProblems + inactiveProblems }
 
     Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
         Row(
-                modifier = Modifier.fillMaxWidth(),
+            modifier = Modifier.fillMaxWidth(),
-                verticalAlignment = Alignment.CenterVertically,
+            verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.spacedBy(12.dp)
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
         ) {
             Icon(
-                    painter = painterResource(id = R.drawable.ic_mountains),
+                painter = painterResource(id = R.drawable.ic_mountains),
-                    contentDescription = "Ascently Logo",
+                contentDescription = "Ascently Logo",
-                    modifier = Modifier.size(32.dp),
+                modifier = Modifier.size(32.dp),
-                    tint = MaterialTheme.colorScheme.primary
+                tint = MaterialTheme.colorScheme.primary,
             )
             Text(
-                    text = "Climbing Problems",
+                text = "Climbing Problems",
-                    style = MaterialTheme.typography.headlineMedium,
+                style = MaterialTheme.typography.headlineMedium,
-                    fontWeight = FontWeight.Bold,
+                fontWeight = FontWeight.Bold,
-                    modifier = Modifier.weight(1f)
+                modifier = Modifier.weight(1f),
             )
             SyncIndicator(isSyncing = viewModel.syncService.isSyncing)
         }
@@ -75,18 +76,18 @@ fun ProblemsScreen(viewModel: ClimbViewModel, onNavigateToProblemDetail: (String
             Card(modifier = Modifier.fillMaxWidth()) {
                 Column(modifier = Modifier.padding(16.dp)) {
                     Text(
-                            text = "Filters",
+                        text = "Filters",
-                            style = MaterialTheme.typography.titleMedium,
+                        style = MaterialTheme.typography.titleMedium,
-                            fontWeight = FontWeight.Bold
+                        fontWeight = FontWeight.Bold,
                     )
 
                     Spacer(modifier = Modifier.height(12.dp))
 
                     // Climb Type Filter
                     Text(
-                            text = "Climb Type",
+                        text = "Climb Type",
-                            style = MaterialTheme.typography.bodyMedium,
+                        style = MaterialTheme.typography.bodyMedium,
-                            fontWeight = FontWeight.Medium
+                        fontWeight = FontWeight.Medium,
                     )
 
                     Spacer(modifier = Modifier.height(8.dp))
@@ -94,16 +95,16 @@ fun ProblemsScreen(viewModel: ClimbViewModel, onNavigateToProblemDetail: (String
                     LazyRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                         item {
                             FilterChip(
-                                    onClick = { selectedClimbType = null },
+                                onClick = { selectedClimbType = null },
-                                    label = { Text("All Types") },
+                                label = { Text("All Types") },
-                                    selected = selectedClimbType == null
+                                selected = selectedClimbType == null,
                             )
                         }
                         items(ClimbType.entries) { climbType ->
                             FilterChip(
-                                    onClick = { selectedClimbType = climbType },
+                                onClick = { selectedClimbType = climbType },
-                                    label = { Text(climbType.displayName) },
+                                label = { Text(climbType.displayName) },
-                                    selected = selectedClimbType == climbType
+                                selected = selectedClimbType == climbType,
                             )
                         }
                     }
@@ -112,9 +113,9 @@ fun ProblemsScreen(viewModel: ClimbViewModel, onNavigateToProblemDetail: (String
 
                     // Gym Filter
                     Text(
-                            text = "Gym",
+                        text = "Gym",
-                            style = MaterialTheme.typography.bodyMedium,
+                        style = MaterialTheme.typography.bodyMedium,
-                            fontWeight = FontWeight.Medium
+                        fontWeight = FontWeight.Medium,
                     )
 
                     Spacer(modifier = Modifier.height(8.dp))
@@ -122,16 +123,16 @@ fun ProblemsScreen(viewModel: ClimbViewModel, onNavigateToProblemDetail: (String
                     LazyRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                         item {
                             FilterChip(
-                                    onClick = { selectedGym = null },
+                                onClick = { selectedGym = null },
-                                    label = { Text("All Gyms") },
+                                label = { Text("All Gyms") },
-                                    selected = selectedGym == null
+                                selected = selectedGym == null,
                             )
                         }
                         items(gyms) { gym ->
                             FilterChip(
-                                    onClick = { selectedGym = gym },
+                                onClick = { selectedGym = gym },
-                                    label = { Text(gym.name) },
+                                label = { Text(gym.name) },
-                                    selected = selectedGym?.id == gym.id
+                                selected = selectedGym?.id == gym.id,
                             )
                         }
                     }
@@ -140,10 +141,10 @@ fun ProblemsScreen(viewModel: ClimbViewModel, onNavigateToProblemDetail: (String
                     if (selectedClimbType != null || selectedGym != null) {
                         Spacer(modifier = Modifier.height(12.dp))
                         Text(
-                                text =
+                            text =
-                                        "Showing ${filteredProblems.size} of ${problems.size} problems (${activeProblems.size} active, ${inactiveProblems.size} reset)",
+                            "Showing ${filteredProblems.size} of ${problems.size} problems (${activeProblems.size} active, ${inactiveProblems.size} reset)",
-                                style = MaterialTheme.typography.bodySmall,
+                            style = MaterialTheme.typography.bodySmall,
-                                color = MaterialTheme.colorScheme.onSurfaceVariant
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
                         )
                     }
                 }
@@ -154,35 +155,37 @@ fun ProblemsScreen(viewModel: ClimbViewModel, onNavigateToProblemDetail: (String
 
         if (filteredProblems.isEmpty()) {
             EmptyStateMessage(
-                    title =
+                title =
-                            if (problems.isEmpty()) {
+                if (problems.isEmpty()) {
-                                if (gyms.isEmpty()) "No Gyms Available" else "No Problems Yet"
+                    if (gyms.isEmpty()) "No Gyms Available" else "No Problems Yet"
-                            } else {
+                } else {
-                                "No Problems Match Filters"
+                    "No Problems Match Filters"
-                            },
+                },
-                    message =
+                message =
-                            if (problems.isEmpty()) {
+                if (problems.isEmpty()) {
-                                if (gyms.isEmpty())
+                    if (gyms.isEmpty()) {
-                                        "Add a gym first to start tracking problems and routes!"
+                        "Add a gym first to start tracking problems and routes!"
-                                else "Start tracking your favorite problems and routes!"
+                    } else {
-                            } else {
+                        "Start tracking your favorite problems and routes!"
-                                "Try adjusting your filters to see more problems."
+                    }
-                            },
+                } else {
-                    onActionClick = {},
+                    "Try adjusting your filters to see more problems."
-                    actionText = ""
+                },
+                onActionClick = {},
+                actionText = "",
             )
         } else {
             LazyColumn {
-                items(sortedProblems) { problem ->
+                    items(sortedProblems, key = { it.id }) { problem ->
                     ProblemCard(
-                            problem = problem,
+                        problem = problem,
-                            gymName = gyms.find { it.id == problem.gymId }?.name ?: "Unknown Gym",
+                        gymName = gyms.find { it.id == problem.gymId }?.name ?: "Unknown Gym",
-                            attempts = attempts,
+                        attempts = attempts,
-                            onClick = { onNavigateToProblemDetail(problem.id) },
+                        onClick = { onNavigateToProblemDetail(problem.id) },
-                            onToggleActive = {
+                        onToggleActive = {
-                                val updatedProblem = problem.copy(isActive = !problem.isActive)
+                            val updatedProblem = problem.copy(isActive = !problem.isActive)
-                                viewModel.updateProblem(updatedProblem)
+                            viewModel.updateProblem(updatedProblem)
-                            }
+                        },
                     )
                     Spacer(modifier = Modifier.height(8.dp))
                 }
@@ -194,81 +197,86 @@ fun ProblemsScreen(viewModel: ClimbViewModel, onNavigateToProblemDetail: (String
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun ProblemCard(
-        problem: Problem,
+    problem: Problem,
-        gymName: String,
+    gymName: String,
-        attempts: List<Attempt>,
+    attempts: List<Attempt>,
-        onClick: () -> Unit,
+    onClick: () -> Unit,
-        onToggleActive: (() -> Unit)? = null
+    onToggleActive: (() -> Unit)? = null,
 ) {
     val isCompleted =
-            attempts.any { attempt ->
+        attempts.any { attempt ->
-                attempt.problemId == problem.id &&
+            attempt.problemId == problem.id &&
-                        (attempt.result == AttemptResult.SUCCESS ||
+                (
-                                attempt.result == AttemptResult.FLASH)
+                    attempt.result == AttemptResult.SUCCESS ||
-            }
+                        attempt.result == AttemptResult.FLASH
+                    )
+        }
 
     Card(onClick = onClick, modifier = Modifier.fillMaxWidth()) {
         Column(modifier = Modifier.fillMaxWidth().padding(16.dp)) {
             Row(
-                    modifier = Modifier.fillMaxWidth(),
+                modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.SpaceBetween,
+                horizontalArrangement = Arrangement.SpaceBetween,
-                    verticalAlignment = Alignment.Top
+                verticalAlignment = Alignment.Top,
             ) {
                 Column(modifier = Modifier.weight(1f)) {
                     Text(
-                            text = problem.name ?: "Unnamed Problem",
+                        text = problem.name ?: "Unnamed Problem",
-                            style = MaterialTheme.typography.titleMedium,
+                        style = MaterialTheme.typography.titleMedium,
-                            fontWeight = FontWeight.Bold,
+                        fontWeight = FontWeight.Bold,
-                            color =
+                        color =
-                                    if (problem.isActive) MaterialTheme.colorScheme.onSurface
+                        if (problem.isActive) {
-                                    else MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
+                            MaterialTheme.colorScheme.onSurface
+                        } else {
+                            MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
+                        },
                     )
 
                     Text(
-                            text = gymName,
+                        text = gymName,
-                            style = MaterialTheme.typography.bodyMedium,
+                        style = MaterialTheme.typography.bodyMedium,
-                            color =
+                        color =
-                                    MaterialTheme.colorScheme.onSurfaceVariant.copy(
+                        MaterialTheme.colorScheme.onSurfaceVariant.copy(
-                                            alpha = if (problem.isActive) 1f else 0.6f
+                            alpha = if (problem.isActive) 1f else 0.6f,
-                                    )
+                        ),
                     )
                 }
 
                 Column(horizontalAlignment = Alignment.End) {
                     Row(
-                            horizontalArrangement = Arrangement.spacedBy(8.dp),
+                        horizontalArrangement = Arrangement.spacedBy(8.dp),
-                            verticalAlignment = Alignment.CenterVertically
+                        verticalAlignment = Alignment.CenterVertically,
                     ) {
                         if (problem.imagePaths.isNotEmpty()) {
                             Icon(
-                                    imageVector = Icons.Default.Image,
+                                imageVector = Icons.Default.Image,
-                                    contentDescription = "Has images",
+                                contentDescription = "Has images",
-                                    modifier = Modifier.size(16.dp),
+                                modifier = Modifier.size(16.dp),
-                                    tint = MaterialTheme.colorScheme.primary
+                                tint = MaterialTheme.colorScheme.primary,
                             )
                         }
 
                         if (isCompleted) {
                             Icon(
-                                    imageVector = Icons.Default.CheckCircle,
+                                imageVector = Icons.Default.CheckCircle,
-                                    contentDescription = "Completed",
+                                contentDescription = "Completed",
-                                    modifier = Modifier.size(16.dp),
+                                modifier = Modifier.size(16.dp),
-                                    tint = MaterialTheme.colorScheme.tertiary
+                                tint = MaterialTheme.colorScheme.tertiary,
                             )
                         }
 
                         Text(
-                                text = problem.difficulty.grade,
+                            text = problem.difficulty.grade,
-                                style = MaterialTheme.typography.titleMedium,
+                            style = MaterialTheme.typography.titleMedium,
-                                fontWeight = FontWeight.Bold,
+                            fontWeight = FontWeight.Bold,
-                                color = MaterialTheme.colorScheme.primary
+                            color = MaterialTheme.colorScheme.primary,
                         )
                     }
 
                     Text(
-                            text = problem.climbType.displayName,
+                        text = problem.climbType.displayName,
-                            style = MaterialTheme.typography.bodySmall,
+                        style = MaterialTheme.typography.bodySmall,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
                     )
                 }
             }
@@ -276,9 +284,9 @@ fun ProblemCard(
             problem.location?.let { location ->
                 Spacer(modifier = Modifier.height(4.dp))
                 Text(
-                        text = "Location: $location",
+                    text = "Location: $location",
-                        style = MaterialTheme.typography.bodySmall,
+                    style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                 )
             }
 
@@ -287,9 +295,9 @@ fun ProblemCard(
                 Row {
                     problem.tags.take(3).forEach { tag ->
                         AssistChip(
-                                onClick = {},
+                            onClick = {},
-                                label = { Text(tag) },
+                            label = { Text(tag) },
-                                modifier = Modifier.padding(end = 4.dp)
+                            modifier = Modifier.padding(end = 4.dp),
                         )
                     }
                 }
@@ -298,10 +306,10 @@ fun ProblemCard(
             if (!problem.isActive) {
                 Spacer(modifier = Modifier.height(8.dp))
                 Text(
-                        text = "Reset / No Longer Set",
+                    text = "Reset / No Longer Set",
-                        style = MaterialTheme.typography.bodySmall,
+                    style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.tertiary,
+                    color = MaterialTheme.colorScheme.tertiary,
-                        fontWeight = FontWeight.Medium
+                    fontWeight = FontWeight.Medium,
                 )
             }
 
@@ -309,19 +317,21 @@ fun ProblemCard(
             if (onToggleActive != null) {
                 Spacer(modifier = Modifier.height(8.dp))
                 OutlinedButton(
-                        onClick = onToggleActive,
+                    onClick = onToggleActive,
-                        colors =
+                    colors =
-                                ButtonDefaults.outlinedButtonColors(
+                    ButtonDefaults.outlinedButtonColors(
-                                        contentColor =
+                        contentColor =
-                                                if (problem.isActive)
+                        if (problem.isActive) {
-                                                        MaterialTheme.colorScheme.tertiary
+                            MaterialTheme.colorScheme.tertiary
-                                                else MaterialTheme.colorScheme.primary
+                        } else {
-                                ),
+                            MaterialTheme.colorScheme.primary
-                        modifier = Modifier.fillMaxWidth()
+                        },
+                    ),
+                    modifier = Modifier.fillMaxWidth(),
                 ) {
                     Text(
-                            text = if (problem.isActive) "Mark as Reset" else "Mark as Active",
+                        text = if (problem.isActive) "Mark as Reset" else "Mark as Active",
-                            style = MaterialTheme.typography.bodySmall
+                        style = MaterialTheme.typography.bodySmall,
                     )
                 }
             }

android/app/src/main/java/com/atridad/ascently/ui/screens/SessionsScreen.kt

@@ -5,8 +5,6 @@ import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.grid.GridCells
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
 import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -26,6 +24,7 @@ import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
+import androidx.core.content.edit
 import com.atridad.ascently.R
 import com.atridad.ascently.data.model.ClimbSession
 import com.atridad.ascently.data.model.SessionStatus
@@ -41,7 +40,7 @@ import java.util.Locale
 
 enum class ViewMode {
     LIST,
-    CALENDAR
+    CALENDAR,
 }
 
 @OptIn(ExperimentalMaterial3Api::class)
@@ -54,51 +53,58 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
     val uiState by viewModel.uiState.collectAsState()
 
     val sharedPreferences =
-            context.getSharedPreferences("SessionsPreferences", Context.MODE_PRIVATE)
+        context.getSharedPreferences("SessionsPreferences", Context.MODE_PRIVATE)
     val savedViewMode = sharedPreferences.getString("view_mode", "LIST")
     var viewMode by remember {
         mutableStateOf(if (savedViewMode == "CALENDAR") ViewMode.CALENDAR else ViewMode.LIST)
     }
     var selectedMonth by remember { mutableStateOf(YearMonth.now()) }
-    var selectedDate by remember { mutableStateOf<LocalDate?>(null) }
+    var selectedDate by remember { mutableStateOf<LocalDate?>(LocalDate.now()) }
 
-    val completedSessions = sessions.filter { it.status == SessionStatus.COMPLETED }
+    val completedSessions = remember(sessions) {
-    val activeSessionGym = activeSession?.let { session -> gyms.find { it.id == session.gymId } }
+        sessions.filter { it.status == SessionStatus.COMPLETED }
+    }
+    val activeSessionGym = remember(activeSession, gyms) {
+        activeSession?.let { session -> gyms.find { it.id == session.gymId } }
+    }
 
     Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
         Row(
-                modifier = Modifier.fillMaxWidth(),
+            modifier = Modifier.fillMaxWidth(),
-                verticalAlignment = Alignment.CenterVertically,
+            verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.spacedBy(12.dp)
+            horizontalArrangement = Arrangement.spacedBy(12.dp),
         ) {
             Icon(
-                    painter = painterResource(id = R.drawable.ic_mountains),
+                painter = painterResource(id = R.drawable.ic_mountains),
-                    contentDescription = "Ascently Logo",
+                contentDescription = "Ascently Logo",
-                    modifier = Modifier.size(32.dp),
+                modifier = Modifier.size(32.dp),
-                    tint = MaterialTheme.colorScheme.primary
+                tint = MaterialTheme.colorScheme.primary,
             )
             Text(
-                    text = "Climbing Sessions",
+                text = "Climbing Sessions",
-                    style = MaterialTheme.typography.headlineMedium,
+                style = MaterialTheme.typography.headlineMedium,
-                    fontWeight = FontWeight.Bold,
+                fontWeight = FontWeight.Bold,
-                    modifier = Modifier.weight(1f)
+                modifier = Modifier.weight(1f),
             )
 
             IconButton(
-                    onClick = {
+                onClick = {
-                        viewMode =
+                    viewMode =
-                                if (viewMode == ViewMode.LIST) ViewMode.CALENDAR else ViewMode.LIST
+                        if (viewMode == ViewMode.LIST) ViewMode.CALENDAR else ViewMode.LIST
-                        selectedDate = null
+                    selectedDate = null
-                        sharedPreferences.edit().putString("view_mode", viewMode.name).apply()
+                    sharedPreferences.edit { putString("view_mode", viewMode.name) }
-                    }
+                },
             ) {
                 Icon(
-                        imageVector =
+                    imageVector =
-                                if (viewMode == ViewMode.LIST) Icons.Default.CalendarMonth
+                    if (viewMode == ViewMode.LIST) {
-                                else Icons.AutoMirrored.Filled.List,
+                        Icons.Default.CalendarMonth
-                        contentDescription =
+                    } else {
-                                if (viewMode == ViewMode.LIST) "Calendar View" else "List View",
+                        Icons.AutoMirrored.Filled.List
-                        tint = MaterialTheme.colorScheme.primary
+                    },
+                    contentDescription =
+                    if (viewMode == ViewMode.LIST) "Calendar View" else "List View",
+                    tint = MaterialTheme.colorScheme.primary,
                 )
             }
 
@@ -108,10 +114,10 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
         Spacer(modifier = Modifier.height(16.dp))
 
         ActiveSessionBanner(
-                activeSession = activeSession,
+            activeSession = activeSession,
-                gym = activeSessionGym,
+            gym = activeSessionGym,
-                onSessionClick = { activeSession?.let { onNavigateToSessionDetail(it.id) } },
+            onSessionClick = { activeSession?.let { onNavigateToSessionDetail(it.id) } },
-                onEndSession = { activeSession?.let { viewModel.endSession(context, it.id) } }
+            onEndSession = { activeSession?.let { viewModel.endSession(context, it.id) } },
         )
 
         if (activeSession != null) {
@@ -120,24 +126,26 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
 
         if (completedSessions.isEmpty() && activeSession == null) {
             EmptyStateMessage(
-                    title = if (gyms.isEmpty()) "No Gyms Available" else "No Sessions Yet",
+                title = if (gyms.isEmpty()) "No Gyms Available" else "No Sessions Yet",
-                    message =
+                message =
-                            if (gyms.isEmpty())
+                if (gyms.isEmpty()) {
-                                    "Add a gym first to start tracking your climbing sessions!"
+                    "Add a gym first to start tracking your climbing sessions!"
-                            else "Start your first climbing session!",
+                } else {
-                    onActionClick = {},
+                    "Start your first climbing session!"
-                    actionText = ""
+                },
+                onActionClick = {},
+                actionText = "",
             )
         } else {
             when (viewMode) {
                 ViewMode.LIST -> {
                     LazyColumn {
-                        items(completedSessions) { session ->
+                        items(completedSessions, key = { it.id }) { session ->
                             SessionCard(
-                                    session = session,
+                                session = session,
-                                    gymName = gyms.find { it.id == session.gymId }?.name
+                                gymName = gyms.find { it.id == session.gymId }?.name
-                                                    ?: "Unknown Gym",
+                                    ?: "Unknown Gym",
-                                    onClick = { onNavigateToSessionDetail(session.id) }
+                                onClick = { onNavigateToSessionDetail(session.id) },
                             )
                             Spacer(modifier = Modifier.height(8.dp))
                         }
@@ -145,18 +153,13 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
                 }
                 ViewMode.CALENDAR -> {
                     CalendarView(
-                            sessions = completedSessions,
+                        sessions = completedSessions,
-                            gyms = gyms,
+                        gyms = gyms,
-                            activeSession = activeSession,
+                        selectedMonth = selectedMonth,
-                            activeSessionGym = activeSessionGym,
+                        onMonthChange = { selectedMonth = it },
-                            selectedMonth = selectedMonth,
+                        selectedDate = selectedDate,
-                            onMonthChange = { selectedMonth = it },
+                        onDateSelected = { selectedDate = it },
-                            selectedDate = selectedDate,
+                        onNavigateToSessionDetail = onNavigateToSessionDetail,
-                            onDateSelected = { selectedDate = it },
-                            onNavigateToSessionDetail = onNavigateToSessionDetail,
-                            onEndSession = {
-                                activeSession?.let { viewModel.endSession(context, it.id) }
-                            }
                     )
                 }
             }
@@ -170,27 +173,27 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
         }
 
         Card(
-                modifier = Modifier.fillMaxWidth().padding(16.dp),
+            modifier = Modifier.fillMaxWidth().padding(16.dp),
-                colors =
+            colors =
-                        CardDefaults.cardColors(
+            CardDefaults.cardColors(
-                                containerColor = MaterialTheme.colorScheme.primaryContainer
+                containerColor = MaterialTheme.colorScheme.primaryContainer,
-                        ),
+            ),
-                shape = RoundedCornerShape(12.dp)
+            shape = RoundedCornerShape(12.dp),
         ) {
             Row(
-                    modifier = Modifier.fillMaxWidth().padding(16.dp),
+                modifier = Modifier.fillMaxWidth().padding(16.dp),
-                    verticalAlignment = Alignment.CenterVertically
+                verticalAlignment = Alignment.CenterVertically,
             ) {
                 Icon(
-                        Icons.Default.CheckCircle,
+                    Icons.Default.CheckCircle,
-                        contentDescription = null,
+                    contentDescription = null,
-                        tint = MaterialTheme.colorScheme.primary
+                    tint = MaterialTheme.colorScheme.primary,
                 )
                 Spacer(modifier = Modifier.width(8.dp))
                 Text(
-                        text = message,
+                    text = message,
-                        style = MaterialTheme.typography.bodyMedium,
+                    style = MaterialTheme.typography.bodyMedium,
-                        color = MaterialTheme.colorScheme.onPrimaryContainer
+                    color = MaterialTheme.colorScheme.onPrimaryContainer,
                 )
             }
         }
@@ -203,27 +206,27 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
         }
 
         Card(
-                modifier = Modifier.fillMaxWidth().padding(16.dp),
+            modifier = Modifier.fillMaxWidth().padding(16.dp),
-                colors =
+            colors =
-                        CardDefaults.cardColors(
+            CardDefaults.cardColors(
-                                containerColor = MaterialTheme.colorScheme.errorContainer
+                containerColor = MaterialTheme.colorScheme.errorContainer,
-                        ),
+            ),
-                shape = RoundedCornerShape(12.dp)
+            shape = RoundedCornerShape(12.dp),
         ) {
             Row(
-                    modifier = Modifier.fillMaxWidth().padding(16.dp),
+                modifier = Modifier.fillMaxWidth().padding(16.dp),
-                    verticalAlignment = Alignment.CenterVertically
+                verticalAlignment = Alignment.CenterVertically,
             ) {
                 Icon(
-                        Icons.Default.Warning,
+                    Icons.Default.Warning,
-                        contentDescription = null,
+                    contentDescription = null,
-                        tint = MaterialTheme.colorScheme.error
+                    tint = MaterialTheme.colorScheme.error,
                 )
                 Spacer(modifier = Modifier.width(8.dp))
                 Text(
-                        text = error,
+                    text = error,
-                        style = MaterialTheme.typography.bodyMedium,
+                    style = MaterialTheme.typography.bodyMedium,
-                        color = MaterialTheme.colorScheme.onErrorContainer
+                    color = MaterialTheme.colorScheme.onErrorContainer,
                 )
             }
         }
@@ -233,21 +236,25 @@ fun SessionsScreen(viewModel: ClimbViewModel, onNavigateToSessionDetail: (String
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
 fun SessionCard(session: ClimbSession, gymName: String, onClick: () -> Unit) {
+    val formattedDate = remember(session.date) {
+        DateFormatUtils.formatDateForDisplay(session.date)
+    }
+
     Card(onClick = onClick, modifier = Modifier.fillMaxWidth()) {
         Column(modifier = Modifier.fillMaxWidth().padding(16.dp)) {
             Row(
-                    modifier = Modifier.fillMaxWidth(),
+                modifier = Modifier.fillMaxWidth(),
-                    horizontalArrangement = Arrangement.SpaceBetween
+                horizontalArrangement = Arrangement.SpaceBetween,
             ) {
                 Text(
-                        text = gymName,
+                    text = gymName,
-                        style = MaterialTheme.typography.titleMedium,
+                    style = MaterialTheme.typography.titleMedium,
-                        fontWeight = FontWeight.Bold
+                    fontWeight = FontWeight.Bold,
                 )
                 Text(
-                        text = formatDate(session.date),
+                    text = formattedDate,
-                        style = MaterialTheme.typography.bodyMedium,
+                    style = MaterialTheme.typography.bodyMedium,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                 )
             }
 
@@ -255,8 +262,8 @@ fun SessionCard(session: ClimbSession, gymName: String, onClick: () -> Unit) {
 
             session.duration?.let { duration ->
                 Text(
-                        text = "Duration: $duration minutes",
+                    text = "Duration: $duration minutes",
-                        style = MaterialTheme.typography.bodyMedium
+                    style = MaterialTheme.typography.bodyMedium,
                 )
             }
 
@@ -264,10 +271,10 @@ fun SessionCard(session: ClimbSession, gymName: String, onClick: () -> Unit) {
                 if (notes.isNotBlank()) {
                     Spacer(modifier = Modifier.height(4.dp))
                     Text(
-                            text = notes,
+                        text = notes,
-                            style = MaterialTheme.typography.bodySmall,
+                        style = MaterialTheme.typography.bodySmall,
-                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-                            maxLines = 2
+                        maxLines = 2,
                     )
                 }
             }
@@ -277,30 +284,30 @@ fun SessionCard(session: ClimbSession, gymName: String, onClick: () -> Unit) {
 
 @Composable
 fun EmptyStateMessage(
-        title: String,
+    title: String,
-        message: String,
+    message: String,
-        onActionClick: () -> Unit,
+    onActionClick: () -> Unit,
-        actionText: String
+    actionText: String,
 ) {
     Column(
-            modifier = Modifier.fillMaxSize(),
+        modifier = Modifier.fillMaxSize(),
-            horizontalAlignment = Alignment.CenterHorizontally,
+        horizontalAlignment = Alignment.CenterHorizontally,
-            verticalArrangement = Arrangement.Center
+        verticalArrangement = Arrangement.Center,
     ) {
         Text(
-                text = title,
+            text = title,
-                style = MaterialTheme.typography.headlineSmall,
+            style = MaterialTheme.typography.headlineSmall,
-                fontWeight = FontWeight.Bold,
+            fontWeight = FontWeight.Bold,
-                textAlign = TextAlign.Center
+            textAlign = TextAlign.Center,
         )
 
         Spacer(modifier = Modifier.height(8.dp))
 
         Text(
-                text = message,
+            text = message,
-                style = MaterialTheme.typography.bodyLarge,
+            style = MaterialTheme.typography.bodyLarge,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = TextAlign.Center
+            textAlign = TextAlign.Center,
         )
 
         if (actionText.isNotEmpty()) {
@@ -313,66 +320,74 @@ fun EmptyStateMessage(
 
 @Composable
 fun CalendarView(
-        sessions: List<ClimbSession>,
+    sessions: List<ClimbSession>,
-        gyms: List<com.atridad.ascently.data.model.Gym>,
+    gyms: List<com.atridad.ascently.data.model.Gym>,
-        activeSession: ClimbSession?,
+    selectedMonth: YearMonth,
-        activeSessionGym: com.atridad.ascently.data.model.Gym?,
+    onMonthChange: (YearMonth) -> Unit,
-        selectedMonth: YearMonth,
+    selectedDate: LocalDate?,
-        onMonthChange: (YearMonth) -> Unit,
+    onDateSelected: (LocalDate?) -> Unit,
-        selectedDate: LocalDate?,
+    onNavigateToSessionDetail: (String) -> Unit,
-        onDateSelected: (LocalDate?) -> Unit,
-        onNavigateToSessionDetail: (String) -> Unit,
-        onEndSession: () -> Unit
 ) {
     val sessionsByDate =
-            remember(sessions) {
+        remember(sessions) {
-                sessions.groupBy {
+            sessions.groupBy {
-                    try {
+                try {
-                        java.time.Instant.parse(it.date)
+                    java.time.Instant.parse(it.date)
-                                .atZone(java.time.ZoneId.systemDefault())
+                        .atZone(java.time.ZoneId.systemDefault())
-                                .toLocalDate()
+                        .toLocalDate()
-                    } catch (e: Exception) {
+                } catch (_: Exception) {
-                        LocalDate.parse(it.date, DateTimeFormatter.ISO_LOCAL_DATE)
+                    LocalDate.parse(it.date, DateTimeFormatter.ISO_LOCAL_DATE)
-                    }
                 }
             }
+        }
 
-    Column(modifier = Modifier.fillMaxSize()) {
+    val firstDayOfMonth = selectedMonth.atDay(1)
-        Card(
+    val daysInMonth = selectedMonth.lengthOfMonth()
+    val firstDayOfWeek = firstDayOfMonth.dayOfWeek.value % 7
+    val totalCells =
+        ((firstDayOfWeek + daysInMonth) / 7.0).let {
+            if (it == it.toInt().toDouble()) it.toInt() * 7 else (it.toInt() + 1) * 7
+        }
+    val numRows = totalCells / 7
+
+    LazyColumn(modifier = Modifier.fillMaxSize()) {
+        item {
+            Card(
                 modifier = Modifier.fillMaxWidth(),
                 colors =
-                        CardDefaults.cardColors(
+                CardDefaults.cardColors(
-                                containerColor = MaterialTheme.colorScheme.surfaceVariant
+                    containerColor = MaterialTheme.colorScheme.surfaceVariant,
-                        )
+                ),
-        ) {
-            Column(
-                    modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 12.dp),
-                    horizontalAlignment = Alignment.CenterHorizontally
             ) {
-                Row(
+                Column(
+                    modifier =
+                    Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 12.dp),
+                    horizontalAlignment = Alignment.CenterHorizontally,
+                ) {
+                    Row(
                         modifier = Modifier.fillMaxWidth(),
                         horizontalArrangement = Arrangement.SpaceBetween,
-                        verticalAlignment = Alignment.CenterVertically
+                        verticalAlignment = Alignment.CenterVertically,
-                ) {
+                    ) {
-                    IconButton(onClick = { onMonthChange(selectedMonth.minusMonths(1)) }) {
+                        IconButton(onClick = { onMonthChange(selectedMonth.minusMonths(1)) }) {
-                        Text("‹", style = MaterialTheme.typography.headlineMedium)
+                            Text("‹", style = MaterialTheme.typography.headlineMedium)
-                    }
+                        }
 
-                    Text(
+                        Text(
                             text =
-                                    "${selectedMonth.month.getDisplayName(TextStyle.FULL, Locale.getDefault())} ${selectedMonth.year}",
+                            "${selectedMonth.month.getDisplayName(TextStyle.FULL, Locale.getDefault())} ${selectedMonth.year}",
                             style = MaterialTheme.typography.titleMedium,
-                            fontWeight = FontWeight.Bold
+                            fontWeight = FontWeight.Bold,
-                    )
+                        )
 
-                    IconButton(onClick = { onMonthChange(selectedMonth.plusMonths(1)) }) {
+                        IconButton(onClick = { onMonthChange(selectedMonth.plusMonths(1)) }) {
-                        Text("›", style = MaterialTheme.typography.headlineMedium)
+                            Text("›", style = MaterialTheme.typography.headlineMedium)
+                        }
                     }
-                }
 
-                Spacer(modifier = Modifier.height(8.dp))
+                    Spacer(modifier = Modifier.height(8.dp))
 
-                Button(
+                    Button(
                         onClick = {
                             val today = LocalDate.now()
                             onMonthChange(YearMonth.from(today))
@@ -380,68 +395,66 @@ fun CalendarView(
                         },
                         shape = RoundedCornerShape(50),
                         colors =
-                                ButtonDefaults.buttonColors(
+                        ButtonDefaults.buttonColors(
-                                        containerColor = MaterialTheme.colorScheme.primary
+                            containerColor = MaterialTheme.colorScheme.primary,
-                                ),
+                        ),
-                        contentPadding = PaddingValues(horizontal = 20.dp, vertical = 8.dp)
+                        contentPadding = PaddingValues(horizontal = 20.dp, vertical = 8.dp),
-                ) {
+                    ) {
-                    Text(
+                        Text(
                             text = "Today",
                             style = MaterialTheme.typography.labelLarge,
-                            fontWeight = FontWeight.SemiBold
+                            fontWeight = FontWeight.SemiBold,
-                    )
+                        )
+                    }
                 }
             }
-        }
 
-        Spacer(modifier = Modifier.height(16.dp))
+            Spacer(modifier = Modifier.height(16.dp))
 
-        Row(modifier = Modifier.fillMaxWidth()) {
+            Row(modifier = Modifier.fillMaxWidth()) {
-            listOf("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat").forEach { day ->
+                listOf("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat").forEach { day ->
-                Text(
+                    Text(
                         text = day,
                         modifier = Modifier.weight(1f),
                         textAlign = TextAlign.Center,
                         style = MaterialTheme.typography.labelSmall,
                         color = MaterialTheme.colorScheme.onSurfaceVariant,
-                        fontWeight = FontWeight.Bold
+                        fontWeight = FontWeight.Bold,
-                )
+                    )
+                }
             }
+
+            Spacer(modifier = Modifier.height(8.dp))
         }
 
-        Spacer(modifier = Modifier.height(8.dp))
+        items(numRows) { rowIndex ->
+            Row(modifier = Modifier.fillMaxWidth()) {
+                for (colIndex in 0 until 7) {
+                    val index = rowIndex * 7 + colIndex
+                    val dayNumber = index - firstDayOfWeek + 1
 
-        val firstDayOfMonth = selectedMonth.atDay(1)
+                    Box(modifier = Modifier.weight(1f)) {
-        val daysInMonth = selectedMonth.lengthOfMonth()
+                        if (dayNumber in 1..daysInMonth) {
-        val firstDayOfWeek = firstDayOfMonth.dayOfWeek.value % 7
+                            val date = selectedMonth.atDay(dayNumber)
-        val totalCells =
+                            val sessionsOnDate = sessionsByDate[date] ?: emptyList()
-                ((firstDayOfWeek + daysInMonth) / 7.0).let {
+                            val isSelected = date == selectedDate
-                    if (it == it.toInt().toDouble()) it.toInt() * 7 else (it.toInt() + 1) * 7
+                            val isToday = date == LocalDate.now()
-                }
 
-        LazyVerticalGrid(columns = GridCells.Fixed(7), modifier = Modifier.fillMaxWidth()) {
+                            CalendarDay(
-            items(totalCells) { index ->
+                                day = dayNumber,
-                val dayNumber = index - firstDayOfWeek + 1
+                                hasSession = sessionsOnDate.isNotEmpty(),
-
+                                isSelected = isSelected,
-                if (dayNumber in 1..daysInMonth) {
+                                isToday = isToday,
-                    val date = selectedMonth.atDay(dayNumber)
+                                onClick = {
-                    val sessionsOnDate = sessionsByDate[date] ?: emptyList()
+                                    if (sessionsOnDate.isNotEmpty()) {
-                    val isSelected = date == selectedDate
+                                        onDateSelected(if (isSelected) null else date)
-                    val isToday = date == LocalDate.now()
+                                    }
-
+                                },
-                    CalendarDay(
+                            )
-                            day = dayNumber,
+                        } else {
-                            hasSession = sessionsOnDate.isNotEmpty(),
+                            Spacer(modifier = Modifier.aspectRatio(1f))
-                            isSelected = isSelected,
+                        }
-                            isToday = isToday,
+                    }
-                            onClick = {
-                                if (sessionsOnDate.isNotEmpty()) {
-                                    onDateSelected(if (isSelected) null else date)
-                                }
-                            }
-                    )
-                } else {
-                    Spacer(modifier = Modifier.aspectRatio(1f))
                 }
             }
         }
@@ -449,88 +462,88 @@ fun CalendarView(
         if (selectedDate != null) {
             val sessionsOnSelectedDate = sessionsByDate[selectedDate] ?: emptyList()
 
-            Spacer(modifier = Modifier.height(16.dp))
+            item {
+                Spacer(modifier = Modifier.height(16.dp))
 
-            Text(
+                Text(
                     text =
-                            "Sessions on ${selectedDate.format(DateTimeFormatter.ofPattern("MMMM d, yyyy"))}",
+                    "Sessions on ${selectedDate.format(DateTimeFormatter.ofPattern("MMMM d, yyyy"))}",
                     style = MaterialTheme.typography.titleSmall,
                     fontWeight = FontWeight.Bold,
-                    modifier = Modifier.padding(vertical = 8.dp)
+                    modifier = Modifier.padding(vertical = 8.dp),
-            )
+                )
-
-            LazyColumn(modifier = Modifier.fillMaxWidth()) {
-                items(sessionsOnSelectedDate) { session ->
-                    SessionCard(
-                            session = session,
-                            gymName = gyms.find { it.id == session.gymId }?.name ?: "Unknown Gym",
-                            onClick = { onNavigateToSessionDetail(session.id) }
-                    )
-                    Spacer(modifier = Modifier.height(8.dp))
-                }
             }
+
+            items(sessionsOnSelectedDate) { session ->
+                SessionCard(
+                    session = session,
+                    gymName = gyms.find { it.id == session.gymId }?.name ?: "Unknown Gym",
+                    onClick = { onNavigateToSessionDetail(session.id) },
+                )
+                Spacer(modifier = Modifier.height(8.dp))
+            }
+
+            item { Spacer(modifier = Modifier.height(16.dp)) }
         }
     }
 }
 
 @Composable
 fun CalendarDay(
-        day: Int,
+    day: Int,
-        hasSession: Boolean,
+    hasSession: Boolean,
-        isSelected: Boolean,
+    isSelected: Boolean,
-        isToday: Boolean,
+    isToday: Boolean,
-        onClick: () -> Unit
+    onClick: () -> Unit,
 ) {
     Box(
-            modifier =
+        modifier =
-                    Modifier.aspectRatio(1f)
+        Modifier.aspectRatio(1f)
-                            .padding(2.dp)
+            .padding(2.dp)
-                            .clip(CircleShape)
+            .clip(CircleShape)
-                            .background(
+            .background(
-                                    when {
+                when {
-                                        isSelected -> MaterialTheme.colorScheme.primaryContainer
+                    isSelected -> MaterialTheme.colorScheme.primaryContainer
-                                        isToday -> MaterialTheme.colorScheme.secondaryContainer
+                    isToday -> MaterialTheme.colorScheme.secondaryContainer
-                                        else -> Color.Transparent
+                    else -> Color.Transparent
-                                    }
+                },
-                            )
+            )
-                            .clickable(enabled = hasSession, onClick = onClick),
+            .clickable(enabled = hasSession, onClick = onClick),
-            contentAlignment = Alignment.Center
+        contentAlignment = Alignment.Center,
     ) {
         Column(
-                horizontalAlignment = Alignment.CenterHorizontally,
+            horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.Center
+            verticalArrangement = Arrangement.Center,
         ) {
             Text(
-                    text = day.toString(),
+                text = day.toString(),
-                    style = MaterialTheme.typography.bodyMedium,
+                style = MaterialTheme.typography.bodyMedium,
-                    color =
+                color =
-                            when {
+                when {
-                                isSelected -> MaterialTheme.colorScheme.onPrimaryContainer
+                    isSelected -> MaterialTheme.colorScheme.onPrimaryContainer
-                                isToday -> MaterialTheme.colorScheme.onSecondaryContainer
+                    isToday -> MaterialTheme.colorScheme.onSecondaryContainer
-                                !hasSession -> MaterialTheme.colorScheme.onSurfaceVariant
+                    !hasSession -> MaterialTheme.colorScheme.onSurfaceVariant
-                                else -> MaterialTheme.colorScheme.onSurface
+                    else -> MaterialTheme.colorScheme.onSurface
-                            },
+                },
-                    fontWeight = if (hasSession || isToday) FontWeight.Bold else FontWeight.Normal
+                fontWeight = if (hasSession || isToday) FontWeight.Bold else FontWeight.Normal,
             )
 
             if (hasSession) {
                 Box(
-                        modifier =
+                    modifier =
-                                Modifier.size(6.dp)
+                    Modifier.size(6.dp)
-                                        .clip(CircleShape)
+                        .clip(CircleShape)
-                                        .background(
+                        .background(
-                                                if (isSelected) MaterialTheme.colorScheme.primary
+                            if (isSelected) {
-                                                else
+                                MaterialTheme.colorScheme.primary
-                                                        MaterialTheme.colorScheme.primary.copy(
+                            } else {
-                                                                alpha = 0.7f
+                                MaterialTheme.colorScheme.primary.copy(
-                                                        )
+                                    alpha = 0.7f,
-                                        )
+                                )
+                            },
+                        ),
                 )
             }
         }
     }
 }
-
-private fun formatDate(dateString: String): String {
-    return DateFormatUtils.formatDateForDisplay(dateString)
-}

android/app/src/main/java/com/atridad/ascently/ui/theme/CustomIcons.kt

@@ -12,9 +12,9 @@ object CustomIcons {
         defaultWidth = 24.dp,
         defaultHeight = 24.dp,
         viewportWidth = 24f,
-        viewportHeight = 24f
+        viewportHeight = 24f,
     ).path(
-        fill = SolidColor(color)
+        fill = SolidColor(color),
     ) {
         moveTo(6f, 6f)
         horizontalLineTo(18f)

android/app/src/main/java/com/atridad/ascently/ui/theme/Theme.kt

@@ -47,7 +47,7 @@ private val DarkColorScheme = darkColorScheme(
     surfaceContainerLow = ClimbNeutral10,
     surfaceContainer = ClimbNeutral12,
     surfaceContainerHigh = ClimbNeutral17,
-    surfaceContainerHighest = ClimbNeutral22
+    surfaceContainerHighest = ClimbNeutral22,
 )
 
 // Climbing-themed light color scheme with full Material You compatibility
@@ -84,7 +84,7 @@ private val LightColorScheme = lightColorScheme(
     surfaceContainerLow = ClimbNeutral96,
     surfaceContainer = ClimbNeutral94,
     surfaceContainerHigh = ClimbNeutral92,
-    surfaceContainerHighest = ClimbNeutral90
+    surfaceContainerHighest = ClimbNeutral90,
 )
 
 @Composable
@@ -93,7 +93,7 @@ fun AscentlyTheme(
     // Dynamic color is available on Android 12+ and provides full Material You theming
     // When enabled, it adapts to the user's system wallpaper colors
     dynamicColor: Boolean = true,
-    content: @Composable () -> Unit
+    content: @Composable () -> Unit,
 ) {
     val colorScheme = when {
         dynamicColor && true -> {
@@ -116,6 +116,6 @@ fun AscentlyTheme(
     MaterialTheme(
         colorScheme = colorScheme,
         typography = Typography,
-        content = content
+        content = content,
     )
 }

android/app/src/main/java/com/atridad/ascently/ui/theme/Type.kt

@@ -13,6 +13,6 @@ val Typography = Typography(
         fontWeight = FontWeight.Normal,
         fontSize = 16.sp,
         lineHeight = 24.sp,
-        letterSpacing = 0.5.sp
+        letterSpacing = 0.5.sp,
-    )
+    ),
 )

android/app/src/main/java/com/atridad/ascently/ui/viewmodel/ClimbViewModel.kt

@@ -11,14 +11,14 @@ import com.atridad.ascently.service.SessionTrackingService
 import com.atridad.ascently.utils.AppLogger
 import com.atridad.ascently.utils.ImageUtils
 import com.atridad.ascently.widget.ClimbStatsWidgetProvider
-import java.io.File
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
+import java.io.File
 
 class ClimbViewModel(
     private val repository: ClimbRepository,
     val syncService: SyncService,
-    private val context: Context
+    private val context: Context,
 ) : ViewModel() {
 
     // Health Connect manager
@@ -35,7 +35,7 @@ class ClimbViewModel(
             .stateIn(
                 scope = viewModelScope,
                 started = SharingStarted.WhileSubscribed(),
-                initialValue = emptyList()
+                initialValue = emptyList(),
             )
 
     val problems =
@@ -44,7 +44,7 @@ class ClimbViewModel(
             .stateIn(
                 scope = viewModelScope,
                 started = SharingStarted.WhileSubscribed(),
-                initialValue = emptyList()
+                initialValue = emptyList(),
             )
 
     val sessions =
@@ -53,7 +53,7 @@ class ClimbViewModel(
             .stateIn(
                 scope = viewModelScope,
                 started = SharingStarted.WhileSubscribed(),
-                initialValue = emptyList()
+                initialValue = emptyList(),
             )
 
     val activeSession =
@@ -62,7 +62,7 @@ class ClimbViewModel(
             .stateIn(
                 scope = viewModelScope,
                 started = SharingStarted.WhileSubscribed(),
-                initialValue = null
+                initialValue = null,
             )
 
     val attempts =
@@ -71,7 +71,7 @@ class ClimbViewModel(
             .stateIn(
                 scope = viewModelScope,
                 started = SharingStarted.WhileSubscribed(),
-                initialValue = emptyList()
+                initialValue = emptyList(),
             )
 
     // Gym operations
@@ -243,7 +243,7 @@ class ClimbViewModel(
                 _uiState.value =
                     _uiState.value.copy(
                         error =
-                            "Notification permission is required to track your climbing session. Please enable notifications in settings."
+                        "Notification permission is required to track your climbing session. Please enable notifications in settings.",
                     )
                 return@launch
             }
@@ -253,7 +253,7 @@ class ClimbViewModel(
                 AppLogger.d("ClimbViewModel") { "Active session already exists: ${existingActive.id}" }
                 _uiState.value =
                     _uiState.value.copy(
-                        error = "There's already an active session. Please end it first."
+                        error = "There's already an active session. Please end it first.",
                     )
                 return@launch
             }
@@ -281,7 +281,7 @@ class ClimbViewModel(
                 _uiState.value =
                     _uiState.value.copy(
                         error =
-                            "Notification permission is required to manage your climbing session. Please enable notifications in settings."
+                        "Notification permission is required to manage your climbing session. Please enable notifications in settings.",
                     )
                 return@launch
             }
@@ -354,20 +354,20 @@ class ClimbViewModel(
                 _uiState.value =
                     _uiState.value.copy(
                         isLoading = true,
-                        message = "Creating ZIP file with images..."
+                        message = "Creating ZIP file with images...",
                     )
                 repository.exportAllDataToZipUri(context, uri)
                 _uiState.value =
                     _uiState.value.copy(
                         isLoading = false,
                         message =
-                            "Export complete! Your climbing data and images have been saved."
+                        "Export complete! Your climbing data and images have been saved.",
                     )
             } catch (e: Exception) {
                 _uiState.value =
                     _uiState.value.copy(
                         isLoading = false,
-                        error = "Export failed: ${e.message}"
+                        error = "Export failed: ${e.message}",
                     )
             }
         }
@@ -380,7 +380,7 @@ class ClimbViewModel(
 
                 if (!file.name.lowercase().endsWith(".zip")) {
                     throw Exception(
-                        "Only ZIP files are supported for import. Please use a ZIP file exported from Ascently."
+                        "Only ZIP files are supported for import. Please use a ZIP file exported from Ascently.",
                     )
                 }
 
@@ -389,13 +389,13 @@ class ClimbViewModel(
                 _uiState.value =
                     _uiState.value.copy(
                         isLoading = false,
-                        message = "Data imported successfully from ${file.name}"
+                        message = "Data imported successfully from ${file.name}",
                     )
             } catch (e: Exception) {
                 _uiState.value =
                     _uiState.value.copy(
                         isLoading = false,
-                        error = "Import failed: ${e.message}"
+                        error = "Import failed: ${e.message}",
                     )
             }
         }
@@ -411,11 +411,13 @@ class ClimbViewModel(
     }
 
     // Sync-related methods
-    suspend fun performManualSync() {
+    fun performManualSync() {
-        try {
+        viewModelScope.launch {
-            syncService.syncWithServer()
+            try {
-        } catch (e: Exception) {
+                syncService.syncWithServer()
-            setError("Sync failed: ${e.message}")
+            } catch (e: Exception) {
+                setError("Sync failed: ${e.message}")
+            }
         }
     }
 
@@ -445,7 +447,7 @@ class ClimbViewModel(
                 _uiState.value =
                     _uiState.value.copy(
                         isLoading = false,
-                        message = "All data has been reset successfully"
+                        message = "All data has been reset successfully",
                     )
             } catch (e: Exception) {
                 _uiState.value =
@@ -467,7 +469,7 @@ class ClimbViewModel(
                     healthConnectManager.autoSyncCompletedSession(
                         session,
                         gymName,
-                        attemptCount
+                        attemptCount,
                     )
 
                 result.onFailure { error ->
@@ -487,5 +489,5 @@ class ClimbViewModel(
 data class ClimbUiState(
     val isLoading: Boolean = false,
     val message: String? = null,
-    val error: String? = null
+    val error: String? = null,
 )

android/app/src/main/java/com/atridad/ascently/ui/viewmodel/ClimbViewModelFactory.kt

@@ -7,9 +7,9 @@ import com.atridad.ascently.data.repository.ClimbRepository
 import com.atridad.ascently.data.sync.SyncService
 
 class ClimbViewModelFactory(
-        private val repository: ClimbRepository,
+    private val repository: ClimbRepository,
-        private val syncService: SyncService,
+    private val syncService: SyncService,
-        private val context: Context
+    private val context: Context,
 ) : ViewModelProvider.Factory {
 
     @Suppress("UNCHECKED_CAST")

android/app/src/main/java/com/atridad/ascently/utils/AppLogger.kt

@@ -11,7 +11,7 @@ object AppLogger {
         DEBUG(Log.DEBUG),
         INFO(Log.INFO),
         WARN(Log.WARN),
-        ERROR(Log.ERROR)
+        ERROR(Log.ERROR),
     }
 
     fun d(tag: String = DEFAULT_TAG, messageProvider: () -> String) {
@@ -34,7 +34,7 @@ object AppLogger {
         level: Level,
         tag: String,
         messageProvider: () -> String,
-        throwable: Throwable? = null
+        throwable: Throwable? = null,
     ) {
         if (!BuildConfig.DEBUG) return
 

android/app/src/main/java/com/atridad/ascently/utils/DateFormatUtils.kt

@@ -10,7 +10,7 @@ object DateFormatUtils {
 
     // ISO 8601 formatter matching iOS date format exactly
     private val ISO_FORMATTER =
-            DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSX").withZone(ZoneOffset.UTC)
+        DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSSX").withZone(ZoneOffset.UTC)
 
     /** Get current timestamp in iOS-compatible ISO 8601 format */
     fun nowISO8601(): String {
@@ -22,7 +22,6 @@ object DateFormatUtils {
         return try {
             Instant.from(ISO_FORMATTER.parse(dateString))
         } catch (_: Exception) {
-
             try {
                 Instant.parse(dateString)
             } catch (_: Exception) {

android/app/src/main/java/com/atridad/ascently/utils/ImageNamingUtils.kt

@@ -13,7 +13,7 @@ object ImageNamingUtils {
 
     /** Generates a deterministic filename for a problem image */
     fun generateImageFilename(problemId: String, imageIndex: Int): String {
-        val input = "${problemId}_${imageIndex}"
+        val input = "${problemId}_$imageIndex"
         val hash = createHash(input)
 
         return "problem_${hash}_${imageIndex}${IMAGE_EXTENSION}"

android/app/src/main/java/com/atridad/ascently/utils/ImageUtils.kt

@@ -32,7 +32,7 @@ object ImageUtils {
         context: Context,
         imageUri: Uri,
         originalBitmap: Bitmap,
-        outputFile: File
+        outputFile: File,
     ): Boolean {
         return try {
             // Get EXIF data from original image
@@ -147,12 +147,16 @@ object ImageUtils {
             val imagesDir = getImagesDirectory(context)
             imagesDir.listFiles()?.mapNotNull { file ->
                 if (file.isFile &&
-                    (file.extension == "jpg" ||
+                    (
+                        file.extension == "jpg" ||
                             file.extension == "jpeg" ||
-                            file.extension == "png")
+                            file.extension == "png"
+                        )
                 ) {
                     "$IMAGES_DIR/${file.name}"
-                } else null
+                } else {
+                    null
+                }
             }
                 ?: emptyList()
         } catch (e: Exception) {
@@ -187,7 +191,7 @@ object ImageUtils {
         context: Context,
         tempFilename: String,
         problemId: String,
-        imageIndex: Int
+        imageIndex: Int,
     ): String? {
         return try {
             val tempFile = File(getImagesDirectory(context), tempFilename)
@@ -217,7 +221,7 @@ object ImageUtils {
     fun saveImageFromBytesWithFilename(
         context: Context,
         imageData: ByteArray,
-        filename: String
+        filename: String,
     ): String? {
         return try {
             val imageFile = File(getImagesDirectory(context), filename)

android/app/src/main/java/com/atridad/ascently/utils/MigrationManager.kt

@@ -51,7 +51,7 @@ class MigrationManager(private val context: Context) {
                 "openclimb_data_state" to "ascently_data_state",
                 "health_connect_prefs" to "health_connect_prefs", // Keep same name
                 "deleted_items" to "deleted_items", // Keep same name
-                "sync_preferences" to "sync_preferences" // Keep same name
+                "sync_preferences" to "sync_preferences", // Keep same name
             )
 
         for ((oldFileName, newFileName) in preferenceFileMigrations) {
@@ -82,7 +82,8 @@ class MigrationManager(private val context: Context) {
                         is Float -> putFloat(key, value)
                         is Boolean -> putBoolean(key, value)
                         is Set<*> -> {
-                            @Suppress("UNCHECKED_CAST") putStringSet(key, value as Set<String>)
+                            @Suppress("UNCHECKED_CAST")
+                            putStringSet(key, value as Set<String>)
                         }
                     }
                 }
@@ -108,7 +109,7 @@ class MigrationManager(private val context: Context) {
                 "ascently_data_state",
                 "health_connect_prefs",
                 "deleted_items",
-                "sync_preferences"
+                "sync_preferences",
             )
 
         for (prefFileName in preferencesToCheck) {

android/app/src/main/java/com/atridad/ascently/utils/NotificationPermissionUtils.kt

@@ -13,7 +13,7 @@ object NotificationPermissionUtils {
     fun isNotificationPermissionGranted(context: Context): Boolean {
         return ContextCompat.checkSelfPermission(
             context,
-            Manifest.permission.POST_NOTIFICATIONS
+            Manifest.permission.POST_NOTIFICATIONS,
         ) == PackageManager.PERMISSION_GRANTED
     }
 

android/app/src/main/java/com/atridad/ascently/utils/ShortcutManager.kt

@@ -20,10 +20,10 @@ object AppShortcutManager {
 
     /** Updates the app shortcuts based on current session state */
     fun updateShortcuts(
-            context: Context,
+        context: Context,
-            hasActiveSession: Boolean,
+        hasActiveSession: Boolean,
-            hasGyms: Boolean,
+        hasGyms: Boolean,
-            lastUsedGym: com.atridad.ascently.data.model.Gym? = null
+        lastUsedGym: com.atridad.ascently.data.model.Gym? = null,
     ) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N_MR1) {
             val shortcutManager = context.getSystemService(ShortcutManager::class.java)
@@ -44,52 +44,52 @@ object AppShortcutManager {
 
     @RequiresApi(Build.VERSION_CODES.N_MR1)
     private fun createStartSessionShortcut(
-            context: Context,
+        context: Context,
-            lastUsedGym: com.atridad.ascently.data.model.Gym? = null
+        lastUsedGym: com.atridad.ascently.data.model.Gym? = null,
     ): ShortcutInfo {
         val startIntent =
-                Intent(context, MainActivity::class.java).apply {
+            Intent(context, MainActivity::class.java).apply {
-                    action = ACTION_START_SESSION
+                action = ACTION_START_SESSION
-                    flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP
+                flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP
-                    lastUsedGym?.let { gym -> putExtra("LAST_USED_GYM_ID", gym.id) }
+                lastUsedGym?.let { gym -> putExtra("LAST_USED_GYM_ID", gym.id) }
-                }
+            }
 
         val shortLabel =
-                if (lastUsedGym != null) {
+            if (lastUsedGym != null) {
-                    "Start at ${lastUsedGym.name}"
+                "Start at ${lastUsedGym.name}"
-                } else {
+            } else {
-                    context.getString(R.string.shortcut_start_session_short)
+                context.getString(R.string.shortcut_start_session_short)
-                }
+            }
 
         val longLabel =
-                if (lastUsedGym != null) {
+            if (lastUsedGym != null) {
-                    "Start a new climbing session at ${lastUsedGym.name}"
+                "Start a new climbing session at ${lastUsedGym.name}"
-                } else {
+            } else {
-                    context.getString(R.string.shortcut_start_session_long)
+                context.getString(R.string.shortcut_start_session_long)
-                }
+            }
 
         return ShortcutInfo.Builder(context, SHORTCUT_START_SESSION)
-                .setShortLabel(shortLabel)
+            .setShortLabel(shortLabel)
-                .setLongLabel(longLabel)
+            .setLongLabel(longLabel)
-                .setIcon(Icon.createWithResource(context, R.drawable.ic_play_arrow_24))
+            .setIcon(Icon.createWithResource(context, R.drawable.ic_play_arrow_24))
-                .setIntent(startIntent)
+            .setIntent(startIntent)
-                .build()
+            .build()
     }
 
     @RequiresApi(Build.VERSION_CODES.N_MR1)
     private fun createEndSessionShortcut(context: Context): ShortcutInfo {
         val endIntent =
-                Intent(context, MainActivity::class.java).apply {
+            Intent(context, MainActivity::class.java).apply {
-                    action = ACTION_END_SESSION
+                action = ACTION_END_SESSION
-                    flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP
+                flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP
-                }
+            }
 
         return ShortcutInfo.Builder(context, SHORTCUT_END_SESSION)
-                .setShortLabel(context.getString(R.string.shortcut_end_session_short))
+            .setShortLabel(context.getString(R.string.shortcut_end_session_short))
-                .setLongLabel(context.getString(R.string.shortcut_end_session_long))
+            .setLongLabel(context.getString(R.string.shortcut_end_session_long))
-                .setIcon(Icon.createWithResource(context, R.drawable.ic_stop_24))
+            .setIcon(Icon.createWithResource(context, R.drawable.ic_stop_24))
-                .setIntent(endIntent)
+            .setIntent(endIntent)
-                .build()
+            .build()
     }
 
     /** Removes all dynamic shortcuts */

android/app/src/main/java/com/atridad/ascently/utils/ZipExportImportUtils.kt

@@ -3,6 +3,8 @@ package com.atridad.ascently.utils
 import android.content.Context
 import com.atridad.ascently.data.format.BackupProblem
 import com.atridad.ascently.data.format.ClimbDataBackup
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
@@ -11,8 +13,6 @@ import java.time.LocalDateTime
 import java.util.zip.ZipEntry
 import java.util.zip.ZipInputStream
 import java.util.zip.ZipOutputStream
-import kotlinx.serialization.encodeToString
-import kotlinx.serialization.json.Json
 
 object ZipExportImportUtils {
 
@@ -25,15 +25,15 @@ object ZipExportImportUtils {
         context: Context,
         exportData: ClimbDataBackup,
         referencedImagePaths: Set<String>,
-        directory: File? = null
+        directory: File? = null,
     ): File {
         val exportDir =
             directory
                 ?: File(
                     context.getExternalFilesDir(
-                        android.os.Environment.DIRECTORY_DOCUMENTS
+                        android.os.Environment.DIRECTORY_DOCUMENTS,
                     ),
-                    "Ascently"
+                    "Ascently",
                 )
         if (!exportDir.exists()) {
             exportDir.mkdirs()
@@ -92,7 +92,7 @@ object ZipExportImportUtils {
 
                 // Log export summary
                 AppLogger.i("ZipExportImportUtils") {
-                    "Export completed: ${successfulImages}/${referencedImagePaths.size} images included"
+                    "Export completed: $successfulImages/${referencedImagePaths.size} images included"
                 }
             }
 
@@ -116,7 +116,7 @@ object ZipExportImportUtils {
         context: Context,
         uri: android.net.Uri,
         exportData: ClimbDataBackup,
-        referencedImagePaths: Set<String>
+        referencedImagePaths: Set<String>,
     ) {
         try {
             context.contentResolver.openOutputStream(uri)?.use { outputStream ->
@@ -164,7 +164,7 @@ object ZipExportImportUtils {
                     }
 
                     AppLogger.i("ZipExportImportUtils") {
-                        "Export to URI completed: ${successfulImages}/${referencedImagePaths.size} images included"
+                        "Export to URI completed: $successfulImages/${referencedImagePaths.size} images included"
                     }
                 }
             }
@@ -176,7 +176,7 @@ object ZipExportImportUtils {
 
     private fun createMetadata(
         exportData: ClimbDataBackup,
-        referencedImagePaths: Set<String>
+        referencedImagePaths: Set<String>,
     ): String {
         return buildString {
             appendLine("Ascently Export Metadata")
@@ -195,7 +195,7 @@ object ZipExportImportUtils {
     /** Data class to hold extraction results */
     data class ImportResult(
         val jsonContent: String,
-        val importedImagePaths: Map<String, String> // original filename -> new relative path
+        val importedImagePaths: Map<String, String>, // original filename -> new relative path
     )
 
     /** Extracts a ZIP file and returns the JSON content and imported image paths */
@@ -235,7 +235,7 @@ object ZipExportImportUtils {
                                     File.createTempFile(
                                         "import_image_",
                                         "_$originalFilename",
-                                        context.cacheDir
+                                        context.cacheDir,
                                     )
 
                                 FileOutputStream(tempFile).use { output -> zipIn.copyTo(output) }
@@ -306,7 +306,7 @@ object ZipExportImportUtils {
      */
     fun updateProblemImagePaths(
         problems: List<BackupProblem>,
-        imagePathMapping: Map<String, String>
+        imagePathMapping: Map<String, String>,
     ): List<BackupProblem> {
         return problems.map { problem ->
             val updatedImagePaths =

android/app/src/main/java/com/atridad/ascently/widget/ClimbStatsWidgetProvider.kt

@@ -11,12 +11,12 @@ import com.atridad.ascently.MainActivity
 import com.atridad.ascently.R
 import com.atridad.ascently.data.database.AscentlyDatabase
 import com.atridad.ascently.data.repository.ClimbRepository
-import java.time.LocalDate
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.launch
+import java.time.LocalDate
 
 class ClimbStatsWidgetProvider : AppWidgetProvider() {
 
@@ -24,9 +24,9 @@ class ClimbStatsWidgetProvider : AppWidgetProvider() {
     private val coroutineScope = CoroutineScope(Dispatchers.IO + job)
 
     override fun onUpdate(
-            context: Context,
+        context: Context,
-            appWidgetManager: AppWidgetManager,
+        appWidgetManager: AppWidgetManager,
-            appWidgetIds: IntArray
+        appWidgetIds: IntArray,
     ) {
         for (appWidgetId in appWidgetIds) {
             updateAppWidget(context, appWidgetManager, appWidgetId)
@@ -40,9 +40,9 @@ class ClimbStatsWidgetProvider : AppWidgetProvider() {
     }
 
     private fun updateAppWidget(
-            context: Context,
+        context: Context,
-            appWidgetManager: AppWidgetManager,
+        appWidgetManager: AppWidgetManager,
-            appWidgetId: Int
+        appWidgetId: Int,
     ) {
         coroutineScope.launch {
             try {
@@ -59,20 +59,20 @@ class ClimbStatsWidgetProvider : AppWidgetProvider() {
 
                 // Filter for last 7 days across all gyms
                 val weekSessions =
-                        sessions.filter { session ->
+                    sessions.filter { session ->
-                            try {
+                        try {
-                                val sessionDate = LocalDate.parse(session.date.substring(0, 10))
+                            val sessionDate = LocalDate.parse(session.date.substring(0, 10))
-                                !sessionDate.isBefore(sevenDaysAgo) && !sessionDate.isAfter(today)
+                            !sessionDate.isBefore(sevenDaysAgo) && !sessionDate.isAfter(today)
-                            } catch (_: Exception) {
+                        } catch (_: Exception) {
-                                false
+                            false
-                            }
                         }
+                    }
 
                 val weekSessionIds = weekSessions.map { it.id }.toSet()
 
                 // Count total attempts this week
                 val totalAttempts =
-                        attempts.count { attempt -> weekSessionIds.contains(attempt.sessionId) }
+                    attempts.count { attempt -> weekSessionIds.contains(attempt.sessionId) }
 
                 // Count sessions this week
                 val totalSessions = weekSessions.size
@@ -85,19 +85,19 @@ class ClimbStatsWidgetProvider : AppWidgetProvider() {
                     views.setTextViewText(R.id.widget_sessions_value, totalSessions.toString())
 
                     val intent =
-                            Intent(context, MainActivity::class.java).apply {
+                        Intent(context, MainActivity::class.java).apply {
-                                flags =
+                            flags =
-                                        Intent.FLAG_ACTIVITY_NEW_TASK or
+                                Intent.FLAG_ACTIVITY_NEW_TASK or
-                                                Intent.FLAG_ACTIVITY_CLEAR_TOP
+                                Intent.FLAG_ACTIVITY_CLEAR_TOP
-                            }
+                        }
                     val pendingIntent =
-                            PendingIntent.getActivity(
+                        PendingIntent.getActivity(
-                                    context,
+                            context,
-                                    0,
+                            0,
-                                    intent,
+                            intent,
-                                    PendingIntent.FLAG_UPDATE_CURRENT or
+                            PendingIntent.FLAG_UPDATE_CURRENT or
-                                            PendingIntent.FLAG_IMMUTABLE
+                                PendingIntent.FLAG_IMMUTABLE,
-                            )
+                        )
                     views.setOnClickPendingIntent(R.id.widget_container, pendingIntent)
 
                     appWidgetManager.updateAppWidget(appWidgetId, views)
@@ -110,13 +110,13 @@ class ClimbStatsWidgetProvider : AppWidgetProvider() {
 
                     val intent = Intent(context, MainActivity::class.java)
                     val pendingIntent =
-                            PendingIntent.getActivity(
+                        PendingIntent.getActivity(
-                                    context,
+                            context,
-                                    0,
+                            0,
-                                    intent,
+                            intent,
-                                    PendingIntent.FLAG_UPDATE_CURRENT or
+                            PendingIntent.FLAG_UPDATE_CURRENT or
-                                            PendingIntent.FLAG_IMMUTABLE
+                                PendingIntent.FLAG_IMMUTABLE,
-                            )
+                        )
                     views.setOnClickPendingIntent(R.id.widget_container, pendingIntent)
 
                     appWidgetManager.updateAppWidget(appWidgetId, views)
@@ -132,10 +132,10 @@ class ClimbStatsWidgetProvider : AppWidgetProvider() {
             val appWidgetIds = appWidgetManager.getAppWidgetIds(componentName)
 
             val intent =
-                    Intent(context, ClimbStatsWidgetProvider::class.java).apply {
+                Intent(context, ClimbStatsWidgetProvider::class.java).apply {
-                        action = AppWidgetManager.ACTION_APPWIDGET_UPDATE
+                    action = AppWidgetManager.ACTION_APPWIDGET_UPDATE
-                        putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, appWidgetIds)
+                    putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, appWidgetIds)
-                    }
+                }
             context.sendBroadcast(intent)
         }
     }

android/app/src/main/res/xml/data_extraction_rules.xml

@@ -5,10 +5,6 @@
 -->
 <data-extraction-rules>
     <cloud-backup>
-        <!-- TODO: Use <include> and <exclude> to control what is backed up.
-        <include .../>
-        <exclude .../>
-        -->
     </cloud-backup>
     <!--
     <device-transfer>

android/app/src/test/java/com/atridad/openclimb/BusinessLogicTests.kt

@@ -2,10 +2,10 @@ package com.atridad.ascently
 
 import com.atridad.ascently.data.format.*
 import com.atridad.ascently.data.model.*
-import java.time.LocalDateTime
-import java.time.format.DateTimeFormatter
 import org.junit.Assert.*
 import org.junit.Test
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
 
 class BusinessLogicTests {
 
@@ -21,11 +21,11 @@ class BusinessLogicTests {
         assertNull(session.duration)
 
         val completedSession =
-                session.copy(
+            session.copy(
-                        status = SessionStatus.COMPLETED,
+                status = SessionStatus.COMPLETED,
-                        endTime = getCurrentTimestamp(),
+                endTime = getCurrentTimestamp(),
-                        duration = 7200L
+                duration = 7200L,
-                )
+            )
         assertEquals(SessionStatus.COMPLETED, completedSession.status)
         assertNotNull(completedSession.endTime)
         assertNotNull(completedSession.duration)
@@ -38,12 +38,12 @@ class BusinessLogicTests {
         val session = ClimbSession.create(gym.id)
 
         val attempt =
-                Attempt.create(
+            Attempt.create(
-                        sessionId = session.id,
+                sessionId = session.id,
-                        problemId = problem.id,
+                problemId = problem.id,
-                        result = AttemptResult.SUCCESS,
+                result = AttemptResult.SUCCESS,
-                        notes = "Clean send!"
+                notes = "Clean send!",
-                )
+            )
 
         assertEquals(session.id, attempt.sessionId)
         assertEquals(problem.id, attempt.problemId)
@@ -76,12 +76,12 @@ class BusinessLogicTests {
         val problem2 = createTestProblem(gym.id)
 
         val attempts =
-                listOf(
+            listOf(
-                        Attempt.create(session.id, problem1.id, AttemptResult.SUCCESS),
+                Attempt.create(session.id, problem1.id, AttemptResult.SUCCESS),
-                        Attempt.create(session.id, problem1.id, AttemptResult.FALL),
+                Attempt.create(session.id, problem1.id, AttemptResult.FALL),
-                        Attempt.create(session.id, problem2.id, AttemptResult.FLASH),
+                Attempt.create(session.id, problem2.id, AttemptResult.FLASH),
-                        Attempt.create(session.id, problem2.id, AttemptResult.SUCCESS)
+                Attempt.create(session.id, problem2.id, AttemptResult.SUCCESS),
-                )
+            )
 
         val sessionStats = calculateSessionStatistics(session, attempts)
 
@@ -97,17 +97,17 @@ class BusinessLogicTests {
         val session = ClimbSession.create(gym.id)
 
         val problems =
-                listOf(
+            listOf(
-                        createTestProblemWithGrade(gym.id, "V3"),
+                createTestProblemWithGrade(gym.id, "V3"),
-                        createTestProblemWithGrade(gym.id, "V4"),
+                createTestProblemWithGrade(gym.id, "V4"),
-                        createTestProblemWithGrade(gym.id, "V5"),
+                createTestProblemWithGrade(gym.id, "V5"),
-                        createTestProblemWithGrade(gym.id, "V6")
+                createTestProblemWithGrade(gym.id, "V6"),
-                )
+            )
 
         val attempts =
-                problems.map { problem ->
+            problems.map { problem ->
-                    Attempt.create(session.id, problem.id, AttemptResult.SUCCESS)
+                Attempt.create(session.id, problem.id, AttemptResult.SUCCESS)
-                }
+            }
 
         val progression = calculateDifficultyProgression(attempts, problems)
 
@@ -123,17 +123,17 @@ class BusinessLogicTests {
         val problems = listOf(createTestProblem(gym.id), createTestProblem(gym.id))
         val session = ClimbSession.create(gym.id)
         val attempts =
-                problems.map { problem ->
+            problems.map { problem ->
-                    Attempt.create(session.id, problem.id, AttemptResult.SUCCESS)
+                Attempt.create(session.id, problem.id, AttemptResult.SUCCESS)
-                }
+            }
 
         val backup =
-                createBackupData(
+            createBackupData(
-                        gyms = listOf(gym),
+                gyms = listOf(gym),
-                        problems = problems,
+                problems = problems,
-                        sessions = listOf(session),
+                sessions = listOf(session),
-                        attempts = attempts
+                attempts = attempts,
-                )
+            )
 
         validateBackupIntegrity(backup)
 
@@ -146,30 +146,30 @@ class BusinessLogicTests {
     @Test
     fun testClimbTypeCompatibilityRules() {
         val boulderGym =
-                Gym(
+            Gym(
-                        id = "boulder_gym",
+                id = "boulder_gym",
-                        name = "Boulder Gym",
+                name = "Boulder Gym",
-                        location = "Boulder City",
+                location = "Boulder City",
-                        supportedClimbTypes = listOf(ClimbType.BOULDER),
+                supportedClimbTypes = listOf(ClimbType.BOULDER),
-                        difficultySystems = listOf(DifficultySystem.V_SCALE, DifficultySystem.FONT),
+                difficultySystems = listOf(DifficultySystem.V_SCALE, DifficultySystem.FONT),
-                        customDifficultyGrades = emptyList(),
+                customDifficultyGrades = emptyList(),
-                        notes = null,
+                notes = null,
-                        createdAt = getCurrentTimestamp(),
+                createdAt = getCurrentTimestamp(),
-                        updatedAt = getCurrentTimestamp()
+                updatedAt = getCurrentTimestamp(),
-                )
+            )
 
         val ropeGym =
-                Gym(
+            Gym(
-                        id = "rope_gym",
+                id = "rope_gym",
-                        name = "Rope Gym",
+                name = "Rope Gym",
-                        location = "Rope City",
+                location = "Rope City",
-                        supportedClimbTypes = listOf(ClimbType.ROPE),
+                supportedClimbTypes = listOf(ClimbType.ROPE),
-                        difficultySystems = listOf(DifficultySystem.YDS),
+                difficultySystems = listOf(DifficultySystem.YDS),
-                        customDifficultyGrades = emptyList(),
+                customDifficultyGrades = emptyList(),
-                        notes = null,
+                notes = null,
-                        createdAt = getCurrentTimestamp(),
+                createdAt = getCurrentTimestamp(),
-                        updatedAt = getCurrentTimestamp()
+                updatedAt = getCurrentTimestamp(),
-                )
+            )
 
         // Boulder gym should support boulder problems with V-Scale
         assertTrue(isCompatibleClimbType(boulderGym, ClimbType.BOULDER, DifficultySystem.V_SCALE))
@@ -197,26 +197,26 @@ class BusinessLogicTests {
         val session = ClimbSession.create(gym.id)
 
         val attempts =
-                listOf(
+            listOf(
-                        createAttemptWithTimestamp(
+                createAttemptWithTimestamp(
-                                session.id,
+                    session.id,
-                                problem.id,
+                    problem.id,
-                                "2024-01-01T10:00:00Z",
+                    "2024-01-01T10:00:00Z",
-                                AttemptResult.FALL
+                    AttemptResult.FALL,
-                        ),
+                ),
-                        createAttemptWithTimestamp(
+                createAttemptWithTimestamp(
-                                session.id,
+                    session.id,
-                                problem.id,
+                    problem.id,
-                                "2024-01-01T10:05:00Z",
+                    "2024-01-01T10:05:00Z",
-                                AttemptResult.FALL
+                    AttemptResult.FALL,
-                        ),
+                ),
-                        createAttemptWithTimestamp(
+                createAttemptWithTimestamp(
-                                session.id,
+                    session.id,
-                                problem.id,
+                    problem.id,
-                                "2024-01-01T10:10:00Z",
+                    "2024-01-01T10:10:00Z",
-                                AttemptResult.SUCCESS
+                    AttemptResult.SUCCESS,
-                        )
+                ),
-                )
+            )
 
         val sequence = AttemptSequence(attempts)
 
@@ -230,32 +230,32 @@ class BusinessLogicTests {
     @Test
     fun testGradeConsistencyValidation() {
         val validCombinations =
-                listOf(
+            listOf(
-                        Pair(ClimbType.BOULDER, DifficultySystem.V_SCALE),
+                Pair(ClimbType.BOULDER, DifficultySystem.V_SCALE),
-                        Pair(ClimbType.BOULDER, DifficultySystem.FONT),
+                Pair(ClimbType.BOULDER, DifficultySystem.FONT),
-                        Pair(ClimbType.ROPE, DifficultySystem.YDS),
+                Pair(ClimbType.ROPE, DifficultySystem.YDS),
-                        Pair(ClimbType.BOULDER, DifficultySystem.CUSTOM),
+                Pair(ClimbType.BOULDER, DifficultySystem.CUSTOM),
-                        Pair(ClimbType.ROPE, DifficultySystem.CUSTOM)
+                Pair(ClimbType.ROPE, DifficultySystem.CUSTOM),
-                )
+            )
 
         val invalidCombinations =
-                listOf(
+            listOf(
-                        Pair(ClimbType.BOULDER, DifficultySystem.YDS),
+                Pair(ClimbType.BOULDER, DifficultySystem.YDS),
-                        Pair(ClimbType.ROPE, DifficultySystem.V_SCALE),
+                Pair(ClimbType.ROPE, DifficultySystem.V_SCALE),
-                        Pair(ClimbType.ROPE, DifficultySystem.FONT)
+                Pair(ClimbType.ROPE, DifficultySystem.FONT),
-                )
+            )
 
         validCombinations.forEach { (climbType, difficultySystem) ->
             assertTrue(
-                    "$climbType should be compatible with $difficultySystem",
+                "$climbType should be compatible with $difficultySystem",
-                    isValidGradeCombination(climbType, difficultySystem)
+                isValidGradeCombination(climbType, difficultySystem),
             )
         }
 
         invalidCombinations.forEach { (climbType, difficultySystem) ->
             assertFalse(
-                    "$climbType should not be compatible with $difficultySystem",
+                "$climbType should not be compatible with $difficultySystem",
-                    isValidGradeCombination(climbType, difficultySystem)
+                isValidGradeCombination(climbType, difficultySystem),
             )
         }
     }
@@ -276,11 +276,11 @@ class BusinessLogicTests {
     @Test
     fun testImagePathHandling() {
         val originalPaths =
-                listOf(
+            listOf(
-                        "/storage/images/problem1.jpg",
+                "/storage/images/problem1.jpg",
-                        "/data/cache/problem2.png",
+                "/data/cache/problem2.png",
-                        "relative/path/problem3.jpeg"
+                "relative/path/problem3.jpeg",
-                )
+            )
 
         val relativePaths = convertToRelativePaths(originalPaths)
 
@@ -295,76 +295,76 @@ class BusinessLogicTests {
 
     private fun createTestGym(): Gym {
         return Gym(
-                id = "test_gym_1",
+            id = "test_gym_1",
-                name = "Test Climbing Gym",
+            name = "Test Climbing Gym",
-                location = "Test City",
+            location = "Test City",
-                supportedClimbTypes = listOf(ClimbType.BOULDER, ClimbType.ROPE),
+            supportedClimbTypes = listOf(ClimbType.BOULDER, ClimbType.ROPE),
-                difficultySystems = listOf(DifficultySystem.V_SCALE, DifficultySystem.YDS),
+            difficultySystems = listOf(DifficultySystem.V_SCALE, DifficultySystem.YDS),
-                customDifficultyGrades = emptyList(),
+            customDifficultyGrades = emptyList(),
-                notes = "Test gym for unit testing",
+            notes = "Test gym for unit testing",
-                createdAt = getCurrentTimestamp(),
+            createdAt = getCurrentTimestamp(),
-                updatedAt = getCurrentTimestamp()
+            updatedAt = getCurrentTimestamp(),
         )
     }
 
     private fun createTestProblem(
-            gymId: String,
+        gymId: String,
-            climbType: ClimbType = ClimbType.BOULDER
+        climbType: ClimbType = ClimbType.BOULDER,
     ): Problem {
         val difficulty =
-                when (climbType) {
+            when (climbType) {
-                    ClimbType.BOULDER -> DifficultyGrade(DifficultySystem.V_SCALE, "V5")
+                ClimbType.BOULDER -> DifficultyGrade(DifficultySystem.V_SCALE, "V5")
-                    ClimbType.ROPE -> DifficultyGrade(DifficultySystem.YDS, "5.10a")
+                ClimbType.ROPE -> DifficultyGrade(DifficultySystem.YDS, "5.10a")
-                }
+            }
 
         return Problem(
-                id = "test_problem_${java.util.UUID.randomUUID()}",
+            id = "test_problem_${java.util.UUID.randomUUID()}",
-                gymId = gymId,
+            gymId = gymId,
-                name = "Test Problem",
+            name = "Test Problem",
-                description = "A test climbing problem",
+            description = "A test climbing problem",
-                climbType = climbType,
+            climbType = climbType,
-                difficulty = difficulty,
+            difficulty = difficulty,
-                tags = listOf("test", "overhang"),
+            tags = listOf("test", "overhang"),
-                location = "Wall A",
+            location = "Wall A",
-                imagePaths = emptyList(),
+            imagePaths = emptyList(),
-                isActive = true,
+            isActive = true,
-                dateSet = "2024-01-01",
+            dateSet = "2024-01-01",
-                notes = null,
+            notes = null,
-                createdAt = getCurrentTimestamp(),
+            createdAt = getCurrentTimestamp(),
-                updatedAt = getCurrentTimestamp()
+            updatedAt = getCurrentTimestamp(),
         )
     }
 
     private fun createTestProblemWithGrade(gymId: String, grade: String): Problem {
         return Problem(
-                id = "test_problem_${java.util.UUID.randomUUID()}",
+            id = "test_problem_${java.util.UUID.randomUUID()}",
-                gymId = gymId,
+            gymId = gymId,
-                name = "Test Problem $grade",
+            name = "Test Problem $grade",
-                description = null,
+            description = null,
-                climbType = ClimbType.BOULDER,
+            climbType = ClimbType.BOULDER,
-                difficulty = DifficultyGrade(DifficultySystem.V_SCALE, grade),
+            difficulty = DifficultyGrade(DifficultySystem.V_SCALE, grade),
-                tags = emptyList(),
+            tags = emptyList(),
-                location = null,
+            location = null,
-                imagePaths = emptyList(),
+            imagePaths = emptyList(),
-                isActive = true,
+            isActive = true,
-                dateSet = null,
+            dateSet = null,
-                notes = null,
+            notes = null,
-                createdAt = getCurrentTimestamp(),
+            createdAt = getCurrentTimestamp(),
-                updatedAt = getCurrentTimestamp()
+            updatedAt = getCurrentTimestamp(),
         )
     }
 
     private fun createAttemptWithTimestamp(
-            sessionId: String,
+        sessionId: String,
-            problemId: String,
+        problemId: String,
-            timestamp: String,
+        timestamp: String,
-            result: AttemptResult
+        result: AttemptResult,
     ): Attempt {
         return Attempt.create(
-                sessionId = sessionId,
+            sessionId = sessionId,
-                problemId = problemId,
+            problemId = problemId,
-                result = result,
+            result = result,
-                timestamp = timestamp
+            timestamp = timestamp,
         )
     }
 
@@ -373,126 +373,126 @@ class BusinessLogicTests {
     }
 
     private fun calculateSessionStatistics(
-            session: ClimbSession,
+        session: ClimbSession,
-            attempts: List<Attempt>
+        attempts: List<Attempt>,
     ): SessionStatistics {
         val successful =
-                attempts.count {
+            attempts.count {
-                    it.result == AttemptResult.SUCCESS || it.result == AttemptResult.FLASH
+                it.result == AttemptResult.SUCCESS || it.result == AttemptResult.FLASH
-                }
+            }
         val uniqueProblems = attempts.map { it.problemId }.toSet().size
         val successRate = (successful.toDouble() / attempts.size) * 100
 
         return SessionStatistics(
-                totalAttempts = attempts.size,
+            totalAttempts = attempts.size,
-                successfulAttempts = successful,
+            successfulAttempts = successful,
-                uniqueProblems = uniqueProblems,
+            uniqueProblems = uniqueProblems,
-                successRate = successRate
+            successRate = successRate,
         )
     }
 
     private fun calculateDifficultyProgression(
-            attempts: List<Attempt>,
+        attempts: List<Attempt>,
-            problems: List<Problem>
+        problems: List<Problem>,
     ): DifficultyProgression {
         val problemMap = problems.associateBy { it.id }
         val grades =
-                attempts
+            attempts
-                        .mapNotNull { attempt -> problemMap[attempt.problemId]?.difficulty?.grade }
+                .mapNotNull { attempt -> problemMap[attempt.problemId]?.difficulty?.grade }
-                        .filter { it.startsWith("V") }
+                .filter { it.startsWith("V") }
 
         val numericGrades =
-                grades.mapNotNull { grade ->
+            grades.mapNotNull { grade ->
-                    when (grade) {
+                when (grade) {
-                        "VB" -> 0
+                    "VB" -> 0
-                        else -> grade.removePrefix("V").toIntOrNull()
+                    else -> grade.removePrefix("V").toIntOrNull()
-                    }
                 }
+            }
 
         val minGrade = "V${numericGrades.minOrNull() ?: 0}".replace("V0", "VB")
         val maxGrade = "V${numericGrades.maxOrNull() ?: 0}".replace("V0", "VB")
         val avgGrade = numericGrades.average()
         val showsProgression =
-                numericGrades.size > 1 &&
+            numericGrades.size > 1 &&
-                        (numericGrades.maxOrNull() ?: 0) > (numericGrades.minOrNull() ?: 0)
+                (numericGrades.maxOrNull() ?: 0) > (numericGrades.minOrNull() ?: 0)
 
         return DifficultyProgression(minGrade, maxGrade, avgGrade, showsProgression)
     }
 
     private fun createBackupData(
-            gyms: List<Gym>,
+        gyms: List<Gym>,
-            problems: List<Problem>,
+        problems: List<Problem>,
-            sessions: List<ClimbSession>,
+        sessions: List<ClimbSession>,
-            attempts: List<Attempt>
+        attempts: List<Attempt>,
     ): ClimbDataBackup {
         return ClimbDataBackup(
-                exportedAt = getCurrentTimestamp(),
+            exportedAt = getCurrentTimestamp(),
-                version = "2.0",
+            version = "2.0",
-                formatVersion = "2.0",
+            formatVersion = "2.0",
-                gyms =
+            gyms =
-                        gyms.map { gym ->
+            gyms.map { gym ->
-                            BackupGym(
+                BackupGym(
-                                    id = gym.id,
+                    id = gym.id,
-                                    name = gym.name,
+                    name = gym.name,
-                                    location = gym.location,
+                    location = gym.location,
-                                    supportedClimbTypes = gym.supportedClimbTypes,
+                    supportedClimbTypes = gym.supportedClimbTypes,
-                                    difficultySystems = gym.difficultySystems,
+                    difficultySystems = gym.difficultySystems,
-                                    customDifficultyGrades = gym.customDifficultyGrades,
+                    customDifficultyGrades = gym.customDifficultyGrades,
-                                    notes = gym.notes,
+                    notes = gym.notes,
-                                    createdAt = gym.createdAt,
+                    createdAt = gym.createdAt,
-                                    updatedAt = gym.updatedAt
+                    updatedAt = gym.updatedAt,
-                            )
+                )
-                        },
+            },
-                problems =
+            problems =
-                        problems.map { problem ->
+            problems.map { problem ->
-                            BackupProblem(
+                BackupProblem(
-                                    id = problem.id,
+                    id = problem.id,
-                                    gymId = problem.gymId,
+                    gymId = problem.gymId,
-                                    name = problem.name,
+                    name = problem.name,
-                                    description = problem.description,
+                    description = problem.description,
-                                    climbType = problem.climbType,
+                    climbType = problem.climbType,
-                                    difficulty = problem.difficulty,
+                    difficulty = problem.difficulty,
-                                    tags = problem.tags,
+                    tags = problem.tags,
-                                    location = problem.location,
+                    location = problem.location,
-                                    imagePaths = problem.imagePaths,
+                    imagePaths = problem.imagePaths,
-                                    isActive = problem.isActive,
+                    isActive = problem.isActive,
-                                    dateSet = problem.dateSet,
+                    dateSet = problem.dateSet,
-                                    notes = problem.notes,
+                    notes = problem.notes,
-                                    createdAt = problem.createdAt,
+                    createdAt = problem.createdAt,
-                                    updatedAt = problem.updatedAt
+                    updatedAt = problem.updatedAt,
-                            )
+                )
-                        },
+            },
-                sessions =
+            sessions =
-                        sessions.map { session ->
+            sessions.map { session ->
-                            BackupClimbSession(
+                BackupClimbSession(
-                                    id = session.id,
+                    id = session.id,
-                                    gymId = session.gymId,
+                    gymId = session.gymId,
-                                    date = session.date,
+                    date = session.date,
-                                    startTime = session.startTime,
+                    startTime = session.startTime,
-                                    endTime = session.endTime,
+                    endTime = session.endTime,
-                                    duration = session.duration,
+                    duration = session.duration,
-                                    status = session.status,
+                    status = session.status,
-                                    notes = session.notes,
+                    notes = session.notes,
-                                    createdAt = session.createdAt,
+                    createdAt = session.createdAt,
-                                    updatedAt = session.updatedAt
+                    updatedAt = session.updatedAt,
-                            )
+                )
-                        },
+            },
-                attempts =
+            attempts =
-                        attempts.map { attempt ->
+            attempts.map { attempt ->
-                            BackupAttempt(
+                BackupAttempt(
-                                    id = attempt.id,
+                    id = attempt.id,
-                                    sessionId = attempt.sessionId,
+                    sessionId = attempt.sessionId,
-                                    problemId = attempt.problemId,
+                    problemId = attempt.problemId,
-                                    result = attempt.result,
+                    result = attempt.result,
-                                    highestHold = attempt.highestHold,
+                    highestHold = attempt.highestHold,
-                                    notes = attempt.notes,
+                    notes = attempt.notes,
-                                    duration = attempt.duration,
+                    duration = attempt.duration,
-                                    restTime = attempt.restTime,
+                    restTime = attempt.restTime,
-                                    timestamp = attempt.timestamp,
+                    timestamp = attempt.timestamp,
-                                    createdAt = attempt.createdAt,
+                    createdAt = attempt.createdAt,
-                                    updatedAt = attempt.updatedAt,
+                    updatedAt = attempt.updatedAt,
-                            )
+                )
-                        }
+            },
         )
     }
 
@@ -501,8 +501,8 @@ class BusinessLogicTests {
         val gymIds = backup.gyms.map { it.id }.toSet()
         backup.problems.forEach { problem ->
             assertTrue(
-                    "Problem ${problem.id} references non-existent gym ${problem.gymId}",
+                "Problem ${problem.id} references non-existent gym ${problem.gymId}",
-                    gymIds.contains(problem.gymId)
+                gymIds.contains(problem.gymId),
             )
         }
 
@@ -510,8 +510,8 @@ class BusinessLogicTests {
         val sessionIds = backup.sessions.map { it.id }.toSet()
         backup.attempts.forEach { attempt ->
             assertTrue(
-                    "Attempt ${attempt.id} references non-existent session ${attempt.sessionId}",
+                "Attempt ${attempt.id} references non-existent session ${attempt.sessionId}",
-                    sessionIds.contains(attempt.sessionId)
+                sessionIds.contains(attempt.sessionId),
             )
         }
 
@@ -519,19 +519,19 @@ class BusinessLogicTests {
         val problemIds = backup.problems.map { it.id }.toSet()
         backup.attempts.forEach { attempt ->
             assertTrue(
-                    "Attempt ${attempt.id} references non-existent problem ${attempt.problemId}",
+                "Attempt ${attempt.id} references non-existent problem ${attempt.problemId}",
-                    problemIds.contains(attempt.problemId)
+                problemIds.contains(attempt.problemId),
             )
         }
     }
 
     private fun isCompatibleClimbType(
-            gym: Gym,
+        gym: Gym,
-            climbType: ClimbType,
+        climbType: ClimbType,
-            difficultySystem: DifficultySystem
+        difficultySystem: DifficultySystem,
     ): Boolean {
         return gym.supportedClimbTypes.contains(climbType) &&
-                gym.difficultySystems.contains(difficultySystem)
+            gym.difficultySystems.contains(difficultySystem)
     }
 
     private fun calculateSessionDuration(startTime: String, endTime: String): Long {
@@ -541,19 +541,19 @@ class BusinessLogicTests {
     }
 
     private fun isValidGradeCombination(
-            climbType: ClimbType,
+        climbType: ClimbType,
-            difficultySystem: DifficultySystem
+        difficultySystem: DifficultySystem,
     ): Boolean {
         return when (climbType) {
             ClimbType.BOULDER ->
-                    difficultySystem in
+                difficultySystem in
-                            listOf(
+                    listOf(
-                                    DifficultySystem.V_SCALE,
+                        DifficultySystem.V_SCALE,
-                                    DifficultySystem.FONT,
+                        DifficultySystem.FONT,
-                                    DifficultySystem.CUSTOM
+                        DifficultySystem.CUSTOM,
-                            )
+                    )
             ClimbType.ROPE ->
-                    difficultySystem in listOf(DifficultySystem.YDS, DifficultySystem.CUSTOM)
+                difficultySystem in listOf(DifficultySystem.YDS, DifficultySystem.CUSTOM)
         }
     }
 
@@ -568,29 +568,29 @@ class BusinessLogicTests {
     // Data classes for testing
 
     data class SessionStatistics(
-            val totalAttempts: Int,
+        val totalAttempts: Int,
-            val successfulAttempts: Int,
+        val successfulAttempts: Int,
-            val uniqueProblems: Int,
+        val uniqueProblems: Int,
-            val successRate: Double
+        val successRate: Double,
     )
 
     data class DifficultyProgression(
-            val minGrade: String,
+        val minGrade: String,
-            val maxGrade: String,
+        val maxGrade: String,
-            val averageGrade: Double,
+        val averageGrade: Double,
-            val showsProgression: Boolean
+        val showsProgression: Boolean,
     )
 
     data class AttemptSequence(val attempts: List<Attempt>) {
         val totalAttempts = attempts.size
         val failedAttempts =
-                attempts.count {
+            attempts.count {
-                    it.result == AttemptResult.FALL || it.result == AttemptResult.NO_PROGRESS
+                it.result == AttemptResult.FALL || it.result == AttemptResult.NO_PROGRESS
-                }
+            }
         val successfulAttempts =
-                attempts.count {
+            attempts.count {
-                    it.result == AttemptResult.SUCCESS || it.result == AttemptResult.FLASH
+                it.result == AttemptResult.SUCCESS || it.result == AttemptResult.FLASH
-                }
+            }
         val finalResult = attempts.lastOrNull()?.result
 
         fun isValidSequence(): Boolean {

android/app/src/test/java/com/atridad/openclimb/DataModelTests.kt

@@ -2,10 +2,10 @@ package com.atridad.ascently
 
 import com.atridad.ascently.data.format.*
 import com.atridad.ascently.data.model.*
-import java.time.Instant
-import java.time.format.DateTimeFormatter
 import org.junit.Assert.*
 import org.junit.Test
+import java.time.Instant
+import java.time.format.DateTimeFormatter
 
 class DataModelTests {
 
@@ -141,17 +141,17 @@ class DataModelTests {
     @Test
     fun testBackupGymCreationAndValidation() {
         val gym =
-                BackupGym(
+            BackupGym(
-                        id = "gym123",
+                id = "gym123",
-                        name = "Test Climbing Gym",
+                name = "Test Climbing Gym",
-                        location = "Test City",
+                location = "Test City",
-                        supportedClimbTypes = listOf(ClimbType.BOULDER, ClimbType.ROPE),
+                supportedClimbTypes = listOf(ClimbType.BOULDER, ClimbType.ROPE),
-                        difficultySystems = listOf(DifficultySystem.V_SCALE, DifficultySystem.YDS),
+                difficultySystems = listOf(DifficultySystem.V_SCALE, DifficultySystem.YDS),
-                        customDifficultyGrades = emptyList(),
+                customDifficultyGrades = emptyList(),
-                        notes = "Great gym for beginners",
+                notes = "Great gym for beginners",
-                        createdAt = "2024-01-01T10:00:00Z",
+                createdAt = "2024-01-01T10:00:00Z",
-                        updatedAt = "2024-01-01T10:00:00Z"
+                updatedAt = "2024-01-01T10:00:00Z",
-                )
+            )
 
         assertEquals("gym123", gym.id)
         assertEquals("Test Climbing Gym", gym.name)
@@ -167,22 +167,22 @@ class DataModelTests {
     @Test
     fun testBackupProblemCreationAndValidation() {
         val problem =
-                BackupProblem(
+            BackupProblem(
-                        id = "problem123",
+                id = "problem123",
-                        gymId = "gym123",
+                gymId = "gym123",
-                        name = "Test Problem",
+                name = "Test Problem",
-                        description = "A challenging boulder problem",
+                description = "A challenging boulder problem",
-                        climbType = ClimbType.BOULDER,
+                climbType = ClimbType.BOULDER,
-                        difficulty = DifficultyGrade(DifficultySystem.V_SCALE, "V5"),
+                difficulty = DifficultyGrade(DifficultySystem.V_SCALE, "V5"),
-                        tags = listOf("overhang", "crimpy"),
+                tags = listOf("overhang", "crimpy"),
-                        location = "Wall A",
+                location = "Wall A",
-                        imagePaths = listOf("image1.jpg", "image2.jpg"),
+                imagePaths = listOf("image1.jpg", "image2.jpg"),
-                        isActive = true,
+                isActive = true,
-                        dateSet = "2024-01-01",
+                dateSet = "2024-01-01",
-                        notes = "Watch the start holds",
+                notes = "Watch the start holds",
-                        createdAt = "2024-01-01T10:00:00Z",
+                createdAt = "2024-01-01T10:00:00Z",
-                        updatedAt = "2024-01-01T10:00:00Z"
+                updatedAt = "2024-01-01T10:00:00Z",
-                )
+            )
 
         assertEquals("problem123", problem.id)
         assertEquals("gym123", problem.gymId)
@@ -190,25 +190,25 @@ class DataModelTests {
         assertEquals(ClimbType.BOULDER, problem.climbType)
         assertEquals("V5", problem.difficulty.grade)
         assertTrue(problem.isActive)
-        assertEquals(2, problem.tags.size)
+        assertEquals(2, problem.tags?.size ?: 0)
         assertEquals(2, problem.imagePaths?.size ?: 0)
     }
 
     @Test
     fun testBackupClimbSessionCreationAndValidation() {
         val session =
-                BackupClimbSession(
+            BackupClimbSession(
-                        id = "session123",
+                id = "session123",
-                        gymId = "gym123",
+                gymId = "gym123",
-                        date = "2024-01-01",
+                date = "2024-01-01",
-                        startTime = "2024-01-01T10:00:00Z",
+                startTime = "2024-01-01T10:00:00Z",
-                        endTime = "2024-01-01T12:00:00Z",
+                endTime = "2024-01-01T12:00:00Z",
-                        duration = 7200,
+                duration = 7200,
-                        status = SessionStatus.COMPLETED,
+                status = SessionStatus.COMPLETED,
-                        notes = "Great session today",
+                notes = "Great session today",
-                        createdAt = "2024-01-01T10:00:00Z",
+                createdAt = "2024-01-01T10:00:00Z",
-                        updatedAt = "2024-01-01T12:00:00Z"
+                updatedAt = "2024-01-01T12:00:00Z",
-                )
+            )
 
         assertEquals("session123", session.id)
         assertEquals("gym123", session.gymId)
@@ -220,19 +220,19 @@ class DataModelTests {
     @Test
     fun testBackupAttemptCreationAndValidation() {
         val attempt =
-                BackupAttempt(
+            BackupAttempt(
-                        id = "attempt123",
+                id = "attempt123",
-                        sessionId = "session123",
+                sessionId = "session123",
-                        problemId = "problem123",
+                problemId = "problem123",
-                        result = AttemptResult.SUCCESS,
+                result = AttemptResult.SUCCESS,
-                        highestHold = "Top",
+                highestHold = "Top",
-                        notes = "Stuck it on second try",
+                notes = "Stuck it on second try",
-                        duration = 300,
+                duration = 300,
-                        restTime = 120,
+                restTime = 120,
-                        timestamp = "2024-01-01T10:30:00Z",
+                timestamp = "2024-01-01T10:30:00Z",
-                        createdAt = "2024-01-01T10:30:00Z",
+                createdAt = "2024-01-01T10:30:00Z",
-                        updatedAt = "2024-01-01T10:30:00Z"
+                updatedAt = "2024-01-01T10:30:00Z",
-                )
+            )
 
         assertEquals("attempt123", attempt.id)
         assertEquals("session123", attempt.sessionId)
@@ -246,15 +246,15 @@ class DataModelTests {
     @Test
     fun testClimbDataBackupCreationAndValidation() {
         val backup =
-                ClimbDataBackup(
+            ClimbDataBackup(
-                        exportedAt = "2024-01-01T10:00:00Z",
+                exportedAt = "2024-01-01T10:00:00Z",
-                        version = "2.0",
+                version = "2.0",
-                        formatVersion = "2.0",
+                formatVersion = "2.0",
-                        gyms = emptyList(),
+                gyms = emptyList(),
-                        problems = emptyList(),
+                problems = emptyList(),
-                        sessions = emptyList(),
+                sessions = emptyList(),
-                        attempts = emptyList()
+                attempts = emptyList(),
-                )
+            )
 
         assertEquals("2.0", backup.version)
         assertEquals("2.0", backup.formatVersion)
@@ -280,18 +280,18 @@ class DataModelTests {
     @Test
     fun testSessionDurationCalculation() {
         val session =
-                BackupClimbSession(
+            BackupClimbSession(
-                        id = "test",
+                id = "test",
-                        gymId = "gym1",
+                gymId = "gym1",
-                        date = "2024-01-01",
+                date = "2024-01-01",
-                        startTime = "2024-01-01T10:00:00Z",
+                startTime = "2024-01-01T10:00:00Z",
-                        endTime = "2024-01-01T12:00:00Z",
+                endTime = "2024-01-01T12:00:00Z",
-                        duration = 7200,
+                duration = 7200,
-                        status = SessionStatus.COMPLETED,
+                status = SessionStatus.COMPLETED,
-                        notes = null,
+                notes = null,
-                        createdAt = "2024-01-01T10:00:00Z",
+                createdAt = "2024-01-01T10:00:00Z",
-                        updatedAt = "2024-01-01T12:00:00Z"
+                updatedAt = "2024-01-01T12:00:00Z",
-                )
+            )
 
         assertEquals(7200L, session.duration)
         val hours = session.duration!! / 3600
@@ -301,21 +301,21 @@ class DataModelTests {
     @Test
     fun testEmptyCollectionsHandling() {
         val gym =
-                BackupGym(
+            BackupGym(
-                        id = "gym1",
+                id = "gym1",
-                        name = "Test Gym",
+                name = "Test Gym",
-                        location = null,
+                location = null,
-                        supportedClimbTypes = emptyList(),
+                supportedClimbTypes = emptyList(),
-                        difficultySystems = emptyList(),
+                difficultySystems = emptyList(),
-                        customDifficultyGrades = emptyList(),
+                customDifficultyGrades = emptyList(),
-                        notes = null,
+                notes = null,
-                        createdAt = "2024-01-01T10:00:00Z",
+                createdAt = "2024-01-01T10:00:00Z",
-                        updatedAt = "2024-01-01T10:00:00Z"
+                updatedAt = "2024-01-01T10:00:00Z",
-                )
+            )
 
-        assertTrue(gym.supportedClimbTypes.isEmpty())
+        assertTrue(gym.supportedClimbTypes?.isEmpty() ?: true)
-        assertTrue(gym.difficultySystems.isEmpty())
+        assertTrue(gym.difficultySystems?.isEmpty() ?: true)
-        assertTrue(gym.customDifficultyGrades.isEmpty())
+        assertTrue(gym.customDifficultyGrades?.isEmpty() ?: true)
         assertNull(gym.location)
         assertNull(gym.notes)
     }
@@ -323,29 +323,29 @@ class DataModelTests {
     @Test
     fun testNullableFieldsHandling() {
         val problem =
-                BackupProblem(
+            BackupProblem(
-                        id = "problem1",
+                id = "problem1",
-                        gymId = "gym1",
+                gymId = "gym1",
-                        name = null,
+                name = null,
-                        description = null,
+                description = null,
-                        climbType = ClimbType.BOULDER,
+                climbType = ClimbType.BOULDER,
-                        difficulty = DifficultyGrade(DifficultySystem.V_SCALE, "V1"),
+                difficulty = DifficultyGrade(DifficultySystem.V_SCALE, "V1"),
-                        tags = emptyList(),
+                tags = emptyList(),
-                        location = null,
+                location = null,
-                        imagePaths = null,
+                imagePaths = null,
-                        isActive = true,
+                isActive = true,
-                        dateSet = null,
+                dateSet = null,
-                        notes = null,
+                notes = null,
-                        createdAt = "2024-01-01T10:00:00Z",
+                createdAt = "2024-01-01T10:00:00Z",
-                        updatedAt = "2024-01-01T10:00:00Z"
+                updatedAt = "2024-01-01T10:00:00Z",
-                )
+            )
 
         assertNull(problem.name)
         assertNull(problem.description)
         assertNull(problem.location)
         assertNull(problem.dateSet)
         assertNull(problem.notes)
-        assertTrue(problem.tags.isEmpty())
+        assertTrue(problem.tags?.isEmpty() ?: true)
         assertNull(problem.imagePaths)
     }
 
@@ -362,7 +362,7 @@ class DataModelTests {
     @Test
     fun testBackupDataFormatValidation() {
         val testJson =
-                """
+            """
         {
             "exportedAt": "2024-01-01T10:00:00Z",
             "version": "2.0",
@@ -372,7 +372,7 @@ class DataModelTests {
             "sessions": [],
             "attempts": []
         }
-        """.trimIndent()
+            """.trimIndent()
 
         assertTrue(testJson.contains("exportedAt"))
         assertTrue(testJson.contains("version"))
@@ -397,44 +397,44 @@ class DataModelTests {
     fun testClimbTypeAndDifficultySystemCompatibility() {
         // Test that V_SCALE works with BOULDER
         val boulderProblem =
-                BackupProblem(
+            BackupProblem(
-                        id = "boulder1",
+                id = "boulder1",
-                        gymId = "gym1",
+                gymId = "gym1",
-                        name = "Boulder Problem",
+                name = "Boulder Problem",
-                        description = null,
+                description = null,
-                        climbType = ClimbType.BOULDER,
+                climbType = ClimbType.BOULDER,
-                        difficulty = DifficultyGrade(DifficultySystem.V_SCALE, "V3"),
+                difficulty = DifficultyGrade(DifficultySystem.V_SCALE, "V3"),
-                        tags = emptyList(),
+                tags = emptyList(),
-                        location = null,
+                location = null,
-                        imagePaths = null,
+                imagePaths = null,
-                        isActive = true,
+                isActive = true,
-                        dateSet = null,
+                dateSet = null,
-                        notes = null,
+                notes = null,
-                        createdAt = "2024-01-01T10:00:00Z",
+                createdAt = "2024-01-01T10:00:00Z",
-                        updatedAt = "2024-01-01T10:00:00Z"
+                updatedAt = "2024-01-01T10:00:00Z",
-                )
+            )
 
         assertEquals(ClimbType.BOULDER, boulderProblem.climbType)
         assertEquals(DifficultySystem.V_SCALE, boulderProblem.difficulty.system)
 
         // Test that YDS works with ROPE
         val ropeProblem =
-                BackupProblem(
+            BackupProblem(
-                        id = "rope1",
+                id = "rope1",
-                        gymId = "gym1",
+                gymId = "gym1",
-                        name = "Rope Problem",
+                name = "Rope Problem",
-                        description = null,
+                description = null,
-                        climbType = ClimbType.ROPE,
+                climbType = ClimbType.ROPE,
-                        difficulty = DifficultyGrade(DifficultySystem.YDS, "5.10a"),
+                difficulty = DifficultyGrade(DifficultySystem.YDS, "5.10a"),
-                        tags = emptyList(),
+                tags = emptyList(),
-                        location = null,
+                location = null,
-                        imagePaths = null,
+                imagePaths = null,
-                        isActive = true,
+                isActive = true,
-                        dateSet = null,
+                dateSet = null,
-                        notes = null,
+                notes = null,
-                        createdAt = "2024-01-01T10:00:00Z",
+                createdAt = "2024-01-01T10:00:00Z",
-                        updatedAt = "2024-01-01T10:00:00Z"
+                updatedAt = "2024-01-01T10:00:00Z",
-                )
+            )
 
         assertEquals(ClimbType.ROPE, ropeProblem.climbType)
         assertEquals(DifficultySystem.YDS, ropeProblem.difficulty.system)
@@ -473,12 +473,12 @@ class DataModelTests {
     @Test
     fun testAttemptResultValidation() {
         val validResults =
-                listOf(
+            listOf(
-                        AttemptResult.SUCCESS,
+                AttemptResult.SUCCESS,
-                        AttemptResult.FALL,
+                AttemptResult.FALL,
-                        AttemptResult.NO_PROGRESS,
+                AttemptResult.NO_PROGRESS,
-                        AttemptResult.FLASH
+                AttemptResult.FLASH,
-                )
+            )
 
         assertEquals(4, validResults.size)
         assertTrue(validResults.contains(AttemptResult.SUCCESS))
@@ -490,7 +490,7 @@ class DataModelTests {
     @Test
     fun testSessionStatusValidation() {
         val validStatuses =
-                listOf(SessionStatus.ACTIVE, SessionStatus.COMPLETED, SessionStatus.PAUSED)
+            listOf(SessionStatus.ACTIVE, SessionStatus.COMPLETED, SessionStatus.PAUSED)
 
         assertEquals(3, validStatuses.size)
         assertTrue(validStatuses.contains(SessionStatus.ACTIVE))
@@ -501,64 +501,64 @@ class DataModelTests {
     @Test
     fun testClimbDataIntegrity() {
         val gym =
-                BackupGym(
+            BackupGym(
-                        id = "gym1",
+                id = "gym1",
-                        name = "Test Gym",
+                name = "Test Gym",
-                        location = "Test City",
+                location = "Test City",
-                        supportedClimbTypes = listOf(ClimbType.BOULDER),
+                supportedClimbTypes = listOf(ClimbType.BOULDER),
-                        difficultySystems = listOf(DifficultySystem.V_SCALE),
+                difficultySystems = listOf(DifficultySystem.V_SCALE),
-                        customDifficultyGrades = emptyList(),
+                customDifficultyGrades = emptyList(),
-                        notes = null,
+                notes = null,
-                        createdAt = "2024-01-01T10:00:00Z",
+                createdAt = "2024-01-01T10:00:00Z",
-                        updatedAt = "2024-01-01T10:00:00Z"
+                updatedAt = "2024-01-01T10:00:00Z",
-                )
+            )
 
         val problem =
-                BackupProblem(
+            BackupProblem(
-                        id = "problem1",
+                id = "problem1",
-                        gymId = gym.id,
+                gymId = gym.id,
-                        name = "Test Problem",
+                name = "Test Problem",
-                        description = null,
+                description = null,
-                        climbType = ClimbType.BOULDER,
+                climbType = ClimbType.BOULDER,
-                        difficulty = DifficultyGrade(DifficultySystem.V_SCALE, "V3"),
+                difficulty = DifficultyGrade(DifficultySystem.V_SCALE, "V3"),
-                        tags = emptyList(),
+                tags = emptyList(),
-                        location = null,
+                location = null,
-                        imagePaths = null,
+                imagePaths = null,
-                        isActive = true,
+                isActive = true,
-                        dateSet = null,
+                dateSet = null,
-                        notes = null,
+                notes = null,
-                        createdAt = "2024-01-01T10:00:00Z",
+                createdAt = "2024-01-01T10:00:00Z",
-                        updatedAt = "2024-01-01T10:00:00Z"
+                updatedAt = "2024-01-01T10:00:00Z",
-                )
+            )
 
         val session =
-                BackupClimbSession(
+            BackupClimbSession(
-                        id = "session1",
+                id = "session1",
-                        gymId = gym.id,
+                gymId = gym.id,
-                        date = "2024-01-01",
+                date = "2024-01-01",
-                        startTime = "2024-01-01T10:00:00Z",
+                startTime = "2024-01-01T10:00:00Z",
-                        endTime = "2024-01-01T11:00:00Z",
+                endTime = "2024-01-01T11:00:00Z",
-                        duration = 3600,
+                duration = 3600,
-                        status = SessionStatus.COMPLETED,
+                status = SessionStatus.COMPLETED,
-                        notes = null,
+                notes = null,
-                        createdAt = "2024-01-01T10:00:00Z",
+                createdAt = "2024-01-01T10:00:00Z",
-                        updatedAt = "2024-01-01T11:00:00Z"
+                updatedAt = "2024-01-01T11:00:00Z",
-                )
+            )
 
         val attempt =
-                BackupAttempt(
+            BackupAttempt(
-                        id = "attempt1",
+                id = "attempt1",
-                        sessionId = session.id,
+                sessionId = session.id,
-                        problemId = problem.id,
+                problemId = problem.id,
-                        result = AttemptResult.SUCCESS,
+                result = AttemptResult.SUCCESS,
-                        highestHold = null,
+                highestHold = null,
-                        notes = null,
+                notes = null,
-                        duration = 120,
+                duration = 120,
-                        restTime = null,
+                restTime = null,
-                        timestamp = "2024-01-01T10:30:00Z",
+                timestamp = "2024-01-01T10:30:00Z",
-                        createdAt = "2024-01-01T10:30:00Z",
+                createdAt = "2024-01-01T10:30:00Z",
-                        updatedAt = "2024-01-01T10:30:00Z"
+                updatedAt = "2024-01-01T10:30:00Z",
-                )
+            )
 
         // Verify referential integrity
         assertEquals(gym.id, problem.gymId)

android/app/src/test/java/com/atridad/openclimb/SyncMergeLogicTest.kt

@@ -11,197 +11,197 @@ class SyncMergeLogicTest {
     fun `test intelligent merge preserves all data`() {
         // Create local data
         val localGyms =
-                listOf(
+            listOf(
-                        BackupGym(
+                BackupGym(
-                                id = "gym1",
+                    id = "gym1",
-                                name = "Local Gym 1",
+                    name = "Local Gym 1",
-                                location = "Local Location",
+                    location = "Local Location",
-                                supportedClimbTypes = listOf(ClimbType.BOULDER),
+                    supportedClimbTypes = listOf(ClimbType.BOULDER),
-                                difficultySystems = listOf(DifficultySystem.V_SCALE),
+                    difficultySystems = listOf(DifficultySystem.V_SCALE),
-                                customDifficultyGrades = emptyList(),
+                    customDifficultyGrades = emptyList(),
-                                notes = null,
+                    notes = null,
-                                createdAt = "2024-01-01T10:00:00",
+                    createdAt = "2024-01-01T10:00:00",
-                                updatedAt = "2024-01-01T10:00:00"
+                    updatedAt = "2024-01-01T10:00:00",
-                        )
+                ),
-                )
+            )
 
         val localProblems =
-                listOf(
+            listOf(
-                        BackupProblem(
+                BackupProblem(
-                                id = "problem1",
+                    id = "problem1",
-                                gymId = "gym1",
+                    gymId = "gym1",
-                                name = "Local Problem",
+                    name = "Local Problem",
-                                description = "Local description",
+                    description = "Local description",
-                                climbType = ClimbType.BOULDER,
+                    climbType = ClimbType.BOULDER,
-                                difficulty = DifficultyGrade(DifficultySystem.V_SCALE, "V5"),
+                    difficulty = DifficultyGrade(DifficultySystem.V_SCALE, "V5"),
-                                tags = listOf("local"),
+                    tags = listOf("local"),
-                                location = null,
+                    location = null,
-                                imagePaths = listOf("local_image.jpg"),
+                    imagePaths = listOf("local_image.jpg"),
-                                isActive = true,
+                    isActive = true,
-                                dateSet = null,
+                    dateSet = null,
-                                notes = null,
+                    notes = null,
-                                createdAt = "2024-01-01T10:00:00",
+                    createdAt = "2024-01-01T10:00:00",
-                                updatedAt = "2024-01-01T10:00:00"
+                    updatedAt = "2024-01-01T10:00:00",
-                        )
+                ),
-                )
+            )
 
         val localSessions =
-                listOf(
+            listOf(
-                        BackupClimbSession(
+                BackupClimbSession(
-                                id = "session1",
+                    id = "session1",
-                                gymId = "gym1",
+                    gymId = "gym1",
-                                date = "2024-01-01",
+                    date = "2024-01-01",
-                                startTime = "2024-01-01T10:00:00",
+                    startTime = "2024-01-01T10:00:00",
-                                endTime = "2024-01-01T12:00:00",
+                    endTime = "2024-01-01T12:00:00",
-                                duration = 7200,
+                    duration = 7200,
-                                status = SessionStatus.COMPLETED,
+                    status = SessionStatus.COMPLETED,
-                                notes = null,
+                    notes = null,
-                                createdAt = "2024-01-01T10:00:00",
+                    createdAt = "2024-01-01T10:00:00",
-                                updatedAt = "2024-01-01T10:00:00"
+                    updatedAt = "2024-01-01T10:00:00",
-                        )
+                ),
-                )
+            )
 
         val localAttempts =
-                listOf(
+            listOf(
-                        BackupAttempt(
+                BackupAttempt(
-                                id = "attempt1",
+                    id = "attempt1",
-                                sessionId = "session1",
+                    sessionId = "session1",
-                                problemId = "problem1",
+                    problemId = "problem1",
-                                result = AttemptResult.SUCCESS,
+                    result = AttemptResult.SUCCESS,
-                                highestHold = null,
+                    highestHold = null,
-                                notes = null,
+                    notes = null,
-                                duration = 300,
+                    duration = 300,
-                                restTime = null,
+                    restTime = null,
-                                timestamp = "2024-01-01T10:30:00",
+                    timestamp = "2024-01-01T10:30:00",
-                                createdAt = "2024-01-01T10:30:00",
+                    createdAt = "2024-01-01T10:30:00",
-                                updatedAt = "2024-01-01T10:30:00"
+                    updatedAt = "2024-01-01T10:30:00",
-                        )
+                ),
-                )
+            )
 
         val localBackup =
-                ClimbDataBackup(
+            ClimbDataBackup(
-                        exportedAt = "2024-01-01T10:00:00",
+                exportedAt = "2024-01-01T10:00:00",
-                        version = "2.0",
+                version = "2.0",
-                        formatVersion = "2.0",
+                formatVersion = "2.0",
-                        gyms = localGyms,
+                gyms = localGyms,
-                        problems = localProblems,
+                problems = localProblems,
-                        sessions = localSessions,
+                sessions = localSessions,
-                        attempts = localAttempts
+                attempts = localAttempts,
-                )
+            )
 
         // Create server data with some overlapping and some unique data
         val serverGyms =
-                listOf(
+            listOf(
-                        // Same gym but with newer update
+                // Same gym but with newer update
-                        BackupGym(
+                BackupGym(
-                                id = "gym1",
+                    id = "gym1",
-                                name = "Updated Gym 1",
+                    name = "Updated Gym 1",
-                                location = "Updated Location",
+                    location = "Updated Location",
-                                supportedClimbTypes = listOf(ClimbType.BOULDER, ClimbType.ROPE),
+                    supportedClimbTypes = listOf(ClimbType.BOULDER, ClimbType.ROPE),
-                                difficultySystems =
+                    difficultySystems =
-                                        listOf(DifficultySystem.V_SCALE, DifficultySystem.YDS),
+                    listOf(DifficultySystem.V_SCALE, DifficultySystem.YDS),
-                                customDifficultyGrades = emptyList(),
+                    customDifficultyGrades = emptyList(),
-                                notes = "Updated notes",
+                    notes = "Updated notes",
-                                createdAt = "2024-01-01T10:00:00",
+                    createdAt = "2024-01-01T10:00:00",
-                                updatedAt = "2024-01-01T12:00:00" // Newer update
+                    updatedAt = "2024-01-01T12:00:00", // Newer update
-                        ),
+                ),
-                        // Unique server gym
+                // Unique server gym
-                        BackupGym(
+                BackupGym(
-                                id = "gym2",
+                    id = "gym2",
-                                name = "Server Gym 2",
+                    name = "Server Gym 2",
-                                location = "Server Location",
+                    location = "Server Location",
-                                supportedClimbTypes = listOf(ClimbType.ROPE),
+                    supportedClimbTypes = listOf(ClimbType.ROPE),
-                                difficultySystems = listOf(DifficultySystem.YDS),
+                    difficultySystems = listOf(DifficultySystem.YDS),
-                                customDifficultyGrades = emptyList(),
+                    customDifficultyGrades = emptyList(),
-                                notes = null,
+                    notes = null,
-                                createdAt = "2024-01-01T11:00:00",
+                    createdAt = "2024-01-01T11:00:00",
-                                updatedAt = "2024-01-01T11:00:00"
+                    updatedAt = "2024-01-01T11:00:00",
-                        )
+                ),
-                )
+            )
 
         val serverProblems =
-                listOf(
+            listOf(
-                        // Same problem but with newer update and different images
+                // Same problem but with newer update and different images
-                        BackupProblem(
+                BackupProblem(
-                                id = "problem1",
+                    id = "problem1",
-                                gymId = "gym1",
+                    gymId = "gym1",
-                                name = "Updated Problem",
+                    name = "Updated Problem",
-                                description = "Updated description",
+                    description = "Updated description",
-                                climbType = ClimbType.BOULDER,
+                    climbType = ClimbType.BOULDER,
-                                difficulty = DifficultyGrade(DifficultySystem.V_SCALE, "V5"),
+                    difficulty = DifficultyGrade(DifficultySystem.V_SCALE, "V5"),
-                                tags = listOf("updated", "server"),
+                    tags = listOf("updated", "server"),
-                                location = "Updated location",
+                    location = "Updated location",
-                                imagePaths = listOf("server_image.jpg"),
+                    imagePaths = listOf("server_image.jpg"),
-                                isActive = true,
+                    isActive = true,
-                                dateSet = "2024-01-01",
+                    dateSet = "2024-01-01",
-                                notes = "Updated notes",
+                    notes = "Updated notes",
-                                createdAt = "2024-01-01T10:00:00",
+                    createdAt = "2024-01-01T10:00:00",
-                                updatedAt = "2024-01-01T11:00:00" // Newer update
+                    updatedAt = "2024-01-01T11:00:00", // Newer update
-                        ),
+                ),
-                        // Unique server problem
+                // Unique server problem
-                        BackupProblem(
+                BackupProblem(
-                                id = "problem2",
+                    id = "problem2",
-                                gymId = "gym2",
+                    gymId = "gym2",
-                                name = "Server Problem",
+                    name = "Server Problem",
-                                description = "Server description",
+                    description = "Server description",
-                                climbType = ClimbType.ROPE,
+                    climbType = ClimbType.ROPE,
-                                difficulty = DifficultyGrade(DifficultySystem.YDS, "5.10a"),
+                    difficulty = DifficultyGrade(DifficultySystem.YDS, "5.10a"),
-                                tags = listOf("server"),
+                    tags = listOf("server"),
-                                location = null,
+                    location = null,
-                                imagePaths = null,
+                    imagePaths = null,
-                                isActive = true,
+                    isActive = true,
-                                dateSet = null,
+                    dateSet = null,
-                                notes = null,
+                    notes = null,
-                                createdAt = "2024-01-01T11:00:00",
+                    createdAt = "2024-01-01T11:00:00",
-                                updatedAt = "2024-01-01T11:00:00"
+                    updatedAt = "2024-01-01T11:00:00",
-                        )
+                ),
-                )
+            )
 
         val serverSessions =
-                listOf(
+            listOf(
-                        // Unique server session
+                // Unique server session
-                        BackupClimbSession(
+                BackupClimbSession(
-                                id = "session2",
+                    id = "session2",
-                                gymId = "gym2",
+                    gymId = "gym2",
-                                date = "2024-01-02",
+                    date = "2024-01-02",
-                                startTime = "2024-01-02T14:00:00",
+                    startTime = "2024-01-02T14:00:00",
-                                endTime = "2024-01-02T16:00:00",
+                    endTime = "2024-01-02T16:00:00",
-                                duration = 7200,
+                    duration = 7200,
-                                status = SessionStatus.COMPLETED,
+                    status = SessionStatus.COMPLETED,
-                                notes = "Server session",
+                    notes = "Server session",
-                                createdAt = "2024-01-02T14:00:00",
+                    createdAt = "2024-01-02T14:00:00",
-                                updatedAt = "2024-01-02T14:00:00"
+                    updatedAt = "2024-01-02T14:00:00",
-                        )
+                ),
-                )
+            )
 
         val serverAttempts =
-                listOf(
+            listOf(
-                        // Unique server attempt
+                // Unique server attempt
-                        BackupAttempt(
+                BackupAttempt(
-                                id = "attempt2",
+                    id = "attempt2",
-                                sessionId = "session2",
+                    sessionId = "session2",
-                                problemId = "problem2",
+                    problemId = "problem2",
-                                result = AttemptResult.FALL,
+                    result = AttemptResult.FALL,
-                                highestHold = "Last move",
+                    highestHold = "Last move",
-                                notes = "Almost had it",
+                    notes = "Almost had it",
-                                duration = 180,
+                    duration = 180,
-                                restTime = 60,
+                    restTime = 60,
-                                timestamp = "2024-01-02T14:30:00",
+                    timestamp = "2024-01-02T14:30:00",
-                                createdAt = "2024-01-02T14:30:00",
+                    createdAt = "2024-01-02T14:30:00",
-                                updatedAt = "2024-01-02T14:30:00"
+                    updatedAt = "2024-01-02T14:30:00",
-                        )
+                ),
-                )
+            )
 
         val serverBackup =
-                ClimbDataBackup(
+            ClimbDataBackup(
-                        exportedAt = "2024-01-01T12:00:00",
+                exportedAt = "2024-01-01T12:00:00",
-                        version = "2.0",
+                version = "2.0",
-                        formatVersion = "2.0",
+                formatVersion = "2.0",
-                        gyms = serverGyms,
+                gyms = serverGyms,
-                        problems = serverProblems,
+                problems = serverProblems,
-                        sessions = serverSessions,
+                sessions = serverSessions,
-                        attempts = serverAttempts
+                attempts = serverAttempts,
-                )
+            )
 
         // Simulate merge logic
         val mergedBackup = performIntelligentMerge(localBackup, serverBackup)
@@ -231,12 +231,12 @@ class SyncMergeLogicTest {
 
         // Images should be merged (both local and server images preserved)
         assertTrue(
-                "Should contain local image",
+            "Should contain local image",
-                mergedProblem1.imagePaths!!.contains("local_image.jpg")
+            mergedProblem1.imagePaths!!.contains("local_image.jpg"),
         )
         assertTrue(
-                "Should contain server image",
+            "Should contain server image",
-                mergedProblem1.imagePaths!!.contains("server_image.jpg")
+            mergedProblem1.imagePaths!!.contains("server_image.jpg"),
         )
         assertEquals("Should have 2 images total", 2, mergedProblem1.imagePaths!!.size)
 
@@ -246,78 +246,78 @@ class SyncMergeLogicTest {
 
         // Verify all sessions are preserved
         assertTrue(
-                "Should contain local session",
+            "Should contain local session",
-                mergedBackup.sessions.any { it.id == "session1" }
+            mergedBackup.sessions.any { it.id == "session1" },
         )
         assertTrue(
-                "Should contain server session",
+            "Should contain server session",
-                mergedBackup.sessions.any { it.id == "session2" }
+            mergedBackup.sessions.any { it.id == "session2" },
         )
 
         // Verify all attempts are preserved
         assertTrue(
-                "Should contain local attempt",
+            "Should contain local attempt",
-                mergedBackup.attempts.any { it.id == "attempt1" }
+            mergedBackup.attempts.any { it.id == "attempt1" },
         )
         assertTrue(
-                "Should contain server attempt",
+            "Should contain server attempt",
-                mergedBackup.attempts.any { it.id == "attempt2" }
+            mergedBackup.attempts.any { it.id == "attempt2" },
         )
     }
 
     @Test
     fun `test date comparison logic`() {
         assertTrue(
-                "ISO instant should be newer",
+            "ISO instant should be newer",
-                isNewerThan("2024-01-01T12:00:00Z", "2024-01-01T10:00:00Z")
+            isNewerThan("2024-01-01T12:00:00Z", "2024-01-01T10:00:00Z"),
         )
         assertFalse(
-                "ISO instant should be older",
+            "ISO instant should be older",
-                isNewerThan("2024-01-01T10:00:00Z", "2024-01-01T12:00:00Z")
+            isNewerThan("2024-01-01T10:00:00Z", "2024-01-01T12:00:00Z"),
         )
         assertTrue(
-                "String comparison should work as fallback",
+            "String comparison should work as fallback",
-                isNewerThan("2024-01-02T10:00:00", "2024-01-01T10:00:00")
+            isNewerThan("2024-01-02T10:00:00", "2024-01-01T10:00:00"),
         )
     }
 
     @Test
     fun `test empty data scenarios`() {
         val emptyBackup =
-                ClimbDataBackup(
+            ClimbDataBackup(
-                        exportedAt = "2024-01-01T10:00:00",
+                exportedAt = "2024-01-01T10:00:00",
-                        version = "2.0",
+                version = "2.0",
-                        formatVersion = "2.0",
+                formatVersion = "2.0",
-                        gyms = emptyList(),
+                gyms = emptyList(),
-                        problems = emptyList(),
+                problems = emptyList(),
-                        sessions = emptyList(),
+                sessions = emptyList(),
-                        attempts = emptyList()
+                attempts = emptyList(),
-                )
+            )
 
         val dataBackup =
-                ClimbDataBackup(
+            ClimbDataBackup(
-                        exportedAt = "2024-01-01T10:00:00",
+                exportedAt = "2024-01-01T10:00:00",
-                        version = "2.0",
+                version = "2.0",
-                        formatVersion = "2.0",
+                formatVersion = "2.0",
-                        gyms =
+                gyms =
-                                listOf(
+                listOf(
-                                        BackupGym(
+                    BackupGym(
-                                                id = "gym1",
+                        id = "gym1",
-                                                name = "Test Gym",
+                        name = "Test Gym",
-                                                location = null,
+                        location = null,
-                                                supportedClimbTypes = listOf(ClimbType.BOULDER),
+                        supportedClimbTypes = listOf(ClimbType.BOULDER),
-                                                difficultySystems =
+                        difficultySystems =
-                                                        listOf(DifficultySystem.V_SCALE),
+                        listOf(DifficultySystem.V_SCALE),
-                                                customDifficultyGrades = emptyList(),
+                        customDifficultyGrades = emptyList(),
-                                                notes = null,
+                        notes = null,
-                                                createdAt = "2024-01-01T10:00:00",
+                        createdAt = "2024-01-01T10:00:00",
-                                                updatedAt = "2024-01-01T10:00:00"
+                        updatedAt = "2024-01-01T10:00:00",
-                                        )
+                    ),
-                                ),
+                ),
-                        problems = emptyList(),
+                problems = emptyList(),
-                        sessions = emptyList(),
+                sessions = emptyList(),
-                        attempts = emptyList()
+                attempts = emptyList(),
-                )
+            )
 
         // Test merging empty with data
         val merged1 = performIntelligentMerge(emptyBackup, dataBackup)
@@ -334,8 +334,8 @@ class SyncMergeLogicTest {
 
     // Helper methods that simulate the merge logic from SyncService
     private fun performIntelligentMerge(
-            local: ClimbDataBackup,
+        local: ClimbDataBackup,
-            server: ClimbDataBackup
+        server: ClimbDataBackup,
     ): ClimbDataBackup {
         val mergedGyms = mergeGyms(local.gyms, server.gyms)
         val mergedProblems = mergeProblems(local.problems, server.problems)
@@ -343,13 +343,13 @@ class SyncMergeLogicTest {
         val mergedAttempts = mergeAttempts(local.attempts, server.attempts)
 
         return ClimbDataBackup(
-                exportedAt = "2024-01-01T12:00:00",
+            exportedAt = "2024-01-01T12:00:00",
-                version = "2.0",
+            version = "2.0",
-                formatVersion = "2.0",
+            formatVersion = "2.0",
-                gyms = mergedGyms,
+            gyms = mergedGyms,
-                problems = mergedProblems,
+            problems = mergedProblems,
-                sessions = mergedSessions,
+            sessions = mergedSessions,
-                attempts = mergedAttempts
+            attempts = mergedAttempts,
         )
     }
 
@@ -371,8 +371,8 @@ class SyncMergeLogicTest {
     }
 
     private fun mergeProblems(
-            local: List<BackupProblem>,
+        local: List<BackupProblem>,
-            server: List<BackupProblem>
+        server: List<BackupProblem>,
     ): List<BackupProblem> {
         val merged = mutableMapOf<String, BackupProblem>()
 
@@ -390,7 +390,7 @@ class SyncMergeLogicTest {
                 serverProblem.imagePaths?.let { allImagePaths.addAll(it) }
 
                 merged[serverProblem.id] =
-                        serverProblem.withUpdatedImagePaths(allImagePaths.toList())
+                    serverProblem.withUpdatedImagePaths(allImagePaths.toList())
             }
         }
 
@@ -398,8 +398,8 @@ class SyncMergeLogicTest {
     }
 
     private fun mergeSessions(
-            local: List<BackupClimbSession>,
+        local: List<BackupClimbSession>,
-            server: List<BackupClimbSession>
+        server: List<BackupClimbSession>,
     ): List<BackupClimbSession> {
         val merged = mutableMapOf<String, BackupClimbSession>()
 
@@ -419,8 +419,8 @@ class SyncMergeLogicTest {
     }
 
     private fun mergeAttempts(
-            local: List<BackupAttempt>,
+        local: List<BackupAttempt>,
-            server: List<BackupAttempt>
+        server: List<BackupAttempt>,
     ): List<BackupAttempt> {
         val merged = mutableMapOf<String, BackupAttempt>()
 
@@ -431,10 +431,10 @@ class SyncMergeLogicTest {
         server.forEach { serverAttempt ->
             val localAttempt = merged[serverAttempt.id]
             if (localAttempt == null ||
-                            isNewerThan(
+                isNewerThan(
-                                    serverAttempt.updatedAt ?: serverAttempt.createdAt,
+                    serverAttempt.updatedAt ?: serverAttempt.createdAt,
-                                    localAttempt.updatedAt ?: localAttempt.createdAt
+                    localAttempt.updatedAt ?: localAttempt.createdAt,
-                            )
+                )
             ) {
                 merged[serverAttempt.id] = serverAttempt
             }
@@ -458,32 +458,32 @@ class SyncMergeLogicTest {
     @Test
     fun `test active sessions excluded from sync`() {
         val allLocalSessions =
-                listOf(
+            listOf(
-                        BackupClimbSession(
+                BackupClimbSession(
-                                id = "active_session_1",
+                    id = "active_session_1",
-                                gymId = "gym1",
+                    gymId = "gym1",
-                                date = "2024-01-01",
+                    date = "2024-01-01",
-                                startTime = "2024-01-01T10:00:00",
+                    startTime = "2024-01-01T10:00:00",
-                                endTime = null,
+                    endTime = null,
-                                duration = null,
+                    duration = null,
-                                status = SessionStatus.ACTIVE,
+                    status = SessionStatus.ACTIVE,
-                                notes = null,
+                    notes = null,
-                                createdAt = "2024-01-01T10:00:00",
+                    createdAt = "2024-01-01T10:00:00",
-                                updatedAt = "2024-01-01T10:00:00"
+                    updatedAt = "2024-01-01T10:00:00",
-                        ),
+                ),
-                        BackupClimbSession(
+                BackupClimbSession(
-                                id = "completed_session_1",
+                    id = "completed_session_1",
-                                gymId = "gym1",
+                    gymId = "gym1",
-                                date = "2023-12-31",
+                    date = "2023-12-31",
-                                startTime = "2023-12-31T15:00:00",
+                    startTime = "2023-12-31T15:00:00",
-                                endTime = "2023-12-31T17:00:00",
+                    endTime = "2023-12-31T17:00:00",
-                                duration = 7200000,
+                    duration = 7200000,
-                                status = SessionStatus.COMPLETED,
+                    status = SessionStatus.COMPLETED,
-                                notes = "Previous session",
+                    notes = "Previous session",
-                                createdAt = "2023-12-31T15:00:00",
+                    createdAt = "2023-12-31T15:00:00",
-                                updatedAt = "2023-12-31T17:00:00"
+                    updatedAt = "2023-12-31T17:00:00",
-                        )
+                ),
-                )
+            )
 
         // Simulate filtering that would happen in createBackupFromRepository
         val sessionsForSync = allLocalSessions.filter { it.status != SessionStatus.ACTIVE }
@@ -493,18 +493,18 @@ class SyncMergeLogicTest {
 
         // Active session should be excluded
         assertFalse(
-                "Should not contain active session in sync",
+            "Should not contain active session in sync",
-                sessionsForSync.any {
+            sessionsForSync.any {
-                    it.id == "active_session_1" && it.status == SessionStatus.ACTIVE
+                it.id == "active_session_1" && it.status == SessionStatus.ACTIVE
-                }
+            },
         )
 
         // Completed session should be included
         assertTrue(
-                "Should contain completed session in sync",
+            "Should contain completed session in sync",
-                sessionsForSync.any {
+            sessionsForSync.any {
-                    it.id == "completed_session_1" && it.status == SessionStatus.COMPLETED
+                it.id == "completed_session_1" && it.status == SessionStatus.COMPLETED
-                }
+            },
         )
     }
 }

android/app/src/test/java/com/atridad/openclimb/UtilityTests.kt

@@ -1,10 +1,10 @@
 package com.atridad.ascently
 
+import org.junit.Assert.*
+import org.junit.Test
 import java.time.LocalDateTime
 import java.time.format.DateTimeFormatter
 import java.util.concurrent.TimeUnit
-import org.junit.Assert.*
-import org.junit.Test
 
 class UtilityTests {
 
@@ -75,13 +75,13 @@ class UtilityTests {
     @Test
     fun testClimbingStatistics() {
         val attempts =
-                listOf(
+            listOf(
-                        AttemptData("SUCCESS", 120),
+                AttemptData("SUCCESS", 120),
-                        AttemptData("FALL", 90),
+                AttemptData("FALL", 90),
-                        AttemptData("SUCCESS", 150),
+                AttemptData("SUCCESS", 150),
-                        AttemptData("FLASH", 60),
+                AttemptData("FLASH", 60),
-                        AttemptData("FALL", 110)
+                AttemptData("FALL", 110),
-                )
+            )
 
         val stats = calculateAttemptStatistics(attempts)
 
@@ -163,23 +163,23 @@ class UtilityTests {
     @Test
     fun testSearchFiltering() {
         val problems =
-                listOf(
+            listOf(
-                        ProblemData(
+                ProblemData(
-                                "id1",
+                    "id1",
-                                "Crimpy Problem",
+                    "Crimpy Problem",
-                                "BOULDER",
+                    "BOULDER",
-                                "V5",
+                    "V5",
-                                listOf("crimpy", "overhang")
+                    listOf("crimpy", "overhang"),
-                        ),
+                ),
-                        ProblemData("id2", "Easy Route", "ROPE", "5.6", listOf("beginner", "slab")),
+                ProblemData("id2", "Easy Route", "ROPE", "5.6", listOf("beginner", "slab")),
-                        ProblemData(
+                ProblemData(
-                                "id3",
+                    "id3",
-                                "Hard Boulder",
+                    "Hard Boulder",
-                                "BOULDER",
+                    "BOULDER",
-                                "V10",
+                    "V10",
-                                listOf("powerful", "roof")
+                    listOf("powerful", "roof"),
-                        )
+                ),
-                )
+            )
 
         val boulderProblems = filterByClimbType(problems, "BOULDER")
         assertEquals(2, boulderProblems.size)
@@ -207,20 +207,20 @@ class UtilityTests {
     @Test
     fun testBackupValidation() {
         val validBackup =
-                BackupData(
+            BackupData(
-                        version = "2.0",
+                version = "2.0",
-                        formatVersion = "2.0",
+                formatVersion = "2.0",
-                        exportedAt = "2024-01-01T10:00:00Z",
+                exportedAt = "2024-01-01T10:00:00Z",
-                        dataCount = 5
+                dataCount = 5,
-                )
+            )
 
         val invalidBackup =
-                BackupData(
+            BackupData(
-                        version = "1.0",
+                version = "1.0",
-                        formatVersion = "2.0",
+                formatVersion = "2.0",
-                        exportedAt = "invalid-date",
+                exportedAt = "invalid-date",
-                        dataCount = -1
+                dataCount = -1,
-                )
+            )
 
         assertTrue(isValidBackup(validBackup))
         assertFalse(isValidBackup(invalidBackup))
@@ -258,10 +258,10 @@ class UtilityTests {
         val successRate = (successful.toDouble() / attempts.size) * 100
 
         return AttemptStatistics(
-                totalAttempts = attempts.size,
+            totalAttempts = attempts.size,
-                successfulAttempts = successful,
+            successfulAttempts = successful,
-                successRate = successRate,
+            successRate = successRate,
-                averageDuration = avgDuration
+            averageDuration = avgDuration,
         )
     }
 
@@ -301,8 +301,8 @@ class UtilityTests {
     }
 
     private fun filterByClimbType(
-            problems: List<ProblemData>,
+        problems: List<ProblemData>,
-            climbType: String
+        climbType: String,
     ): List<ProblemData> {
         return problems.filter { it.climbType == climbType }
     }
@@ -312,9 +312,9 @@ class UtilityTests {
     }
 
     private fun filterByDifficultyRange(
-            problems: List<ProblemData>,
+        problems: List<ProblemData>,
-            minGrade: String,
+        minGrade: String,
-            maxGrade: String
+        maxGrade: String,
     ): List<ProblemData> {
         return problems.filter { problem ->
             if (problem.climbType == "BOULDER" && problem.difficulty.startsWith("V")) {
@@ -329,17 +329,17 @@ class UtilityTests {
     }
 
     private fun mergeData(
-            local: Map<String, String>,
+        local: Map<String, String>,
-            server: Map<String, String>
+        server: Map<String, String>,
     ): Map<String, String> {
         return (local.keys + server.keys).associateWith { key -> server[key] ?: local[key]!! }
     }
 
     private fun isValidBackup(backup: BackupData): Boolean {
         return backup.version == "2.0" &&
-                backup.formatVersion == "2.0" &&
+            backup.formatVersion == "2.0" &&
-                backup.exportedAt.matches(Regex("\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z")) &&
+            backup.exportedAt.matches(Regex("\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z")) &&
-                backup.dataCount >= 0
+            backup.dataCount >= 0
     }
 
     // Data classes for testing
@@ -347,24 +347,24 @@ class UtilityTests {
     data class AttemptData(val result: String, val duration: Int)
 
     data class AttemptStatistics(
-            val totalAttempts: Int,
+        val totalAttempts: Int,
-            val successfulAttempts: Int,
+        val successfulAttempts: Int,
-            val successRate: Double,
+        val successRate: Double,
-            val averageDuration: Double
+        val averageDuration: Double,
     )
 
     data class ProblemData(
-            val id: String,
+        val id: String,
-            val name: String,
+        val name: String,
-            val climbType: String,
+        val climbType: String,
-            val difficulty: String,
+        val difficulty: String,
-            val tags: List<String>
+        val tags: List<String>,
     )
 
     data class BackupData(
-            val version: String,
+        val version: String,
-            val formatVersion: String,
+        val formatVersion: String,
-            val exportedAt: String,
+        val exportedAt: String,
-            val dataCount: Int
+        val dataCount: Int,
     )
 }

android/build.gradle.kts

@@ -3,4 +3,6 @@ plugins {
     alias(libs.plugins.android.application) apply false
     alias(libs.plugins.kotlin.android) apply false
     alias(libs.plugins.kotlin.compose) apply false
+    alias(libs.plugins.detekt) apply false
+    alias(libs.plugins.spotless) apply false
 }

android/detekt.yml

@@ -0,0 +1,584 @@
+build:
+  maxIssues: -1
+  excludeCorrectable: false
+
+config:
+  validation: true
+  warningsAsErrors: false
+
+processors:
+  active: true
+  exclude:
+    - 'DetektProgressListener'
+
+console-reports:
+  active: true
+
+output-reports:
+  active: true
+  exclude:
+    - 'TxtOutputReport'
+
+complexity:
+  active: true
+  ComplexCondition:
+    active: true
+    threshold: 5
+  CyclomaticComplexMethod:
+    active: true
+    threshold: 50
+    ignoreSingleWhenExpression: true
+    ignoreSimpleWhenEntries: true
+    ignoreNestingFunctions: false
+    nestingFunctions:
+      - 'also'
+      - 'apply'
+      - 'let'
+      - 'run'
+      - 'with'
+  LabeledExpression:
+    active: false
+  LargeClass:
+    active: true
+    threshold: 800
+  LongMethod:
+    active: true
+    threshold: 120
+    ignoreAnnotated:
+      - 'Composable'
+      - 'Test'
+  LongParameterList:
+    active: true
+    functionThreshold: 15
+    constructorThreshold: 15
+    ignoreDefaultParameters: true
+    ignoreDataClasses: true
+    ignoreAnnotatedParameter:
+      - 'Composable'
+  MethodOverloading:
+    active: false
+  NamedArguments:
+    active: false
+  NestedBlockDepth:
+    active: true
+    threshold: 8
+  NestedScopeFunctions:
+    active: true
+    threshold: 2
+    functions:
+      - 'also'
+      - 'apply'
+      - 'let'
+      - 'run'
+      - 'with'
+  ReplaceSafeCallChainWithRun:
+    active: false
+  StringLiteralDuplication:
+    active: false
+    threshold: 4
+    ignoreAnnotation: true
+    excludeStringsWithLessThan5Characters: true
+    ignoreStringsRegex: '$^'
+  TooManyFunctions:
+    active: true
+    thresholdInFiles: 40
+    thresholdInClasses: 40
+    thresholdInInterfaces: 25
+    thresholdInObjects: 25
+    thresholdInEnums: 15
+    ignoreDeprecated: true
+    ignorePrivate: true
+    ignoreOverridden: true
+
+coroutines:
+  active: true
+  GlobalCoroutineUsage:
+    active: true
+  InjectDispatcher:
+    active: true
+    dispatcherNames:
+      - 'IO'
+      - 'Default'
+      - 'Unconfined'
+  RedundantSuspendModifier:
+    active: true
+  SleepInsteadOfDelay:
+    active: true
+  SuspendFunSwallowedCancellation:
+    active: true
+  SuspendFunWithCoroutineScopeReceiver:
+    active: true
+  SuspendFunWithFlowReturnType:
+    active: true
+
+empty-blocks:
+  active: true
+  EmptyCatchBlock:
+    active: true
+    allowedExceptionNameRegex: '_|(ignore|expected).*'
+  EmptyClassBlock:
+    active: true
+  EmptyDefaultConstructor:
+    active: true
+  EmptyDoWhileBlock:
+    active: true
+  EmptyElseBlock:
+    active: true
+  EmptyFinallyBlock:
+    active: true
+  EmptyForBlock:
+    active: true
+  EmptyFunctionBlock:
+    active: true
+    ignoreOverridden: true
+  EmptyIfBlock:
+    active: true
+  EmptyInitBlock:
+    active: true
+  EmptyKtFile:
+    active: true
+  EmptySecondaryConstructor:
+    active: true
+  EmptyTryBlock:
+    active: true
+  EmptyWhenBlock:
+    active: true
+  EmptyWhileBlock:
+    active: true
+
+exceptions:
+  active: true
+  ExceptionRaisedInUnexpectedLocation:
+    active: true
+    methodNames:
+      - 'equals'
+      - 'finalize'
+      - 'hashCode'
+      - 'toString'
+  InstanceOfCheckForException:
+    active: true
+  NotImplementedDeclaration:
+    active: false
+  ObjectExtendsThrowable:
+    active: false
+  PrintStackTrace:
+    active: true
+  RethrowCaughtException:
+    active: true
+  ReturnFromFinally:
+    active: true
+  SwallowedException:
+    active: false
+    ignoredExceptionTypes:
+      - 'InterruptedException'
+      - 'MalformedURLException'
+      - 'NumberFormatException'
+      - 'ParseException'
+    allowedExceptionNameRegex: '_|(ignore|expected).*'
+  ThrowingExceptionFromFinally:
+    active: true
+  ThrowingExceptionInMain:
+    active: false
+  ThrowingExceptionsWithoutMessageOrCause:
+    active: true
+    excludes: ['**/test/**', '**/androidTest/**', '**/*.Test.kt', '**/*.Spec.kt', '**/*.Spek.kt']
+    exceptions:
+      - 'ArrayIndexOutOfBoundsException'
+      - 'Exception'
+      - 'IllegalArgumentException'
+      - 'IllegalMonitorStateException'
+      - 'IllegalStateException'
+      - 'IndexOutOfBoundsException'
+      - 'NullPointerException'
+      - 'RuntimeException'
+      - 'Throwable'
+  ThrowingNewInstanceOfSameException:
+    active: true
+  TooGenericExceptionCaught:
+    active: false
+    excludes: ['**/test/**', '**/androidTest/**', '**/*.Test.kt', '**/*.Spec.kt', '**/*.Spek.kt']
+    exceptionNames:
+      - 'ArrayIndexOutOfBoundsException'
+      - 'Error'
+      - 'Exception'
+      - 'IllegalMonitorStateException'
+      - 'IndexOutOfBoundsException'
+      - 'NullPointerException'
+      - 'RuntimeException'
+      - 'Throwable'
+    allowedExceptionNameRegex: '_|(ignore|expected).*'
+  TooGenericExceptionThrown:
+    active: false
+    exceptionNames:
+      - 'Error'
+      - 'Exception'
+      - 'RuntimeException'
+      - 'Throwable'
+
+naming:
+  active: true
+  BooleanPropertyNaming:
+    active: true
+    allowedPattern: '^(is|has|are|should|can|will|does|did)'
+  ClassNaming:
+    active: true
+    classPattern: '[A-Z][a-zA-Z0-9]*'
+  ConstructorParameterNaming:
+    active: true
+    parameterPattern: '[a-z][A-Za-z0-9]*'
+    privateParameterPattern: '[a-z][A-Za-z0-9]*'
+    excludeClassPattern: '$^'
+  EnumNaming:
+    active: true
+    enumEntryPattern: '[A-Z][_a-zA-Z0-9]*'
+  ForbiddenClassName:
+    active: false
+  FunctionMaxLength:
+    active: false
+  FunctionMinLength:
+    active: false
+  FunctionNaming:
+    active: true
+    functionPattern: '[a-zA-Z][a-zA-Z0-9]*'
+    excludeClassPattern: '$^'
+    ignoreAnnotated:
+      - 'Composable'
+  FunctionParameterNaming:
+    active: true
+    parameterPattern: '[a-z][A-Za-z0-9]*'
+    excludeClassPattern: '$^'
+  InvalidPackageDeclaration:
+    active: true
+    rootPackage: 'com.atridad.ascently'
+  LambdaParameterNaming:
+    active: true
+    parameterPattern: '[a-z][A-Za-z0-9]*|_'
+  MatchingDeclarationName:
+    active: false
+    mustBeFirst: true
+  MemberNameEqualsClassName:
+    active: true
+    ignoreOverridden: true
+  NoNameShadowing:
+    active: true
+  NonBooleanPropertyPrefixedWithIs:
+    active: true
+  ObjectPropertyNaming:
+    active: false
+  PackageNaming:
+    active: true
+    packagePattern: '[a-z]+(\.[a-z][A-Za-z0-9]*)*'
+  TopLevelPropertyNaming:
+    active: true
+    constantPattern: '[A-Z][_A-Z0-9]*'
+    propertyPattern: '[A-Za-z][_A-Za-z0-9]*'
+    privatePropertyPattern: '_?[A-Za-z][A-Za-z0-9]*'
+  VariableMaxLength:
+    active: false
+  VariableMinLength:
+    active: false
+  VariableNaming:
+    active: true
+    variablePattern: '[a-z][A-Za-z0-9]*'
+    privateVariablePattern: '[_a-z][A-Za-z0-9]*'
+    excludeClassPattern: '$^'
+
+performance:
+  active: true
+  ArrayPrimitive:
+    active: true
+  CouldBeSequence:
+    active: false
+  ForEachOnRange:
+    active: true
+  SpreadOperator:
+    active: false
+  UnnecessaryPartOfBinaryExpression:
+    active: true
+  UnnecessaryTemporaryInstantiation:
+    active: true
+
+potential-bugs:
+  active: true
+  AvoidReferentialEquality:
+    active: true
+  CastNullableToNonNullableType:
+    active: true
+  CastToNullableType:
+    active: false
+  Deprecation:
+    active: false
+  DontDowncastCollectionTypes:
+    active: true
+  DoubleMutabilityForCollection:
+    active: true
+  ElseCaseInsteadOfExhaustiveWhen:
+    active: false
+  EqualsAlwaysReturnsTrueOrFalse:
+    active: true
+  EqualsWithHashCodeExist:
+    active: true
+  ExitOutsideMain:
+    active: false
+  ExplicitGarbageCollectionCall:
+    active: true
+  HasPlatformType:
+    active: true
+  IgnoredReturnValue:
+    active: true
+  ImplicitDefaultLocale:
+    active: true
+  ImplicitUnitReturnType:
+    active: true
+    allowExplicitReturnType: true
+  InvalidRange:
+    active: true
+  IteratorHasNextCallsNextMethod:
+    active: true
+  IteratorNotThrowingNoSuchElementException:
+    active: true
+  LateinitUsage:
+    active: false
+  MapGetWithNotNullAssertionOperator:
+    active: true
+  MissingPackageDeclaration:
+    active: true
+  NullCheckOnMutableProperty:
+    active: true
+  NullableToStringCall:
+    active: true
+  PropertyUsedBeforeDeclaration:
+    active: false
+  UnconditionalJumpStatementInLoop:
+    active: true
+  UnnecessaryNotNullCheck:
+    active: true
+  UnnecessaryNotNullOperator:
+    active: true
+  UnnecessarySafeCall:
+    active: true
+  UnreachableCatchBlock:
+    active: true
+  UnreachableCode:
+    active: true
+  UnsafeCallOnNullableType:
+    active: true
+  UnsafeCast:
+    active: true
+  UnusedUnaryOperator:
+    active: true
+  UselessPostfixExpression:
+    active: true
+  WrongEqualsTypeParameter:
+    active: true
+
+style:
+  active: true
+  AlsoCouldBeApply:
+    active: false
+  BracesOnIfStatements:
+    active: false
+    singleLine: 'never'
+    multiLine: 'always'
+  BracesOnWhenStatements:
+    active: false
+    singleLine: 'necessary'
+    multiLine: 'necessary'
+  CanBeNonNullable:
+    active: true
+  CascadingCallWrapping:
+    active: false
+  ClassOrdering:
+    active: false
+  CollapsibleIfStatements:
+    active: false
+  DataClassContainsFunctions:
+    active: false
+  DataClassShouldBeImmutable:
+    active: true
+  DestructuringDeclarationWithTooManyEntries:
+    active: true
+    maxDestructuringEntries: 5
+  EqualsNullCall:
+    active: true
+  EqualsOnSignatureLine:
+    active: true
+  ExplicitCollectionElementAccessMethod:
+    active: true
+  ExplicitItLambdaParameter:
+    active: false
+  ExpressionBodySyntax:
+    active: false
+    includeLineWrapping: false
+  ForbiddenAnnotation:
+    active: false
+  ForbiddenComment:
+    active: false
+  ForbiddenImport:
+    active: false
+  ForbiddenMethodCall:
+    active: false
+  ForbiddenSuppress:
+    active: false
+  ForbiddenVoid:
+    active: true
+    ignoreOverridden: true
+    ignoreUsageInGenerics: true
+  FunctionOnlyReturningConstant:
+    active: false
+    ignoreOverridableFunction: true
+    ignoreActualFunction: true
+    excludedFunctions: []
+  LoopWithTooManyJumpStatements:
+    active: true
+    maxJumpCount: 2
+  MagicNumber:
+    active: false
+  MandatoryBracesLoops:
+    active: true
+  MaxChainedCallsOnSameLine:
+    active: true
+    maxChainedCalls: 5
+  MaxLineLength:
+    active: true
+    maxLineLength: 220
+    excludePackageStatements: true
+    excludeImportStatements: true
+    excludeCommentStatements: true
+    excludeRawStrings: true
+  MayBeConst:
+    active: true
+  ModifierOrder:
+    active: true
+  MultilineRawStringIndentation:
+    active: false
+    indentSize: 4
+  MultilineLambdaItParameter:
+    active: true
+  NestedClassesVisibility:
+    active: true
+  NewLineAtEndOfFile:
+    active: false
+  NoTabs:
+    active: true
+  NullableBooleanCheck:
+    active: true
+  ObjectLiteralToLambda:
+    active: true
+  OptionalAbstractKeyword:
+    active: true
+  OptionalUnit:
+    active: true
+  PreferToOverPairSyntax:
+    active: true
+  ProtectedMemberInFinalClass:
+    active: true
+  RedundantExplicitType:
+    active: true
+  RedundantHigherOrderMapUsage:
+    active: true
+  RedundantVisibilityModifierRule:
+    active: false
+  ReturnCount:
+    active: true
+    max: 6
+    excludedFunctions:
+      - 'equals'
+    excludeLabeled: true
+    excludeReturnFromLambda: true
+    excludeGuardClauses: true
+  SafeCast:
+    active: true
+  SerialVersionUIDInSerializableClass:
+    active: false
+  SpacingBetweenPackageAndImports:
+    active: true
+  StringShouldBeRawString:
+    active: false
+  ThrowsCount:
+    active: true
+    max: 10
+    excludeGuardClauses: true
+  TrailingWhitespace:
+    active: false
+  TrimMultilineRawString:
+    active: true
+  UnderscoresInNumericLiterals:
+    active: false
+    acceptableLength: 4
+    allowNonStandardGrouping: false
+  UnnecessaryAbstractClass:
+    active: true
+  UnnecessaryAnnotationUseSiteTarget:
+    active: true
+  UnnecessaryApply:
+    active: true
+  UnnecessaryBackticks:
+    active: true
+  UnnecessaryBracesAroundTrailingLambda:
+    active: true
+  UnnecessaryFilter:
+    active: true
+  UnnecessaryInheritance:
+    active: true
+  UnnecessaryInnerClass:
+    active: true
+  UnnecessaryLet:
+    active: true
+  UnnecessaryParentheses:
+    active: false
+    allowForUnclearPrecedence: true
+  UntilInsteadOfRangeTo:
+    active: true
+  UnusedImports:
+    active: true
+  UnusedParameter:
+    active: true
+    allowedNames: 'ignored|expected|_|session|startTime|endTime|xAxisFormatter'
+  UnusedPrivateClass:
+    active: true
+  UnusedPrivateMember:
+    active: true
+    allowedNames: '(_|ignored|expected|serialVersionUID)'
+  UnusedPrivateProperty:
+    active: true
+    allowedNames: '_|ignored|expected|serialVersionUID'
+  UseAnyOrNoneInsteadOfFind:
+    active: true
+  UseArrayLiteralsInAnnotations:
+    active: true
+  UseCheckNotNull:
+    active: true
+  UseCheckOrError:
+    active: true
+  UseDataClass:
+    active: false
+  UseEmptyCounterpart:
+    active: true
+  UseIfEmptyOrIfBlank:
+    active: true
+  UseIfInsteadOfWhen:
+    active: false
+  UseIsNullOrEmpty:
+    active: true
+  UseLet:
+    active: false
+  UseOrEmpty:
+    active: true
+  UseRequire:
+    active: true
+  UseRequireNotNull:
+    active: true
+  UseSumOfInsteadOfFlatMapSize:
+    active: true
+  UselessCallOnNotNull:
+    active: true
+  UtilityClassWithPublicConstructor:
+    active: true
+  VarCouldBeVal:
+    active: true
+  WildcardImport:
+    active: false
+    excludeImports:
+      - 'java.util.*'
+      - 'kotlinx.android.synthetic.*'

android/gradle.properties

@@ -10,7 +10,11 @@ org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
 # When configured, Gradle will run in incubating parallel mode.
 # This option should only be used with decoupled projects. For more details, visit
 # https://developer.android.com/r/tools/gradle-multi-project-decoupled-projects
-# org.gradle.parallel=true
+org.gradle.parallel=true
+# Enable Gradle build caching for faster incremental builds
+org.gradle.caching=true
+# Enable configuration caching for faster configuration phase
+org.gradle.configuration-cache=true
 # AndroidX package structure to make it clearer which packages are bundled with the
 # Android operating system, and which are packaged with your app's APK
 # https://developer.android.com/topic/libraries/support-library/androidx-rn

android/gradle/libs.versions.toml

@@ -1,6 +1,6 @@
 [versions]
 agp = "8.12.3"
-kotlin = "2.2.20"
+kotlin = "2.3.0"
 coreKtx = "1.17.0"
 junit = "4.13.2"
 junitVersion = "1.3.0"
@@ -9,17 +9,20 @@ androidxTestCore = "1.7.0"
 androidxTestExt = "1.3.0"
 androidxTestRunner = "1.7.0"
 androidxTestRules = "1.7.0"
-lifecycleRuntimeKtx = "2.9.4"
+lifecycleRuntimeKtx = "2.10.0"
-activityCompose = "1.11.0"
+activityCompose = "1.12.2"
-composeBom = "2025.10.00"
+composeBom = "2025.12.01"
-room = "2.8.2"
+room = "2.8.4"
-navigation = "2.9.5"
+navigation = "2.9.6"
-viewmodel = "2.9.4"
+viewmodel = "2.10.0"
 kotlinxSerialization = "1.9.0"
 kotlinxCoroutines = "1.10.2"
 coil = "2.7.0"
 ksp = "2.2.20-2.0.3"
-exifinterface = "1.3.6"
+exifinterface = "1.4.2"
+healthConnect = "1.1.0"
+detekt = "1.23.8"
+spotless = "8.1.0"
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
@@ -69,9 +72,14 @@ mockk = { group = "io.mockk", name = "mockk", version = "1.14.6" }
 coil-compose = { group = "io.coil-kt", name = "coil-compose", version.ref = "coil" }
 androidx-exifinterface = { group = "androidx.exifinterface", name = "exifinterface", version.ref = "exifinterface" }
 
+# Health Connect
+health-connect = { group = "androidx.health.connect", name = "connect-client", version.ref = "healthConnect" }
+
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
 kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
 ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
+detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
+spotless = { id = "com.diffplug.spotless", version.ref = "spotless" }

docs/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ascently-docs",
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Documentation site for Ascently - FOSS climbing tracking app",
   "repository": {
     "type": "git",
@@ -26,8 +26,8 @@
   },
   "dependencies": {
     "@astrojs/node": "^9.5.1",
-    "@astrojs/starlight": "^0.36.2",
+    "@astrojs/starlight": "^0.37.1",
-    "astro": "^5.16.0",
+    "astro": "^5.16.5",
     "qrcode": "^1.5.4",
     "sharp": "^0.34.5"
   },

docs/pnpm-lock.yaml

@@ -10,13 +10,13 @@ importers:
     dependencies:
       '@astrojs/node':
         specifier: ^9.5.1
-        version: 9.5.1(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))
+        version: 9.5.1(astro@5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3))
       '@astrojs/starlight':
-        specifier: ^0.36.2
+        specifier: ^0.37.1
-        version: 0.36.2(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))
+        version: 0.37.1(astro@5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3))
       astro:
-        specifier: ^5.16.0
+        specifier: ^5.16.5
-        version: 5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
+        version: 5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3)
       qrcode:
         specifier: ^1.5.4
         version: 1.5.4
@@ -36,11 +36,11 @@ packages:
   '@astrojs/internal-helpers@0.7.5':
     resolution: {integrity: sha512-vreGnYSSKhAjFJCWAwe/CNhONvoc5lokxtRoZims+0wa3KbHBdPHSSthJsKxPd8d/aic6lWKpRTYGY/hsgK6EA==}
 
-  '@astrojs/markdown-remark@6.3.9':
+  '@astrojs/markdown-remark@6.3.10':
-    resolution: {integrity: sha512-hX2cLC/KW74Io1zIbn92kI482j9J7LleBLGCVU9EP3BeH5MVrnFawOnqD0t/q6D1Z+ZNeQG2gNKMslCcO36wng==}
+    resolution: {integrity: sha512-kk4HeYR6AcnzC4QV8iSlOfh+N8TZ3MEStxPyenyCtemqn8IpEATBFMTJcfrNW32dgpt6MY3oCkMM/Tv3/I4G3A==}
 
-  '@astrojs/mdx@4.3.12':
+  '@astrojs/mdx@4.3.13':
-    resolution: {integrity: sha512-pL3CVPtuQrPnDhWjy7zqbOibNyPaxP4VpQS8T8spwKqKzauJ4yoKyNkVTD8jrP7EAJHmBhZ7PTmUGZqOpKKp8g==}
+    resolution: {integrity: sha512-IHDHVKz0JfKBy3//52JSiyWv089b7GVSChIXLrlUOoTLWowG3wr2/8hkaEgEyd/vysvNQvGk+QhysXpJW5ve6Q==}
     engines: {node: 18.20.8 || ^20.3.0 || >=22.0.0}
     peerDependencies:
       astro: ^5.0.0
@@ -57,8 +57,8 @@ packages:
   '@astrojs/sitemap@3.6.0':
     resolution: {integrity: sha512-4aHkvcOZBWJigRmMIAJwRQXBS+ayoP5z40OklTXYXhUDhwusz+DyDl+nSshY6y9DvkVEavwNcFO8FD81iGhXjg==}
 
-  '@astrojs/starlight@0.36.2':
+  '@astrojs/starlight@0.37.1':
-    resolution: {integrity: sha512-QR8NfO7+7DR13kBikhQwAj3IAoptLLNs9DkyKko2M2l3PrqpcpVUnw1JBJ0msGDIwE6tBbua2UeBND48mkh03w==}
+    resolution: {integrity: sha512-STNsR5PaDoiW4IgcX17Fp42FfyqwuweWPts/EWEMcFPAeg9Nvpu3UvVCorasYrgfJgaJTeydsOV++0ACA1KYDA==}
     peerDependencies:
       astro: ^5.5.0
 
@@ -254,17 +254,17 @@ packages:
     cpu: [x64]
     os: [win32]
 
-  '@expressive-code/core@0.41.3':
+  '@expressive-code/core@0.41.4':
-    resolution: {integrity: sha512-9qzohqU7O0+JwMEEgQhnBPOw5DtsQRBXhW++5fvEywsuX44vCGGof1SL5OvPElvNgaWZ4pFZAFSlkNOkGyLwSQ==}
+    resolution: {integrity: sha512-4eDiyq3hI3vJ0KnwIqonh9evy9p8aNixsf5wwnvDWcoPfYU3LGB6Nkb6WDdYS4z52tODCvN5gMRy1DtRopcxXg==}
 
-  '@expressive-code/plugin-frames@0.41.3':
+  '@expressive-code/plugin-frames@0.41.4':
-    resolution: {integrity: sha512-rFQtmf/3N2CK3Cq/uERweMTYZnBu+CwxBdHuOftEmfA9iBE7gTVvwpbh82P9ZxkPLvc40UMhYt7uNuAZexycRQ==}
+    resolution: {integrity: sha512-W9jZW8LsPS8fW5T5CQyXUyyCrMxb7qfl6oxlLZB1rW74qM572Id4CWEXOM/7fFDcd1pW2fUxMoGzJMh0T2Awhg==}
 
-  '@expressive-code/plugin-shiki@0.41.3':
+  '@expressive-code/plugin-shiki@0.41.4':
-    resolution: {integrity: sha512-RlTARoopzhFJIOVHLGvuXJ8DCEme/hjV+ZnRJBIxzxsKVpGPW4Oshqg9xGhWTYdHstTsxO663s0cdBLzZj9TQA==}
+    resolution: {integrity: sha512-zOc0tfWISODHnnpfRJyssTvSWVVe+gj08GcFYiR2a6M8fKF1w5CJkpgf7tTvnoUTuVmL1DHRmiQFUnpGjtRGog==}
 
-  '@expressive-code/plugin-text-markers@0.41.3':
+  '@expressive-code/plugin-text-markers@0.41.4':
-    resolution: {integrity: sha512-SN8tkIzDpA0HLAscEYD2IVrfLiid6qEdE9QLlGVSxO1KEw7qYvjpbNBQjUjMr5/jvTJ7ys6zysU2vLPHE0sb2g==}
+    resolution: {integrity: sha512-lGqbjtIuiY+UZ+z61kKIJAZtF7H5xoT8lkxANmeoVaat+H47O5A+rr5WLmD45ezprO/NTogxHsaMfqRCuQ4vlw==}
 
   '@img/colour@1.0.0':
     resolution: {integrity: sha512-A5P/LfWGFSl6nsckYtjw9da+19jB8hkJ6ACTGcDfEJ0aE+l2n2El7dsVM7UVHZQ9s2lmYMWlrS21YLy2IR1LUw==}
@@ -564,23 +564,23 @@ packages:
     cpu: [x64]
     os: [win32]
 
-  '@shikijs/core@3.15.0':
+  '@shikijs/core@3.20.0':
-    resolution: {integrity: sha512-8TOG6yG557q+fMsSVa8nkEDOZNTSxjbbR8l6lF2gyr6Np+jrPlslqDxQkN6rMXCECQ3isNPZAGszAfYoJOPGlg==}
+    resolution: {integrity: sha512-f2ED7HYV4JEk827mtMDwe/yQ25pRiXZmtHjWF8uzZKuKiEsJR7Ce1nuQ+HhV9FzDcbIo4ObBCD9GPTzNuy9S1g==}
 
-  '@shikijs/engine-javascript@3.15.0':
+  '@shikijs/engine-javascript@3.20.0':
-    resolution: {integrity: sha512-ZedbOFpopibdLmvTz2sJPJgns8Xvyabe2QbmqMTz07kt1pTzfEvKZc5IqPVO/XFiEbbNyaOpjPBkkr1vlwS+qg==}
+    resolution: {integrity: sha512-OFx8fHAZuk7I42Z9YAdZ95To6jDePQ9Rnfbw9uSRTSbBhYBp1kEOKv/3jOimcj3VRUKusDYM6DswLauwfhboLg==}
 
-  '@shikijs/engine-oniguruma@3.15.0':
+  '@shikijs/engine-oniguruma@3.20.0':
-    resolution: {integrity: sha512-HnqFsV11skAHvOArMZdLBZZApRSYS4LSztk2K3016Y9VCyZISnlYUYsL2hzlS7tPqKHvNqmI5JSUJZprXloMvA==}
+    resolution: {integrity: sha512-Yx3gy7xLzM0ZOjqoxciHjA7dAt5tyzJE3L4uQoM83agahy+PlW244XJSrmJRSBvGYELDhYXPacD4R/cauV5bzQ==}
 
-  '@shikijs/langs@3.15.0':
+  '@shikijs/langs@3.20.0':
-    resolution: {integrity: sha512-WpRvEFvkVvO65uKYW4Rzxs+IG0gToyM8SARQMtGGsH4GDMNZrr60qdggXrFOsdfOVssG/QQGEl3FnJ3EZ+8w8A==}
+    resolution: {integrity: sha512-le+bssCxcSHrygCWuOrYJHvjus6zhQ2K7q/0mgjiffRbkhM4o1EWu2m+29l0yEsHDbWaWPNnDUTRVVBvBBeKaA==}
 
-  '@shikijs/themes@3.15.0':
+  '@shikijs/themes@3.20.0':
-    resolution: {integrity: sha512-8ow2zWb1IDvCKjYb0KiLNrK4offFdkfNVPXb1OZykpLCzRU6j+efkY+Y7VQjNlNFXonSw+4AOdGYtmqykDbRiQ==}
+    resolution: {integrity: sha512-U1NSU7Sl26Q7ErRvJUouArxfM2euWqq1xaSrbqMu2iqa+tSp0D1Yah8216sDYbdDHw4C8b75UpE65eWorm2erQ==}
 
-  '@shikijs/types@3.15.0':
+  '@shikijs/types@3.20.0':
-    resolution: {integrity: sha512-BnP+y/EQnhihgHy4oIAN+6FFtmfTekwOLsQbRw9hOKwqgNy8Bdsjq8B05oAt/ZgvIWWFrshV71ytOrlPfYjIJw==}
+    resolution: {integrity: sha512-lhYAATn10nkZcBQ0BlzSbJA3wcmL5MXUUF8d2Zzon6saZDlToKaiRX60n2+ZaHJCmXEcZRWNzn+k9vplr8Jhsw==}
 
   '@shikijs/vscode-textmate@10.0.2':
     resolution: {integrity: sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==}
@@ -621,8 +621,8 @@ packages:
   '@types/node@17.0.45':
     resolution: {integrity: sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw==}
 
-  '@types/node@24.10.1':
+  '@types/node@25.0.1':
-    resolution: {integrity: sha512-GNWcUTRBgIRJD5zj+Tq0fKOJ5XZajIiBroOF0yvj2bSU1WvNdYS/dn9UxwsujGW4JX06dnHyjV2y9rRaybH0iQ==}
+    resolution: {integrity: sha512-czWPzKIAXucn9PtsttxmumiQ9N0ok9FrBwgRWrwmVLlp86BrMExzvXRLFYRJ+Ex3g6yqj+KuaxfX1JTgV2lpfg==}
 
   '@types/qrcode@1.5.6':
     resolution: {integrity: sha512-te7NQcV2BOvdj2b1hCAHzAoMNuj65kNBMz0KBaxM6c3VGBOhU0dURQKOtH8CFNI/dsKkwlv32p26qYQTWoB5bw==}
@@ -689,13 +689,13 @@ packages:
     resolution: {integrity: sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==}
     hasBin: true
 
-  astro-expressive-code@0.41.3:
+  astro-expressive-code@0.41.4:
-    resolution: {integrity: sha512-u+zHMqo/QNLE2eqYRCrK3+XMlKakv33Bzuz+56V1gs8H0y6TZ0hIi3VNbIxeTn51NLn+mJfUV/A0kMNfE4rANw==}
+    resolution: {integrity: sha512-LK6EcK/hIHfOSo9zqapzu4CbTC0YBtMOVdvWjInpB2SgYtxiF22aZDqdpejN8J28mWPqPLQwSqdl2lWuirNXmw==}
     peerDependencies:
       astro: ^4.0.0-beta || ^5.0.0-beta || ^3.3.0
 
-  astro@5.16.0:
+  astro@5.16.5:
-    resolution: {integrity: sha512-GaDRs2Mngpw3dr2vc085GnORh98NiXxwIjg/EoQQQl/icZt3Z7s0BRsYHDZ8swkZbOA6wZsqWJdrNirl+iKcDg==}
+    resolution: {integrity: sha512-QeuM4xzTR0QuXFDNlGVW0BW7rcquKFIkylaPeM4ufii0/RRiPTYtwxDYVZ3KfiMRuuc+nbLD0214kMKTvz/yvQ==}
     engines: {node: 18.20.8 || ^20.3.0 || >=22.0.0, npm: '>=9.6.5', pnpm: '>=7.1.0'}
     hasBin: true
 
@@ -801,8 +801,8 @@ packages:
   cookie-es@1.2.2:
     resolution: {integrity: sha512-+W7VmiVINB+ywl1HGXJXmrqkOhpKrIiVZV6tQuV54ZyQC7MMuBt81Vc336GMLoHBq5hV/F9eXgt5Mnx0Rha5Fg==}
 
-  cookie@1.0.2:
+  cookie@1.1.1:
-    resolution: {integrity: sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA==}
+    resolution: {integrity: sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==}
     engines: {node: '>=18'}
 
   crossws@0.3.5:
@@ -873,8 +873,8 @@ packages:
     resolution: {integrity: sha512-KxektNH63SrbfUyDiwXqRb1rLwKt33AmMv+5Nhsw1kqZ13SJBRTgZHtGbE+hH3a1mVW1cz+4pqSWVPAtLVXTzQ==}
     engines: {node: '>=18'}
 
-  devalue@5.5.0:
+  devalue@5.6.1:
-    resolution: {integrity: sha512-69sM5yrHfFLJt0AZ9QqZXGCPfJ7fQjvpln3Rq5+PS03LD32Ost1Q9N+eEnaQwGRIriKkMImXD56ocjQmfjbV3w==}
+    resolution: {integrity: sha512-jDwizj+IlEZBunHcOuuFVBnIMPAEHvTsJj0BcIp94xYguLRVBcXO853px/MyIJvbVzWdsGvrRweIUWJw8hBP7A==}
 
   devlop@1.1.0:
     resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==}
@@ -986,8 +986,8 @@ packages:
   eventemitter3@5.0.1:
     resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==}
 
-  expressive-code@0.41.3:
+  expressive-code@0.41.4:
-    resolution: {integrity: sha512-YLnD62jfgBZYrXIPQcJ0a51Afv9h8VlWqEGK9uU2T5nL/5rb8SnA86+7+mgCZe5D34Tff5RNEA5hjNVJYHzrFg==}
+    resolution: {integrity: sha512-A9aFLhgqLkL6VSfqYkPqkJVMtA90/bhCLmUO7L3/a1xWISNMcHoCS6d6i8ePwi8HvHr3xRLswHTNt6NheTjdXA==}
 
   extend@3.0.2:
     resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==}
@@ -1086,8 +1086,8 @@ packages:
   hast-util-to-jsx-runtime@2.3.6:
     resolution: {integrity: sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==}
 
-  hast-util-to-parse5@8.0.0:
+  hast-util-to-parse5@8.0.1:
-    resolution: {integrity: sha512-3KKrV5ZVI8if87DVSi1vDeByYrkGzg4mEfeu4alwgmmIeARiBLKCZS2uw5Gb6nU9x9Yufyj3iudm6i7nl52PFw==}
+    resolution: {integrity: sha512-MlWT6Pjt4CG9lFCjiz4BH7l9wmrMkfkJYCxFwKQic8+RTZgWPuWxwAfjJElsXkex7DJjfSJsQIt931ilUgmwdA==}
 
   hast-util-to-string@3.0.1:
     resolution: {integrity: sha512-XelQVTDWvqcl3axRfI0xSeoVKzyIFPwsAGSLIsKdJKQMXDYJS4WYrBNF/8J7RdhIcFI2BOHgAifggsvsxp/3+A==}
@@ -1246,8 +1246,8 @@ packages:
   mdast-util-phrasing@4.1.0:
     resolution: {integrity: sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==}
 
-  mdast-util-to-hast@13.2.0:
+  mdast-util-to-hast@13.2.1:
-    resolution: {integrity: sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==}
+    resolution: {integrity: sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==}
 
   mdast-util-to-markdown@2.1.2:
     resolution: {integrity: sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==}
@@ -1399,8 +1399,8 @@ packages:
   node-fetch-native@1.6.7:
     resolution: {integrity: sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q==}
 
-  node-mock-http@1.0.3:
+  node-mock-http@1.0.4:
-    resolution: {integrity: sha512-jN8dK25fsfnMrVsEhluUTPkBFY+6ybu7jSB1n+ri/vOGjJxU8J9CZhpSGkHXSkFjtUhbmoncG/YG9ta5Ludqog==}
+    resolution: {integrity: sha512-8DY+kFsDkNXy1sJglUfuODx1/opAGJGyrTuFqEoN90oRc2Vk0ZbD4K2qmKXBBEhZQzdKHIVfEJpDU8Ak2NJEvQ==}
 
   normalize-path@3.0.0:
     resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
@@ -1422,8 +1422,8 @@ packages:
   oniguruma-parser@0.12.1:
     resolution: {integrity: sha512-8Unqkvk1RYc6yq2WBYRj4hdnsAxVze8i7iPfQr8e4uSP3tRv0rpZcbGUDvxfQQcdwHt/e9PrMvGCsa8OqG9X3w==}
 
-  oniguruma-to-es@4.3.3:
+  oniguruma-to-es@4.3.4:
-    resolution: {integrity: sha512-rPiZhzC3wXwE59YQMRDodUwwT9FZ9nNBwQQfsd1wfdtlKEyCdRV0avrTcSZ5xlIvGRVPd/cx6ZN45ECmS39xvg==}
+    resolution: {integrity: sha512-3VhUGN3w2eYxnTzHn+ikMI+fp/96KoRSVK9/kMTcFqj1NRDh2IhQCKvYxDnWePKRXY/AqH+Fuiyb7VHSzBjHfA==}
 
   p-limit@2.3.0:
     resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
@@ -1449,8 +1449,8 @@ packages:
     resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
     engines: {node: '>=6'}
 
-  package-manager-detector@1.5.0:
+  package-manager-detector@1.6.0:
-    resolution: {integrity: sha512-uBj69dVlYe/+wxj8JOpr97XfsxH/eumMt6HqjNTmJDf/6NO9s+0uxeOneIz3AsPt2m6y9PqzDzd3ATcU17MNfw==}
+    resolution: {integrity: sha512-61A5ThoTiDG/C8s8UMZwSorAGwMJ0ERVGj2OjoW5pAalsNOg15+iQiPzrLJ4jhZ1HJzmC2PIHT2oEiH3R5fzNA==}
 
   pagefind@1.4.0:
     resolution: {integrity: sha512-z2kY1mQlL4J8q5EIsQkLzQjilovKzfNVhX8De6oyE6uHpfFtyBaqUpcl/XzJC/4fjD8vBDyh1zolimIcVrCn9g==}
@@ -1512,9 +1512,6 @@ packages:
     resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==}
     engines: {node: '>= 6'}
 
-  property-information@6.5.0:
-    resolution: {integrity: sha512-PgTgs/BlvHxOu8QuEN7wi5A0OmXaBcHpmCSTehcs6Uuu9IkDIEo13Hy7n898RHfrQ49vKCoGeWZSaAK01nwVig==}
-
   property-information@7.1.0:
     resolution: {integrity: sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==}
 
@@ -1554,11 +1551,11 @@ packages:
   regex-utilities@2.3.0:
     resolution: {integrity: sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==}
 
-  regex@6.0.1:
+  regex@6.1.0:
-    resolution: {integrity: sha512-uorlqlzAKjKQZ5P+kTJr3eeJGSVroLKoHmquUj4zHWuR+hEyNqlXsSKlYYF5F4NI6nl7tWCs0apKJ0lmfsXAPA==}
+    resolution: {integrity: sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg==}
 
-  rehype-expressive-code@0.41.3:
+  rehype-expressive-code@0.41.4:
-    resolution: {integrity: sha512-8d9Py4c/V6I/Od2VIXFAdpiO2kc0SV2qTJsRAaqSIcM9aruW4ASLNe2kOEo1inXAAkIhpFzAHTc358HKbvpNUg==}
+    resolution: {integrity: sha512-qEUKfh/Aw9VZSUCXnJef41o7lpfnhXmQdXTkP2ZWGibSk4SoJVJ4ra1xN1t+hL1rp0d0GPKZ1CpM3q6bjV0xbg==}
 
   rehype-format@5.0.1:
     resolution: {integrity: sha512-zvmVru9uB0josBVpr946OR8ui7nJEdzZobwLOOqHb/OOD88W0Vk2SqLwoVOj0fM6IPCCO6TaV9CvQvJMWwukFQ==}
@@ -1652,8 +1649,8 @@ packages:
     resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==}
     engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
 
-  shiki@3.15.0:
+  shiki@3.20.0:
-    resolution: {integrity: sha512-kLdkY6iV3dYbtPwS9KXU7mjfmDm25f5m0IPNFnaXO7TBPcvbUOY72PYXSuSqDzwp+vlH/d7MXpHlKO/x+QoLXw==}
+    resolution: {integrity: sha512-kgCOlsnyWb+p0WU+01RjkCH+eBVsjL1jOwUYWv0YDWkM2/A46+LDKVs5yZCUXjJG6bj4ndFoAg5iLIIue6dulg==}
 
   sisteransi@1.0.5:
     resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==}
@@ -2009,7 +2006,7 @@ snapshots:
 
   '@astrojs/internal-helpers@0.7.5': {}
 
-  '@astrojs/markdown-remark@6.3.9':
+  '@astrojs/markdown-remark@6.3.10':
     dependencies:
       '@astrojs/internal-helpers': 0.7.5
       '@astrojs/prism': 3.3.0
@@ -2025,7 +2022,7 @@ snapshots:
       remark-parse: 11.0.0
       remark-rehype: 11.1.2
       remark-smartypants: 3.0.2
-      shiki: 3.15.0
+      shiki: 3.20.0
       smol-toml: 1.5.2
       unified: 11.0.5
       unist-util-remove-position: 5.0.0
@@ -2035,12 +2032,12 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@astrojs/mdx@4.3.12(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))':
+  '@astrojs/mdx@4.3.13(astro@5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3))':
     dependencies:
-      '@astrojs/markdown-remark': 6.3.9
+      '@astrojs/markdown-remark': 6.3.10
       '@mdx-js/mdx': 3.1.1
       acorn: 8.15.0
-      astro: 5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
+      astro: 5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3)
       es-module-lexer: 1.7.0
       estree-util-visit: 2.0.0
       hast-util-to-html: 9.0.5
@@ -2054,10 +2051,10 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@astrojs/node@9.5.1(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))':
+  '@astrojs/node@9.5.1(astro@5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3))':
     dependencies:
       '@astrojs/internal-helpers': 0.7.5
-      astro: 5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
+      astro: 5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3)
       send: 1.2.0
       server-destroy: 1.0.1
     transitivePeerDependencies:
@@ -2073,17 +2070,17 @@ snapshots:
       stream-replace-string: 2.0.0
       zod: 3.25.76
 
-  '@astrojs/starlight@0.36.2(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))':
+  '@astrojs/starlight@0.37.1(astro@5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3))':
     dependencies:
-      '@astrojs/markdown-remark': 6.3.9
+      '@astrojs/markdown-remark': 6.3.10
-      '@astrojs/mdx': 4.3.12(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))
+      '@astrojs/mdx': 4.3.13(astro@5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3))
       '@astrojs/sitemap': 3.6.0
       '@pagefind/default-ui': 1.4.0
       '@types/hast': 3.0.4
       '@types/js-yaml': 4.0.9
       '@types/mdast': 4.0.4
-      astro: 5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
+      astro: 5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3)
-      astro-expressive-code: 0.41.3(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3))
+      astro-expressive-code: 0.41.4(astro@5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3))
       bcp-47: 2.1.0
       hast-util-from-html: 2.0.3
       hast-util-select: 6.0.4
@@ -2092,6 +2089,7 @@ snapshots:
       i18next: 23.16.8
       js-yaml: 4.1.1
       klona: 2.0.6
+      magic-string: 0.30.21
       mdast-util-directive: 3.1.0
       mdast-util-to-markdown: 2.1.2
       mdast-util-to-string: 4.0.0
@@ -2222,7 +2220,7 @@ snapshots:
   '@esbuild/win32-x64@0.25.12':
     optional: true
 
-  '@expressive-code/core@0.41.3':
+  '@expressive-code/core@0.41.4':
     dependencies:
       '@ctrl/tinycolor': 4.2.0
       hast-util-select: 6.0.4
@@ -2234,18 +2232,18 @@ snapshots:
       unist-util-visit: 5.0.0
       unist-util-visit-parents: 6.0.2
 
-  '@expressive-code/plugin-frames@0.41.3':
+  '@expressive-code/plugin-frames@0.41.4':
     dependencies:
-      '@expressive-code/core': 0.41.3
+      '@expressive-code/core': 0.41.4
 
-  '@expressive-code/plugin-shiki@0.41.3':
+  '@expressive-code/plugin-shiki@0.41.4':
     dependencies:
-      '@expressive-code/core': 0.41.3
+      '@expressive-code/core': 0.41.4
-      shiki: 3.15.0
+      shiki: 3.20.0
 
-  '@expressive-code/plugin-text-markers@0.41.3':
+  '@expressive-code/plugin-text-markers@0.41.4':
     dependencies:
-      '@expressive-code/core': 0.41.3
+      '@expressive-code/core': 0.41.4
 
   '@img/colour@1.0.0': {}
 
@@ -2471,33 +2469,33 @@ snapshots:
   '@rollup/rollup-win32-x64-msvc@4.53.3':
     optional: true
 
-  '@shikijs/core@3.15.0':
+  '@shikijs/core@3.20.0':
     dependencies:
-      '@shikijs/types': 3.15.0
+      '@shikijs/types': 3.20.0
       '@shikijs/vscode-textmate': 10.0.2
       '@types/hast': 3.0.4
       hast-util-to-html: 9.0.5
 
-  '@shikijs/engine-javascript@3.15.0':
+  '@shikijs/engine-javascript@3.20.0':
     dependencies:
-      '@shikijs/types': 3.15.0
+      '@shikijs/types': 3.20.0
       '@shikijs/vscode-textmate': 10.0.2
-      oniguruma-to-es: 4.3.3
+      oniguruma-to-es: 4.3.4
 
-  '@shikijs/engine-oniguruma@3.15.0':
+  '@shikijs/engine-oniguruma@3.20.0':
     dependencies:
-      '@shikijs/types': 3.15.0
+      '@shikijs/types': 3.20.0
       '@shikijs/vscode-textmate': 10.0.2
 
-  '@shikijs/langs@3.15.0':
+  '@shikijs/langs@3.20.0':
     dependencies:
-      '@shikijs/types': 3.15.0
+      '@shikijs/types': 3.20.0
 
-  '@shikijs/themes@3.15.0':
+  '@shikijs/themes@3.20.0':
     dependencies:
-      '@shikijs/types': 3.15.0
+      '@shikijs/types': 3.20.0
 
-  '@shikijs/types@3.15.0':
+  '@shikijs/types@3.20.0':
     dependencies:
       '@shikijs/vscode-textmate': 10.0.2
       '@types/hast': 3.0.4
@@ -2520,7 +2518,7 @@ snapshots:
 
   '@types/fontkit@2.0.8':
     dependencies:
-      '@types/node': 24.10.1
+      '@types/node': 25.0.1
 
   '@types/hast@3.0.4':
     dependencies:
@@ -2542,13 +2540,13 @@ snapshots:
 
   '@types/node@17.0.45': {}
 
-  '@types/node@24.10.1':
+  '@types/node@25.0.1':
     dependencies:
       undici-types: 7.16.0
 
   '@types/qrcode@1.5.6':
     dependencies:
-      '@types/node': 24.10.1
+      '@types/node': 25.0.1
 
   '@types/sax@1.2.7':
     dependencies:
@@ -2595,16 +2593,16 @@ snapshots:
 
   astring@1.9.0: {}
 
-  astro-expressive-code@0.41.3(astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)):
+  astro-expressive-code@0.41.4(astro@5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3)):
     dependencies:
-      astro: 5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3)
+      astro: 5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3)
-      rehype-expressive-code: 0.41.3
+      rehype-expressive-code: 0.41.4
 
-  astro@5.16.0(@types/node@24.10.1)(rollup@4.53.3)(typescript@5.9.3):
+  astro@5.16.5(@types/node@25.0.1)(rollup@4.53.3)(typescript@5.9.3):
     dependencies:
       '@astrojs/compiler': 2.13.0
       '@astrojs/internal-helpers': 0.7.5
-      '@astrojs/markdown-remark': 6.3.9
+      '@astrojs/markdown-remark': 6.3.10
       '@astrojs/telemetry': 3.3.0
       '@capsizecss/unpack': 3.0.1
       '@oslojs/encoding': 1.1.0
@@ -2616,11 +2614,11 @@ snapshots:
       ci-info: 4.3.1
       clsx: 2.1.1
       common-ancestor-path: 1.0.1
-      cookie: 1.0.2
+      cookie: 1.1.1
       cssesc: 3.0.0
       debug: 4.4.3
       deterministic-object-hash: 2.0.2
-      devalue: 5.5.0
+      devalue: 5.6.1
       diff: 5.2.0
       dlv: 1.1.3
       dset: 3.1.4
@@ -2640,13 +2638,13 @@ snapshots:
       neotraverse: 0.6.18
       p-limit: 6.2.0
       p-queue: 8.1.1
-      package-manager-detector: 1.5.0
+      package-manager-detector: 1.6.0
       piccolore: 0.1.3
       picomatch: 4.0.3
       prompts: 2.4.2
       rehype: 13.0.2
       semver: 7.7.3
-      shiki: 3.15.0
+      shiki: 3.20.0
       smol-toml: 1.5.2
       svgo: 4.0.0
       tinyexec: 1.0.2
@@ -2657,8 +2655,8 @@ snapshots:
       unist-util-visit: 5.0.0
       unstorage: 1.17.3
       vfile: 6.0.3
-      vite: 6.4.1(@types/node@24.10.1)
+      vite: 6.4.1(@types/node@25.0.1)
-      vitefu: 1.1.1(vite@6.4.1(@types/node@24.10.1))
+      vitefu: 1.1.1(vite@6.4.1(@types/node@25.0.1))
       xxhash-wasm: 1.1.0
       yargs-parser: 21.1.1
       yocto-spinner: 0.2.3
@@ -2785,7 +2783,7 @@ snapshots:
 
   cookie-es@1.2.2: {}
 
-  cookie@1.0.2: {}
+  cookie@1.1.1: {}
 
   crossws@0.3.5:
     dependencies:
@@ -2843,7 +2841,7 @@ snapshots:
     dependencies:
       base-64: 1.0.0
 
-  devalue@5.5.0: {}
+  devalue@5.6.1: {}
 
   devlop@1.1.0:
     dependencies:
@@ -2979,12 +2977,12 @@ snapshots:
 
   eventemitter3@5.0.1: {}
 
-  expressive-code@0.41.3:
+  expressive-code@0.41.4:
     dependencies:
-      '@expressive-code/core': 0.41.3
+      '@expressive-code/core': 0.41.4
-      '@expressive-code/plugin-frames': 0.41.3
+      '@expressive-code/plugin-frames': 0.41.4
-      '@expressive-code/plugin-shiki': 0.41.3
+      '@expressive-code/plugin-shiki': 0.41.4
-      '@expressive-code/plugin-text-markers': 0.41.3
+      '@expressive-code/plugin-text-markers': 0.41.4
 
   extend@3.0.2: {}
 
@@ -3036,7 +3034,7 @@ snapshots:
       defu: 6.1.4
       destr: 2.0.5
       iron-webcrypto: 1.2.1
-      node-mock-http: 1.0.3
+      node-mock-http: 1.0.4
       radix3: 1.1.2
       ufo: 1.6.1
       uncrypto: 0.1.3
@@ -3114,9 +3112,9 @@ snapshots:
       '@types/unist': 3.0.3
       '@ungap/structured-clone': 1.3.0
       hast-util-from-parse5: 8.0.3
-      hast-util-to-parse5: 8.0.0
+      hast-util-to-parse5: 8.0.1
       html-void-elements: 3.0.0
-      mdast-util-to-hast: 13.2.0
+      mdast-util-to-hast: 13.2.1
       parse5: 7.3.0
       unist-util-position: 5.0.0
       unist-util-visit: 5.0.0
@@ -3171,7 +3169,7 @@ snapshots:
       comma-separated-tokens: 2.0.3
       hast-util-whitespace: 3.0.0
       html-void-elements: 3.0.0
-      mdast-util-to-hast: 13.2.0
+      mdast-util-to-hast: 13.2.1
       property-information: 7.1.0
       space-separated-tokens: 2.0.2
       stringify-entities: 4.0.4
@@ -3197,12 +3195,12 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  hast-util-to-parse5@8.0.0:
+  hast-util-to-parse5@8.0.1:
     dependencies:
       '@types/hast': 3.0.4
       comma-separated-tokens: 2.0.3
       devlop: 1.1.0
-      property-information: 6.5.0
+      property-information: 7.1.0
       space-separated-tokens: 2.0.2
       web-namespaces: 2.0.1
       zwitch: 2.0.4
@@ -3468,7 +3466,7 @@ snapshots:
       '@types/mdast': 4.0.4
       unist-util-is: 6.0.1
 
-  mdast-util-to-hast@13.2.0:
+  mdast-util-to-hast@13.2.1:
     dependencies:
       '@types/hast': 3.0.4
       '@types/mdast': 4.0.4
@@ -3794,7 +3792,7 @@ snapshots:
 
   node-fetch-native@1.6.7: {}
 
-  node-mock-http@1.0.3: {}
+  node-mock-http@1.0.4: {}
 
   normalize-path@3.0.0: {}
 
@@ -3816,10 +3814,10 @@ snapshots:
 
   oniguruma-parser@0.12.1: {}
 
-  oniguruma-to-es@4.3.3:
+  oniguruma-to-es@4.3.4:
     dependencies:
       oniguruma-parser: 0.12.1
-      regex: 6.0.1
+      regex: 6.1.0
       regex-recursion: 6.0.2
 
   p-limit@2.3.0:
@@ -3843,7 +3841,7 @@ snapshots:
 
   p-try@2.2.0: {}
 
-  package-manager-detector@1.5.0: {}
+  package-manager-detector@1.6.0: {}
 
   pagefind@1.4.0:
     optionalDependencies:
@@ -3914,8 +3912,6 @@ snapshots:
       kleur: 3.0.3
       sisteransi: 1.0.5
 
-  property-information@6.5.0: {}
-
   property-information@7.1.0: {}
 
   qrcode@1.5.4:
@@ -3965,13 +3961,13 @@ snapshots:
 
   regex-utilities@2.3.0: {}
 
-  regex@6.0.1:
+  regex@6.1.0:
     dependencies:
       regex-utilities: 2.3.0
 
-  rehype-expressive-code@0.41.3:
+  rehype-expressive-code@0.41.4:
     dependencies:
-      expressive-code: 0.41.3
+      expressive-code: 0.41.4
 
   rehype-format@5.0.1:
     dependencies:
@@ -4051,7 +4047,7 @@ snapshots:
     dependencies:
       '@types/hast': 3.0.4
       '@types/mdast': 4.0.4
-      mdast-util-to-hast: 13.2.0
+      mdast-util-to-hast: 13.2.1
       unified: 11.0.5
       vfile: 6.0.3
 
@@ -4184,14 +4180,14 @@ snapshots:
       '@img/sharp-win32-ia32': 0.34.5
       '@img/sharp-win32-x64': 0.34.5
 
-  shiki@3.15.0:
+  shiki@3.20.0:
     dependencies:
-      '@shikijs/core': 3.15.0
+      '@shikijs/core': 3.20.0
-      '@shikijs/engine-javascript': 3.15.0
+      '@shikijs/engine-javascript': 3.20.0
-      '@shikijs/engine-oniguruma': 3.15.0
+      '@shikijs/engine-oniguruma': 3.20.0
-      '@shikijs/langs': 3.15.0
+      '@shikijs/langs': 3.20.0
-      '@shikijs/themes': 3.15.0
+      '@shikijs/themes': 3.20.0
-      '@shikijs/types': 3.15.0
+      '@shikijs/types': 3.20.0
       '@shikijs/vscode-textmate': 10.0.2
       '@types/hast': 3.0.4
 
@@ -4392,7 +4388,7 @@ snapshots:
       '@types/unist': 3.0.3
       vfile-message: 4.0.3
 
-  vite@6.4.1(@types/node@24.10.1):
+  vite@6.4.1(@types/node@25.0.1):
     dependencies:
       esbuild: 0.25.12
       fdir: 6.5.0(picomatch@4.0.3)
@@ -4401,12 +4397,12 @@ snapshots:
       rollup: 4.53.3
       tinyglobby: 0.2.15
     optionalDependencies:
-      '@types/node': 24.10.1
+      '@types/node': 25.0.1
       fsevents: 2.3.3
 
-  vitefu@1.1.1(vite@6.4.1(@types/node@24.10.1)):
+  vitefu@1.1.1(vite@6.4.1(@types/node@25.0.1)):
     optionalDependencies:
-      vite: 6.4.1(@types/node@24.10.1)
+      vite: 6.4.1(@types/node@25.0.1)
 
   web-namespaces@2.0.1: {}
 

docs/src/components/DownloadButtons.astro

@@ -16,6 +16,62 @@ const hasLink = (link: string | undefined) => link && link.trim() !== "";
 ---
 
 <Tabs syncKey="platform">
+    <TabItem label="iOS" icon="apple">
+        <CardGrid>
+            {
+                hasLink(downloadLinks.ios.appStore) && (
+                    <Card title="App Store" icon="rocket">
+                        <p style="text-align: center;">
+                            <LinkButton
+                                href={downloadLinks.ios.appStore}
+                                variant="primary"
+                                icon="external"
+                            >
+                                Download on App Store
+                            </LinkButton>
+                        </p>
+                        {showQR && (
+                            <p style="text-align: center;">
+                                <QRCode
+                                    data={downloadLinks.ios.appStore}
+                                    size={200}
+                                    alt="QR code for App Store"
+                                />
+                            </p>
+                        )}
+                    </Card>
+                )
+            }
+
+            {
+                hasLink(downloadLinks.ios.testFlight) && (
+                    <Card title="TestFlight Beta" icon="warning">
+                        <p style="text-align: center;">
+                            <LinkButton
+                                href={downloadLinks.ios.testFlight}
+                                variant="secondary"
+                                icon="external"
+                            >
+                                Join TestFlight
+                            </LinkButton>
+                        </p>
+                        {showQR && (
+                            <p style="text-align: center;">
+                                <QRCode
+                                    data={downloadLinks.ios.testFlight}
+                                    size={200}
+                                    alt="QR code for TestFlight"
+                                />
+                            </p>
+                        )}
+                    </Card>
+                )
+            }
+        </CardGrid>
+
+        <p><strong>Requirements:</strong> {requirements.ios}</p>
+    </TabItem>
+
     <TabItem label="Android" icon="star">
         <CardGrid>
             {
@@ -96,60 +152,4 @@ const hasLink = (link: string | undefined) => link && link.trim() !== "";
 
         <p><strong>Requirements:</strong> {requirements.android}</p>
     </TabItem>
-
-    <TabItem label="iOS" icon="apple">
-        <CardGrid>
-            {
-                hasLink(downloadLinks.ios.appStore) && (
-                    <Card title="App Store" icon="rocket">
-                        <p style="text-align: center;">
-                            <LinkButton
-                                href={downloadLinks.ios.appStore}
-                                variant="primary"
-                                icon="external"
-                            >
-                                Download on App Store
-                            </LinkButton>
-                        </p>
-                        {showQR && (
-                            <p style="text-align: center;">
-                                <QRCode
-                                    data={downloadLinks.ios.appStore}
-                                    size={200}
-                                    alt="QR code for App Store"
-                                />
-                            </p>
-                        )}
-                    </Card>
-                )
-            }
-
-            {
-                hasLink(downloadLinks.ios.testFlight) && (
-                    <Card title="TestFlight Beta" icon="warning">
-                        <p style="text-align: center;">
-                            <LinkButton
-                                href={downloadLinks.ios.testFlight}
-                                variant="secondary"
-                                icon="external"
-                            >
-                                Join TestFlight
-                            </LinkButton>
-                        </p>
-                        {showQR && (
-                            <p style="text-align: center;">
-                                <QRCode
-                                    data={downloadLinks.ios.testFlight}
-                                    size={200}
-                                    alt="QR code for TestFlight"
-                                />
-                            </p>
-                        )}
-                    </Card>
-                )
-            }
-        </CardGrid>
-
-        <p><strong>Requirements:</strong> {requirements.ios}</p>
-    </TabItem>
 </Tabs>

docs/src/config.ts

@@ -5,7 +5,7 @@ export const requirements = {
 
 export const downloadLinks = {
   android: {
-    releases: "https://git.atri.dad/atridad/Ascently/releases",
+    releases: "https://git.atri.dad/atridad/Ascently/tags?q=Android",
     obtainium:
       "https://apps.obtainium.imranr.dev/redirect?r=obtainium://add/https://git.atri.dad/atridad/Ascently/releases",
     playStore: "",

docs/src/content/docs/index.mdx

@@ -42,6 +42,6 @@ Ascently is an **offline-first FOSS** app designed to help climbers track their
 
 ---
 
-*Built with ❤️ by Atridad Lahiji*
+*Built with ❤️ by [Atridad Lahiji](https://atri.dad)*
 
 *Contact: me@atri.dad*

ios/.editorconfig

@@ -0,0 +1,22 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.swift]
+indent_size = 4
+max_line_length = 140
+
+[*.{plist,storyboard,xib,xcscheme,xcworkspacedata}]
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
+
+[Makefile]
+indent_style = tab

ios/.swiftformat

@@ -0,0 +1,68 @@
+# SwiftFormat Configuration for Ascently iOS
+# Maintains consistent formatting across the project
+
+# File options
+--exclude build,Pods,DerivedData,.build
+
+# Format options
+--swiftversion 6.0
+--indent 4
+--tabwidth 4
+--maxwidth 140
+--wraparguments before-first
+--wrapparameters before-first
+--wrapcollections before-first
+--wrapconditions after-first
+--wrapreturntype preserve
+--wrapeffects preserve
+--closingparen balanced
+--funcattributes prev-line
+--typeattributes prev-line
+--varattributes preserve
+--storedvarattrs same-line
+--computedvarattrs preserve
+--complexattributes prev-line
+--typeblanklines preserve
+--structthreshold 20
+--enumthreshold 20
+--extensionacl on-declarations
+--organizetypes class,struct,enum,extension,protocol
+--modifierorder acl,setteracl,override,static,final,required,convenience,lazy,dynamic
+--self remove
+--importgrouping alpha
+--semicolons inline
+--operatorfunc spaced
+--nospaceoperators ..<,...
+--ranges no-space
+--emptybraces no-space
+--trimwhitespace always
+--stripunusedargs closure-only
+--header ignore
+--guardelse auto
+--elseposition same-line
+--shortoptionals always
+--linebreaks lf
+--xcodeindentation disabled
+--fragment false
+--conflictmarkers reject
+--ifdef no-indent
+--extensionlength 0
+
+# Enable rules
+--enable isEmpty,sortedSwitchCases,redundantInit,redundantGet,redundantObjc
+--enable blankLineAfterSwitchCase,consecutiveSpaces,duplicateImports
+--enable elseOnSameLine,emptyBraces,hoistAwait,hoistPatternLet,hoistTry
+--enable leadingDelimiters,redundantBackticks,redundantBreak,redundantClosure
+--enable redundantExtensionACL,redundantFileprivate,redundantLetError
+--enable redundantNilInit,redundantParens,redundantPattern,redundantRawValues
+--enable redundantReturn,redundantSelf,redundantType,redundantVoidReturnType
+--enable semicolons,sortImports,spaceAroundBraces,spaceAroundBrackets
+--enable spaceAroundComments,spaceAroundGenerics,spaceAroundOperators
+--enable spaceAroundParens,spaceInsideBraces,spaceInsideBrackets
+--enable spaceInsideComments,spaceInsideGenerics,spaceInsideParens
+--enable strongOutlets,strongifiedSelf,todos,trailingClosures,trailingCommas
+--enable typeSugar,unusedArguments,void,wrapArguments,wrapAttributes
+--enable yodaConditions,blankLinesBetweenScopes,blankLinesAtEndOfScope
+
+# Disable rules
+--disable wrapMultilineStatementBraces

ios/.swiftlint.yml

@@ -0,0 +1,139 @@
+excluded:
+  - build
+  - Pods
+  - DerivedData
+  - .build
+  - AscentlyTests
+
+disabled_rules:
+  - trailing_whitespace
+  - todo
+  - nesting
+  - opening_brace
+  - multiple_closures_with_trailing_closure
+  - trailing_comma
+  - attributes
+  - function_parameter_count
+  - large_tuple
+
+opt_in_rules:
+  - empty_count
+  - explicit_init
+  - closure_spacing
+  - overridden_super_call
+  - redundant_nil_coalescing
+  - first_where
+  - sorted_first_last
+  - contains_over_filter_count
+  - contains_over_filter_is_empty
+  - empty_string
+  - prefer_zero_over_explicit_init
+  - flatmap_over_map_reduce
+  - last_where
+  - sorted_imports
+  - toggle_bool
+  - unavailable_function
+  - unneeded_parentheses_in_closure_argument
+  - vertical_whitespace_closing_braces
+  - yoda_condition
+  - collection_alignment
+  - literal_expression_end_indentation
+
+line_length:
+  warning: 140
+  error: 250
+  ignores_comments: true
+  ignores_urls: true
+  ignores_function_declarations: true
+  ignores_interpolated_strings: true
+
+type_body_length:
+  warning: 600
+  error: 1000
+
+file_length:
+  warning: 1000
+  error: 1500
+  ignore_comment_only_lines: true
+
+function_body_length:
+  warning: 100
+  error: 200
+
+cyclomatic_complexity:
+  warning: 20
+  error: 30
+  ignores_case_statements: true
+
+identifier_name:
+  min_length:
+    warning: 2
+    error: 1
+  max_length:
+    warning: 50
+    error: 60
+  validates_start_with_lowercase: error
+  allowed_symbols:
+    - _
+  excluded:
+    - id
+    - i
+    - j
+    - x
+    - y
+    - z
+    - to
+    - at
+    - or
+    - is
+    - no
+    - go
+    - db
+    - DATA_JSON_FILENAME
+    - IMAGES_DIR_NAME
+    - METADATA_FILENAME
+    # ViewBuilder section functions (SwiftUI convention)
+    - StatusSection
+    - IconDisplaySection
+    - DebugSection
+    - TestingSection
+    - ResultsSection
+    - GymSelectionSection
+    - SessionDetailsSection
+    - ProblemSelectionSection
+    - CreateProblemSection
+    - AttemptDetailsSection
+    - BasicInfoSection
+    - ClimbTypesSection
+    - DifficultySystemsSection
+    - NotesSection
+    - ClimbTypeSection
+    - DifficultySection
+    - LocationSection
+    - TagsSection
+    - PhotosSection
+    - AdditionalInfoSection
+
+type_name:
+  min_length:
+    warning: 3
+    error: 2
+  max_length:
+    warning: 50
+    error: 60
+
+force_cast: warning
+
+force_try: warning
+
+large_tuple:
+  warning: 4
+  error: 6
+
+nesting:
+  type_level:
+    warning: 3
+  function_level:
+    warning: 5
+
+reporter: "xcode"

ios/Ascently.xcodeproj/project.pbxproj

@@ -465,7 +465,7 @@
 				CODE_SIGN_ENTITLEMENTS = Ascently/Ascently.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 32;
+				CURRENT_PROJECT_VERSION = 40;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				DRIVERKIT_DEPLOYMENT_TARGET = 24.6;
 				ENABLE_PREVIEWS = YES;
@@ -487,7 +487,7 @@
 					"@executable_path/Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 15.6;
-				MARKETING_VERSION = 2.3.0;
+				MARKETING_VERSION = 2.6.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.atridad.Ascently;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
@@ -513,7 +513,7 @@
 				CODE_SIGN_ENTITLEMENTS = Ascently/Ascently.entitlements;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 32;
+				CURRENT_PROJECT_VERSION = 40;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				DRIVERKIT_DEPLOYMENT_TARGET = 24.6;
 				ENABLE_PREVIEWS = YES;
@@ -535,7 +535,7 @@
 					"@executable_path/Frameworks",
 				);
 				MACOSX_DEPLOYMENT_TARGET = 15.6;
-				MARKETING_VERSION = 2.3.0;
+				MARKETING_VERSION = 2.6.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.atridad.Ascently;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
@@ -602,7 +602,7 @@
 				ASSETCATALOG_COMPILER_WIDGET_BACKGROUND_COLOR_NAME = WidgetBackground;
 				CODE_SIGN_ENTITLEMENTS = SessionStatusLiveExtension.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 32;
+				CURRENT_PROJECT_VERSION = 40;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = SessionStatusLive/Info.plist;
@@ -613,7 +613,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 2.3.0;
+				MARKETING_VERSION = 2.6.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.atridad.Ascently.SessionStatusLive;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
@@ -632,7 +632,7 @@
 				ASSETCATALOG_COMPILER_WIDGET_BACKGROUND_COLOR_NAME = WidgetBackground;
 				CODE_SIGN_ENTITLEMENTS = SessionStatusLiveExtension.entitlements;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 32;
+				CURRENT_PROJECT_VERSION = 40;
 				DEVELOPMENT_TEAM = 4BC9Y2LL4B;
 				GENERATE_INFOPLIST_FILE = YES;
 				INFOPLIST_FILE = SessionStatusLive/Info.plist;
@@ -643,7 +643,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 2.3.0;
+				MARKETING_VERSION = 2.6.0;
 				PRODUCT_BUNDLE_IDENTIFIER = com.atridad.Ascently.SessionStatusLive;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;

ios/Ascently/AppIntents/AscentlyShortcuts.swift

@@ -1,7 +1,6 @@
 import AppIntents
 
-/// Provides a curated list of the most useful Ascently shortcuts for Siri and the Shortcuts app.
+/// Defines the App Shortcuts available in the Shortcuts app.
-/// Surfaces intents that users can trigger hands-free to manage their climbing sessions.
 struct AscentlyShortcuts: AppShortcutsProvider {
 
     static var shortcutTileColor: ShortcutTileColor {
@@ -11,23 +10,15 @@ struct AscentlyShortcuts: AppShortcutsProvider {
     static var appShortcuts: [AppShortcut] {
         return [
             AppShortcut(
-                intent: StartLastGymSessionIntent(),
+                intent: ToggleSessionIntent(),
                 phrases: [
-                    "Start my climb in \(.applicationName)",
+                    "Toggle climb in \(.applicationName)",
-                    "Begin my last gym session in \(.applicationName)",
+                    "Start or stop climb in \(.applicationName)",
+                    "Climb toggle in \(.applicationName)",
                 ],
-                shortTitle: "Start Climb",
+                shortTitle: "Toggle Session",
                 systemImageName: "figure.climbing"
-            ),
+            )
-            AppShortcut(
-                intent: EndActiveSessionIntent(),
-                phrases: [
-                    "Finish my climb in \(.applicationName)",
-                    "End my session in \(.applicationName)",
-                ],
-                shortTitle: "End Climb",
-                systemImageName: "flag.checkered"
-            ),
         ]
     }
 }

ios/Ascently/AppIntents/EndActiveSessionIntent.swift

@@ -1,40 +0,0 @@
-import AppIntents
-import Foundation
-
-/// Ends the currently active climbing session so logging stays in sync across devices.
-/// Exposed to Shortcuts so users can wrap up a session without opening the app.
-struct EndActiveSessionIntent: AppIntent {
-
-    static var title: LocalizedStringResource {
-        "End Active Session"
-    }
-
-    static var description: IntentDescription {
-        IntentDescription(
-            "Stop the active climbing session and save its progress in Ascently."
-        )
-    }
-
-    static var openAppWhenRun: Bool {
-        false
-    }
-
-    func perform() async throws -> some IntentResult & ProvidesDialog {
-        do {
-            let summary = try await SessionIntentController().endActiveSession()
-            let dialog = IntentDialog("Session at \(summary.gymName) ended. Nice work!")
-            return .result(dialog: dialog)
-        } catch SessionIntentError.noActiveSession {
-            // No active session is fine - just return a friendly message
-            let dialog = IntentDialog("No active session to end.")
-            return .result(dialog: dialog)
-        } catch {
-            // Re-throw other errors
-            throw error
-        }
-    }
-
-    static var parameterSummary: some ParameterSummary {
-        Summary("End my current climbing session")
-    }
-}

ios/Ascently/AppIntents/SessionIntentSupport.swift

@@ -27,7 +27,7 @@ struct SessionIntentSummary: Sendable {
     let status: SessionStatus
 }
 
-/// Central controller that exposes the minimal climbing session operations used by App Intents and shortcuts.
+/// Controller for handling session operations from App Intents.
 @MainActor
 final class SessionIntentController {
 
@@ -39,9 +39,9 @@ final class SessionIntentController {
 
     /// Starts a new session using the most recently visited gym.
     func startSessionWithLastUsedGym() async throws -> SessionIntentSummary {
-        // Give a moment for data to be ready if app just launched
+        // Wait for data to load
         if dataManager.gyms.isEmpty {
-            try? await Task.sleep(nanoseconds: 500_000_000)  // 0.5 seconds
+            try? await Task.sleep(nanoseconds: 500_000_000)
         }
 
         guard let lastGym = dataManager.getLastUsedGym() else {
@@ -89,7 +89,23 @@ final class SessionIntentController {
     }
 
     private func logFailure(_ error: SessionIntentError, context: String) {
-        // Logging from intent context - errors are visible to user via dialog
+        // Log error for debugging
         print("SessionIntentError: \(error). Context: \(context)")
     }
+
+    /// Toggles the session state: ends active session if one exists, otherwise starts a new one.
+    func toggleSession() async throws -> (summary: SessionIntentSummary, wasStarted: Bool) {
+        // Wait for data to load
+        if dataManager.gyms.isEmpty {
+            try? await Task.sleep(nanoseconds: 500_000_000)
+        }
+
+        if dataManager.activeSession != nil {
+            let summary = try await endActiveSession()
+            return (summary, false)
+        } else {
+            let summary = try await startSessionWithLastUsedGym()
+            return (summary, true)
+        }
+    }
 }

ios/Ascently/AppIntents/StartLastGymSessionIntent.swift

@@ -1,43 +0,0 @@
-import AppIntents
-import Foundation
-
-/// Starts a climbing session at the most recently visited gym.
-/// Exposed to Shortcuts so users can begin logging without opening the app.
-struct StartLastGymSessionIntent: AppIntent {
-
-    static var title: LocalizedStringResource {
-        "Start Last Gym Session"
-    }
-
-    static var description: IntentDescription {
-        IntentDescription(
-            "Begin a new climbing session using the most recent gym you visited in Ascently."
-        )
-    }
-
-    static var openAppWhenRun: Bool {
-        true
-    }
-
-    func perform() async throws -> some IntentResult & ProvidesDialog {
-        // Delay to ensure app has time to fully initialize if just launched
-        try? await Task.sleep(nanoseconds: 1_000_000_000)  // 1 second
-
-        let summary = try await SessionIntentController().startSessionWithLastUsedGym()
-
-        // Give Live Activity extra time to start
-        try? await Task.sleep(nanoseconds: 500_000_000)  // 0.5 seconds
-
-        return .result(
-            dialog: Self.successDialog(for: summary.gymName)
-        )
-    }
-
-    private static func successDialog(for gymName: String) -> IntentDialog {
-        IntentDialog("Session started at \(gymName). Have an awesome climb!")
-    }
-
-    static var parameterSummary: some ParameterSummary {
-        Summary("Start a session at my last gym")
-    }
-}

ios/Ascently/AppIntents/ToggleSessionIntent.swift

@@ -0,0 +1,40 @@
+import AppIntents
+import Foundation
+
+/// Toggles the climbing session state: starts a session if none is active, or ends the current one.
+struct ToggleSessionIntent: AppIntent {
+
+    static var title: LocalizedStringResource {
+        "Toggle Climbing Session"
+    }
+
+    static var description: IntentDescription {
+        IntentDescription(
+            "Starts a new session at your last gym if you're not climbing, or ends your current session if you are."
+        )
+    }
+
+    static var openAppWhenRun: Bool {
+        false
+    }
+
+    func perform() async throws -> some IntentResult & ProvidesDialog {
+        // Wait for app initialization
+        try? await Task.sleep(nanoseconds: 1_000_000_000)
+
+        let controller = await SessionIntentController()
+        let (summary, wasStarted) = try await controller.toggleSession()
+
+        if wasStarted {
+            // Wait for Live Activity
+            try? await Task.sleep(nanoseconds: 500_000_000)
+            return .result(dialog: IntentDialog("Session started at \(summary.gymName). Have an awesome climb!"))
+        } else {
+            return .result(dialog: IntentDialog("Session at \(summary.gymName) ended. Nice work!"))
+        }
+    }
+
+    static var parameterSummary: some ParameterSummary {
+        Summary("Toggle my climbing session")
+    }
+}

ios/Ascently/AscentlyApp.swift

@@ -13,10 +13,13 @@ class AppDelegate: NSObject, UIApplicationDelegate {
 struct AscentlyApp: App {
     @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
     @Environment(\.scenePhase) private var scenePhase
+    @StateObject private var themeManager = ThemeManager()
 
     var body: some Scene {
         WindowGroup {
             ContentView()
+                .environmentObject(themeManager)
+                .tint(themeManager.accentColor)
         }
     }
 }

ios/Ascently/Components/CameraImagePicker.swift

@@ -1,52 +1,104 @@
 import SwiftUI
 import UIKit
 
+/// A native iOS camera picker presented from a hosting controller so it can
+/// respect all supported interface orientations. Present with `.fullScreenCover()`.
 struct CameraImagePicker: UIViewControllerRepresentable {
-    @Binding var isPresented: Bool
+    @Environment(\.dismiss) private var dismiss
     let onImageCaptured: (UIImage) -> Void
 
-    func makeUIViewController(context: Context) -> UIImagePickerController {
+    func makeUIViewController(context: Context) -> CameraHostViewController {
-        let picker = UIImagePickerController()
+        let host = CameraHostViewController()
-        picker.delegate = context.coordinator
+        host.onImageCaptured = { image in
-        picker.sourceType = .camera
+            onImageCaptured(image)
-        picker.cameraCaptureMode = .photo
+            dismiss()
-        picker.cameraDevice = .rear
+        }
-        picker.allowsEditing = false
+        host.onCancel = {
-        return picker
+            dismiss()
+        }
+        host.pickerDelegate = context.coordinator
+        context.coordinator.onImageCaptured = { image in
+            onImageCaptured(image)
+            dismiss()
+        }
+        context.coordinator.onCancel = {
+            dismiss()
+        }
+        return host
     }
 
-    func updateUIViewController(_ uiViewController: UIImagePickerController, context: Context) {
+    func updateUIViewController(_ uiViewController: CameraHostViewController, context: Context) {
-        // Nothing here actually... Q_Q
+        // No dynamic updates needed
     }
 
     func makeCoordinator() -> Coordinator {
-        Coordinator(self)
+        Coordinator()
     }
 
     class Coordinator: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
-        let parent: CameraImagePicker
+        var onImageCaptured: ((UIImage) -> Void)?
-
+        var onCancel: (() -> Void)?
-        init(_ parent: CameraImagePicker) {
-            self.parent = parent
-        }
 
         func imagePickerController(
             _ picker: UIImagePickerController,
             didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]
         ) {
-            if let image = info[.originalImage] as? UIImage {
+            picker.dismiss(animated: true) {
-                parent.onImageCaptured(image)
+                if let image = info[.originalImage] as? UIImage {
+                    self.onImageCaptured?(image)
+                } else {
+                    self.onCancel?()
+                }
             }
-            parent.isPresented = false
         }
 
         func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
-            parent.isPresented = false
+            picker.dismiss(animated: true) {
+                self.onCancel?()
+            }
         }
     }
 }
 
-// Extension to check camera availability
+// MARK: - Hosting VC to own presentation/orientation
+final class CameraHostViewController: UIViewController {
+    var onImageCaptured: ((UIImage) -> Void)?
+    var onCancel: (() -> Void)?
+    weak var pickerDelegate: (UIImagePickerControllerDelegate & UINavigationControllerDelegate)?
+
+    private var didPresent = false
+
+    override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        presentIfNeeded()
+    }
+
+    private func presentIfNeeded() {
+        guard !didPresent, UIImagePickerController.isSourceTypeAvailable(.camera) else { return }
+        didPresent = true
+
+        let picker = UIImagePickerController()
+        picker.delegate = pickerDelegate
+        picker.sourceType = .camera
+        picker.cameraCaptureMode = .photo
+        picker.cameraDevice = .rear
+        picker.allowsEditing = false
+        picker.modalPresentationStyle = .fullScreen
+
+        present(picker, animated: true)
+    }
+
+    override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
+        // Defer to app-supported orientations; returning .all allows rotation when permitted by the app
+        return .all
+    }
+
+    override var shouldAutorotate: Bool {
+        true
+    }
+}
+
+// MARK: - Camera Availability Check
 extension CameraImagePicker {
     static var isCameraAvailable: Bool {
         UIImagePickerController.isSourceTypeAvailable(.camera)

ios/Ascently/Components/PhotoOptionSheet.swift

@@ -8,6 +8,7 @@ struct PhotoOptionSheet: View {
     let onCameraSelected: () -> Void
     let onPhotoLibrarySelected: () -> Void
     let onDismiss: () -> Void
+    @EnvironmentObject var themeManager: ThemeManager
 
     var body: some View {
         NavigationView {
@@ -29,7 +30,7 @@ struct PhotoOptionSheet: View {
                         HStack {
                             Image(systemName: "photo.on.rectangle")
                                 .font(.title2)
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                             Text("Photo Library")
                                 .font(.headline)
                             Spacer()
@@ -52,7 +53,7 @@ struct PhotoOptionSheet: View {
                         HStack {
                             Image(systemName: "camera.fill")
                                 .font(.title2)
-                                .foregroundColor(.blue)
+                                .foregroundColor(themeManager.accentColor)
                             Text("Camera")
                                 .font(.headline)
                             Spacer()

ios/Ascently/ContentView.swift

@@ -44,7 +44,8 @@ struct ContentView: View {
                 .tag(4)
         }
         .environmentObject(dataManager)
-        .onChange(of: scenePhase) { oldPhase, newPhase in
+        .environmentObject(MusicService.shared)
+        .onChange(of: scenePhase) { _, newPhase in
             if newPhase == .active {
                 // Add slight delay to ensure app is fully loaded
                 Task {

ios/Ascently/Info.plist

@@ -15,5 +15,7 @@
 	<string>This app needs access to save your climbing workouts to Apple Health.</string>
 	<key>NSHealthUpdateUsageDescription</key>
 	<string>This app needs access to save your climbing workouts to Apple Health.</string>
+	<key>NSAppleMusicUsageDescription</key>
+	<string>This app (optionally) needs access to your music library to play your selected playlist during climbing sessions.</string>
 </dict>
 </plist>

ios/Ascently/Services/MusicService.swift

@@ -0,0 +1,197 @@
+import AVFoundation
+import Combine
+import MusicKit
+import SwiftUI
+
+@MainActor
+class MusicService: ObservableObject {
+    static let shared = MusicService()
+    
+    @Published var isAuthorized = false
+    @Published var playlists: MusicItemCollection<Playlist> = []
+    @Published var selectedPlaylistId: String? {
+        didSet {
+            UserDefaults.standard.set(selectedPlaylistId, forKey: "ascently_selected_playlist_id")
+        }
+    }
+    @Published var isMusicEnabled: Bool {
+        didSet {
+            UserDefaults.standard.set(isMusicEnabled, forKey: "ascently_music_enabled")
+            if !isMusicEnabled {
+                // Genuinely unsure what I want to do with this but we should account for it at some point
+            }
+        }
+    }
+    @Published var isAutoPlayEnabled: Bool {
+        didSet {
+            UserDefaults.standard.set(isAutoPlayEnabled, forKey: "ascently_music_autoplay_enabled")
+        }
+    }
+    @Published var isAutoStopEnabled: Bool {
+        didSet {
+            UserDefaults.standard.set(isAutoStopEnabled, forKey: "ascently_music_autostop_enabled")
+        }
+    }
+    @Published var isPlaying = false
+    
+    private var cancellables = Set<AnyCancellable>()
+    private var hasStartedSessionPlayback = false
+    private var currentPlaylistTrackIds: Set<MusicItemID> = []
+    
+    private init() {
+        self.selectedPlaylistId = UserDefaults.standard.string(forKey: "ascently_selected_playlist_id")
+        self.isMusicEnabled = UserDefaults.standard.bool(forKey: "ascently_music_enabled")
+        self.isAutoPlayEnabled = UserDefaults.standard.bool(forKey: "ascently_music_autoplay_enabled")
+        self.isAutoStopEnabled = UserDefaults.standard.bool(forKey: "ascently_music_autostop_enabled")
+        
+        if isMusicEnabled {
+            Task {
+                await checkAuthorizationStatus()
+            }
+        }
+        
+        setupObservers()
+    }
+    
+    private func setupObservers() {
+        SystemMusicPlayer.shared.state.objectWillChange
+            .sink { [weak self] _ in
+                self?.updatePlaybackStatus()
+            }
+            .store(in: &cancellables)
+            
+        SystemMusicPlayer.shared.queue.objectWillChange
+            .sink { [weak self] _ in
+                self?.checkQueueConsistency()
+            }
+            .store(in: &cancellables)
+    }
+    
+    private func updatePlaybackStatus() {
+        Task { @MainActor [weak self] in
+            self?.isPlaying = SystemMusicPlayer.shared.state.playbackStatus == .playing
+        }
+    }
+    
+    private func checkQueueConsistency() {
+        guard hasStartedSessionPlayback else { return }
+        
+        Task { @MainActor [weak self] in
+            guard let self = self else { return }
+            if let currentEntry = SystemMusicPlayer.shared.queue.currentEntry,
+               let item = currentEntry.item {
+                if !self.currentPlaylistTrackIds.isEmpty && !self.currentPlaylistTrackIds.contains(item.id) {
+                    self.hasStartedSessionPlayback = false
+                }
+            }
+        }
+    }
+    
+    func toggleMusicEnabled(_ enabled: Bool) {
+        isMusicEnabled = enabled
+        if enabled {
+            Task {
+                await checkAuthorizationStatus()
+            }
+        }
+    }
+    
+    func checkAuthorizationStatus() async {
+        let status = await MusicAuthorization.request()
+        self.isAuthorized = status == .authorized
+        if isAuthorized {
+            await fetchPlaylists()
+        }
+    }
+    
+    func fetchPlaylists() async {
+        guard isAuthorized else { return }
+        do {
+            var request = MusicLibraryRequest<Playlist>()
+            request.sort(by: \.name, ascending: true)
+            let response = try await request.response()
+            self.playlists = response.items
+        } catch {
+            print("Error fetching playlists: \(error)")
+        }
+    }
+    
+    func playSelectedPlaylistIfHeadphonesConnected() {
+        guard isMusicEnabled, isAutoPlayEnabled, let playlistId = selectedPlaylistId else { return }
+        
+        if isHeadphonesConnected() {
+            playPlaylist(id: playlistId)
+        }
+    }
+    
+    func resetSessionPlaybackState() {
+        hasStartedSessionPlayback = false
+        currentPlaylistTrackIds.removeAll()
+    }
+    
+    func playPlaylist(id: String) {
+        print("Attempting to play playlist \(id)")
+        Task {
+            do {
+                if playlists.isEmpty {
+                    await fetchPlaylists()
+                }
+                
+                var targetPlaylist: Playlist?
+                
+                if let playlist = playlists.first(where: { $0.id.rawValue == id }) {
+                    targetPlaylist = playlist
+                } else {
+                    var request = MusicLibraryRequest<Playlist>()
+                    request.filter(matching: \.id, equalTo: MusicItemID(id))
+                    let response = try await request.response()
+                    targetPlaylist = response.items.first
+                }
+                
+                if let playlist = targetPlaylist {
+                    let detailedPlaylist = try await playlist.with([.tracks])
+                    if let tracks = detailedPlaylist.tracks {
+                        self.currentPlaylistTrackIds = Set(tracks.map { $0.id })
+                    }
+                    
+                    SystemMusicPlayer.shared.queue = [playlist]
+                    try await SystemMusicPlayer.shared.play()
+                    hasStartedSessionPlayback = true
+                }
+            } catch {
+                print("Error playing playlist: \(error)")
+            }
+        }
+    }
+    
+    func stopPlaybackIfEnabled() {
+        guard isMusicEnabled, isAutoStopEnabled else { return }
+        SystemMusicPlayer.shared.stop()
+    }
+    
+    func togglePlayback() {
+        Task {
+            if isPlaying {
+                SystemMusicPlayer.shared.pause()
+            } else {
+                if let playlistId = selectedPlaylistId, !hasStartedSessionPlayback {
+                    playPlaylist(id: playlistId)
+                } else {
+                    try? await SystemMusicPlayer.shared.play()
+                }
+            }
+        }
+    }
+    
+    private func isHeadphonesConnected() -> Bool {
+        let route = AVAudioSession.sharedInstance().currentRoute
+        return route.outputs.contains { port in
+            port.portType == .headphones ||
+            port.portType == .bluetoothA2DP ||
+            port.portType == .bluetoothLE ||
+            port.portType == .bluetoothHFP ||
+            port.portType == .usbAudio ||
+            port.portType == .airPlay
+        }
+    }
+}

ios/Ascently/Services/Sync/SyncMerger.swift

@@ -0,0 +1,179 @@
+import Foundation
+
+struct SyncMerger {
+    private static let logTag = "SyncMerger"
+    
+    static func mergeDataSafely(
+        localBackup: ClimbDataBackup,
+        serverBackup: ClimbDataBackup,
+        dataManager: ClimbingDataManager,
+        imagePathMapping: [String: String]
+    ) throws -> (gyms: [Gym], problems: [Problem], sessions: [ClimbSession], attempts: [Attempt], uniqueDeletions: [DeletedItem]) {
+        
+        // Merge deletion lists first to prevent resurrection of deleted items
+        let localDeletions = dataManager.getDeletedItems()
+        let allDeletions = localDeletions + serverBackup.deletedItems
+        let uniqueDeletions = Array(Set(allDeletions))
+        
+        AppLogger.info("Merging gyms...", tag: logTag)
+        let mergedGyms = mergeGyms(
+            local: dataManager.gyms,
+            server: serverBackup.gyms,
+            deletedItems: uniqueDeletions)
+        
+        AppLogger.info("Merging problems...", tag: logTag)
+        let mergedProblems = try mergeProblems(
+            local: dataManager.problems,
+            server: serverBackup.problems,
+            imagePathMapping: imagePathMapping,
+            deletedItems: uniqueDeletions)
+        
+        AppLogger.info("Merging sessions...", tag: logTag)
+        let mergedSessions = try mergeSessions(
+            local: dataManager.sessions,
+            server: serverBackup.sessions,
+            deletedItems: uniqueDeletions)
+        
+        AppLogger.info("Merging attempts...", tag: logTag)
+        let mergedAttempts = try mergeAttempts(
+            local: dataManager.attempts,
+            server: serverBackup.attempts,
+            deletedItems: uniqueDeletions)
+            
+        return (mergedGyms, mergedProblems, mergedSessions, mergedAttempts, uniqueDeletions)
+    }
+    
+    private static func mergeGyms(local: [Gym], server: [BackupGym], deletedItems: [DeletedItem]) -> [Gym] {
+        var merged = local
+        let deletedGymIds = Set(deletedItems.filter { $0.type == "gym" }.map { $0.id })
+        let localGymIds = Set(local.map { $0.id.uuidString })
+        
+        merged.removeAll { deletedGymIds.contains($0.id.uuidString) }
+        
+        // Add new items from server (excluding deleted ones)
+        for serverGym in server {
+            if let serverGymConverted = try? serverGym.toGym() {
+                let localHasGym = localGymIds.contains(serverGym.id)
+                let isDeleted = deletedGymIds.contains(serverGym.id)
+                
+                if !localHasGym && !isDeleted {
+                    merged.append(serverGymConverted)
+                }
+            }
+        }
+        
+        return merged
+    }
+    
+    private static func mergeProblems(
+        local: [Problem],
+        server: [BackupProblem],
+        imagePathMapping: [String: String],
+        deletedItems: [DeletedItem]
+    ) throws -> [Problem] {
+        var merged = local
+        let deletedProblemIds = Set(deletedItems.filter { $0.type == "problem" }.map { $0.id })
+        let localProblemIds = Set(local.map { $0.id.uuidString })
+        
+        merged.removeAll { deletedProblemIds.contains($0.id.uuidString) }
+        
+        for serverProblem in server {
+            let localHasProblem = localProblemIds.contains(serverProblem.id)
+            let isDeleted = deletedProblemIds.contains(serverProblem.id)
+            
+            if !localHasProblem && !isDeleted {
+                var problemToAdd = serverProblem
+                
+                if !imagePathMapping.isEmpty, let imagePaths = serverProblem.imagePaths, !imagePaths.isEmpty {
+                    let updatedImagePaths = imagePaths.compactMap { oldPath in
+                        imagePathMapping[oldPath] ?? oldPath
+                    }
+                    if updatedImagePaths != imagePaths {
+                        problemToAdd = BackupProblem(
+                            id: serverProblem.id,
+                            gymId: serverProblem.gymId,
+                            name: serverProblem.name,
+                            description: serverProblem.description,
+                            climbType: serverProblem.climbType,
+                            difficulty: serverProblem.difficulty,
+                            tags: serverProblem.tags,
+                            location: serverProblem.location,
+                            imagePaths: updatedImagePaths,
+                            isActive: serverProblem.isActive,
+                            dateSet: serverProblem.dateSet,
+                            notes: serverProblem.notes,
+                            createdAt: serverProblem.createdAt,
+                            updatedAt: serverProblem.updatedAt
+                        )
+                    }
+                }
+                
+                if let serverProblemConverted = try? problemToAdd.toProblem() {
+                    merged.append(serverProblemConverted)
+                }
+            }
+        }
+        
+        return merged
+    }
+    
+    private static func mergeSessions(
+        local: [ClimbSession], server: [BackupClimbSession], deletedItems: [DeletedItem]
+    ) throws -> [ClimbSession] {
+        var merged = local
+        let deletedSessionIds = Set(deletedItems.filter { $0.type == "session" }.map { $0.id })
+        let localSessionIds = Set(local.map { $0.id.uuidString })
+        
+        merged.removeAll { session in
+            deletedSessionIds.contains(session.id.uuidString) && session.status != .active
+        }
+        
+        for serverSession in server {
+            let localHasSession = localSessionIds.contains(serverSession.id)
+            let isDeleted = deletedSessionIds.contains(serverSession.id)
+            
+            if !localHasSession && !isDeleted {
+                if let serverSessionConverted = try? serverSession.toClimbSession() {
+                    merged.append(serverSessionConverted)
+                }
+            }
+        }
+        
+        return merged
+    }
+    
+    private static func mergeAttempts(
+        local: [Attempt], server: [BackupAttempt], deletedItems: [DeletedItem]
+    ) throws -> [Attempt] {
+        var merged = local
+        let deletedAttemptIds = Set(deletedItems.filter { $0.type == "attempt" }.map { $0.id })
+        let localAttemptIds = Set(local.map { $0.id.uuidString })
+        
+        // Get active session IDs to protect their attempts
+        let activeSessionIds = Set(
+            local.compactMap { attempt in
+                return attempt.sessionId
+            }.filter { _ in
+                return true
+            })
+        
+        // Remove items that were deleted on other devices (but be conservative with attempts)
+        merged.removeAll { attempt in
+            deletedAttemptIds.contains(attempt.id.uuidString)
+                && !activeSessionIds.contains(attempt.sessionId)
+        }
+        
+        for serverAttempt in server {
+            let localHasAttempt = localAttemptIds.contains(serverAttempt.id)
+            let isDeleted = deletedAttemptIds.contains(serverAttempt.id)
+            
+            if !localHasAttempt && !isDeleted {
+                if let serverAttemptConverted = try? serverAttempt.toAttempt() {
+                    merged.append(serverAttemptConverted)
+                }
+            }
+        }
+        
+        return merged
+    }
+}

ios/Ascently/Services/Sync/SyncProvider.swift

@@ -0,0 +1,73 @@
+import Foundation
+
+enum SyncProviderType: String, CaseIterable, Identifiable {
+    case none
+    case server
+    case iCloud
+    
+    var id: String { rawValue }
+    var displayName: String {
+        switch self {
+        case .none: return "None"
+        case .server: return "Self-Hosted Server"
+        case .iCloud: return "iCloud"
+        }
+    }
+}
+
+protocol SyncProvider {
+    var type: SyncProviderType { get }
+    var isConfigured: Bool { get }
+    var isConnected: Bool { get }
+    
+    func sync(dataManager: ClimbingDataManager) async throws
+    func testConnection() async throws
+    func disconnect()
+}
+
+enum SyncError: LocalizedError {
+    case notConfigured
+    case notConnected
+    case invalidURL
+    case invalidResponse
+    case unauthorized
+    case badRequest
+    case serverError(Int)
+    case decodingError(Error)
+    case exportFailed
+    case importFailed(Error)
+    case imageNotFound
+    case imageUploadFailed
+    case providerError(String)
+
+    var errorDescription: String? {
+        switch self {
+        case .notConfigured:
+            return "Sync server not configured. Please set server URL and auth token."
+        case .notConnected:
+            return "Not connected to sync server. Please test connection first."
+        case .invalidURL:
+            return "Invalid server URL."
+        case .invalidResponse:
+            return "Invalid response from server."
+        case .unauthorized:
+            return "Authentication failed. Check your auth token."
+        case .badRequest:
+            return "Bad request. Check your data format."
+        case .serverError(let code):
+            return "Server error (code \(code))."
+        case .decodingError(let error):
+            return "Failed to decode response: \(error.localizedDescription)"
+        case .exportFailed:
+            return "Failed to export local data."
+        case .importFailed(let error):
+            return "Failed to import data: \(error.localizedDescription)"
+        case .imageNotFound:
+            return "Image not found on server."
+        case .imageUploadFailed:
+            return "Failed to upload image to server."
+        case .providerError(let message):
+            return "Sync provider error: \(message)"
+        }
+    }
+}

ios/Ascently/Utils/ImageManager.swift

@@ -238,7 +238,6 @@ class ImageManager {
 
             saveMigrationState(initialState)
             performMigrationWithCheckpoints(files: allLegacyFiles, currentState: initialState)
-
         } catch {
             logError("ERROR: Failed to start migration: \(error)")
         }
@@ -255,7 +254,6 @@ class ImageManager {
 
             logInfo("Resuming with \(remainingFiles.count) remaining files")
             performMigrationWithCheckpoints(files: remainingFiles, currentState: state)
-
         } catch {
             logError("ERROR: Failed to resume migration: \(error)")
             // Fallback: start fresh
@@ -325,7 +323,6 @@ class ImageManager {
                     migratedCount += 1
 
                     logInfo("Migrated: \(fileName) (\(migratedCount)/\(currentState.totalFiles))")
-
                 } catch {
                     failedCount += 1
                     logError("ERROR: Failed to migrate \(fileName): \(error)")
@@ -676,7 +673,7 @@ class ImageManager {
 
             for fileName in files {
                 let filePath = imagesDirectory.appendingPathComponent(fileName)
-                if let data = try? Data(contentsOf: filePath), data.count > 0 {
+                if let data = try? Data(contentsOf: filePath), !data.isEmpty {
                     // Basic validation - check if file has content and is reasonable size
                     if data.count > 100 {  // Minimum viable image size
                         validFiles += 1
@@ -825,7 +822,7 @@ class ImageManager {
         let primaryEmpty =
             (try? fileManager.contentsOfDirectory(atPath: imagesDirectory.path).isEmpty) ?? true
         let backupHasFiles =
-            ((try? fileManager.contentsOfDirectory(atPath: backupDirectory.path)) ?? []).count > 0
+            !((try? fileManager.contentsOfDirectory(atPath: backupDirectory.path)) ?? []).isEmpty
 
         if primaryEmpty && backupHasFiles {
             logDebug("DEBUG SAFE: Primary empty but backup exists - restoring")
@@ -944,7 +941,6 @@ class ImageManager {
             }
 
             logInfo("Completed migration from previous Application Support directory")
-
         } catch {
             logError("ERROR: Failed to migrate from previous Application Support: \(error)")
         }

ios/Ascently/Utils/ThemeManager.swift

@@ -0,0 +1,77 @@
+import Combine
+import SwiftUI
+
+class ThemeManager: ObservableObject {
+    @Published var accentColor: Color = .blue {
+        didSet {
+            saveColor()
+        }
+    }
+    
+    private let userDefaultsKey = "accentColorData"
+    
+    init() {
+        loadColor()
+    }
+    
+    private func loadColor() {
+        guard let data = UserDefaults.standard.data(forKey: userDefaultsKey) else {
+            self.accentColor = .blue
+            return
+        }
+        
+        do {
+            if let uiColor = try NSKeyedUnarchiver.unarchivedObject(ofClass: UIColor.self, from: data) {
+                self.accentColor = Color(uiColor)
+            }
+        } catch {
+            print("Failed to load accent color: \(error)")
+            self.accentColor = .blue
+        }
+    }
+    
+    private func saveColor() {
+        do {
+            let uiColor = UIColor(accentColor)
+            let data = try NSKeyedArchiver.archivedData(withRootObject: uiColor, requiringSecureCoding: false)
+            UserDefaults.standard.set(data, forKey: userDefaultsKey)
+        } catch {
+            print("Failed to save accent color: \(error)")
+        }
+    }
+    
+    func resetToDefault() {
+        accentColor = .blue
+    }
+    
+    // Curated list of preset colors that maintain good contrast
+    static let presetColors: [Color] = [
+        .blue,      // Default Blue
+        .purple,    // Purple
+        .pink,      // Pink
+        .red,       // Red
+        .orange,    // Orange
+        .green,     // Green
+        .teal,      // Teal
+        .indigo,    // Indigo
+        .mint,      // Mint
+        Color(uiColor: .systemBrown), // Brown
+        Color(uiColor: .systemCyan)   // Cyan
+    ]
+    
+    var contrastingTextColor: Color {
+        let uiColor = UIColor(accentColor)
+        var red: CGFloat = 0
+        var green: CGFloat = 0
+        var blue: CGFloat = 0
+        var alpha: CGFloat = 0
+        
+        uiColor.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
+        
+        // Calculate relative luminance
+        let luminance = 0.299 * red + 0.587 * green + 0.114 * blue
+        
+        // Return black for light colors, white for dark colors
+        return luminance > 0.5 ? .black : .white
+    }
+}

ios/Ascently/Utils/ZipUtils.swift

@@ -73,7 +73,7 @@ struct ZipUtils {
 
             do {
                 let imageData = try Data(contentsOf: imageURL)
-                if imageData.count > 0 {
+                if !imageData.isEmpty {
                     let imageEntryName = "\(IMAGES_DIR_NAME)/\(imageName)"
                     try addFileToZip(
                         filename: imageEntryName,

ios/Ascently/ViewModels/ClimbingDataManager.swift

@@ -38,6 +38,7 @@ class ClimbingDataManager: ObservableObject {
 
     let syncService = SyncService()
     let healthKitService = HealthKitService.shared
+    let musicService = MusicService.shared
 
     @Published var isSyncing = false
     private enum Keys {
@@ -437,13 +438,15 @@ class ClimbingDataManager: ObservableObject {
         saveSessions()
         DataStateManager.shared.updateDataState()
 
-        // MARK: - Start Live Activity for new session
         if let gym = gym(withId: gymId) {
             await LiveActivityManager.shared.startLiveActivity(
                 for: newSession,
                 gymName: gym.name)
         }
 
+        musicService.resetSessionPlaybackState()
+        musicService.playSelectedPlaylistIfHeadphonesConnected()
+
         if healthKitService.isEnabled {
             do {
                 try await healthKitService.startWorkout(
@@ -488,9 +491,13 @@ class ClimbingDataManager: ObservableObject {
         // Trigger auto-sync if enabled
         syncService.triggerAutoSync(dataManager: self)
 
-        // MARK: - End Live Activity after session ends
         await LiveActivityManager.shared.endLiveActivity()
         
+        if UserDefaults.standard.bool(forKey: "isAutoStopMusicEnabled") {
+            musicService.stopPlaybackIfEnabled()
+        }
+        musicService.stopPlaybackIfEnabled()
+
         if healthKitService.isEnabled {
             do {
                 try await healthKitService.endWorkout(

ios/Ascently/ViewModels/LiveActivityManager.swift

@@ -207,7 +207,7 @@ final class LiveActivityManager {
     func startHealthChecks() {
         stopHealthChecks()  // Stop any existing timer
 
-        AppLogger.debug("🩺 Starting Live Activity health checks", tag: Self.logTag)
+        AppLogger.debug("Starting Live Activity health checks", tag: Self.logTag)
         healthCheckTimer = Timer.scheduledTimer(withTimeInterval: 30.0, repeats: true) {
             [weak self] _ in
             Task { @MainActor [weak self] in
@@ -233,7 +233,7 @@ final class LiveActivityManager {
         // Only perform health check if it's been at least 25 seconds
         guard timeSinceLastCheck >= 25 else { return }
 
-        AppLogger.debug("🩺 Performing Live Activity health check", tag: Self.logTag)
+        AppLogger.debug("Performing Live Activity health check", tag: Self.logTag)
         lastHealthCheck = now
 
         let activities = Activity<SessionActivityAttributes>.activities