diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..791c54c
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,53 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build and test
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    defaults:
+      run:
+        working-directory: android-app
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: 21
+
+      - uses: gradle/actions/setup-gradle@v5
+
+      - name: Unit tests
+        run: ./gradlew testFossDebugUnitTest testGmsDebugUnitTest
+
+      - name: Assemble debug APKs
+        run: ./gradlew assembleFossDebug assembleGmsDebug
+
+      - name: Upload test reports
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-reports
+          path: android-app/app/build/reports/tests/
+          retention-days: 7
+
+      - name: Upload debug APKs
+        uses: actions/upload-artifact@v4
+        with:
+          name: debug-apks
+          path: android-app/app/build/outputs/apk/*/debug/*.apk
+          retention-days: 7
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..ed20a94
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,87 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    name: Build and publish release
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    defaults:
+      run:
+        working-directory: android-app
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Check tag matches app version
+        id: version
+        run: |
+          tag="${GITHUB_REF_NAME#v}"
+          app_version=$(sed -n 's/.*ClientVersion\.validate("\([^"]*\)").*/\1/p' app/build.gradle.kts)
+          if [ "$tag" != "$app_version" ]; then
+            echo "::error::Tag $GITHUB_REF_NAME does not match versionName $app_version in app/build.gradle.kts"
+            exit 1
+          fi
+          echo "name=$app_version" >> "$GITHUB_OUTPUT"
+
+      - uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: 21
+
+      - uses: gradle/actions/setup-gradle@v5
+        with:
+          cache-read-only: true
+
+      - name: Restore signing keystore
+        env:
+          KEYSTORE_BASE64: ${{ secrets.KEYSTORE_BASE64 }}
+        run: |
+          if [ -z "$KEYSTORE_BASE64" ]; then
+            echo "::error::KEYSTORE_BASE64 secret is not set"
+            exit 1
+          fi
+          echo "$KEYSTORE_BASE64" | base64 --decode > "$RUNNER_TEMP/release.jks"
+          echo "HHO_KEYSTORE_FILE=$RUNNER_TEMP/release.jks" >> "$GITHUB_ENV"
+
+      - name: Unit tests
+        run: ./gradlew testFossDebugUnitTest testGmsDebugUnitTest
+
+      - name: Assemble release APKs
+        env:
+          HHO_KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}
+          HHO_KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
+          HHO_KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
+        run: ./gradlew assembleFossRelease assembleGmsRelease
+
+      - name: Collect artifacts
+        env:
+          VERSION: ${{ steps.version.outputs.name }}
+        run: |
+          mkdir -p dist
+          for flavor in foss gms; do
+            cp "app/build/outputs/apk/$flavor/release/app-$flavor-release.apk" "dist/hho-$VERSION-$flavor.apk"
+          done
+          cd dist
+          sha256sum *.apk > SHA256SUMS
+
+      - name: Remove keystore
+        if: always()
+        run: rm -f "$RUNNER_TEMP/release.jks"
+
+      - name: Publish GitHub release
+        uses: softprops/action-gh-release@v2
+        with:
+          name: ${{ steps.version.outputs.name }}
+          generate_release_notes: true
+          fail_on_unmatched_files: true
+          files: |
+            android-app/dist/*.apk
+            android-app/dist/SHA256SUMS
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..be3f7b2
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 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 Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are 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.
+
+  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.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  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 Affero 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. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  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 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 work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero 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 Affero 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 Affero 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 Affero 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.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero 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 Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero 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 your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  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 AGPL, see
+<https://www.gnu.org/licenses/>.
diff --git a/README.md b/README.md
index 9a2ef3b..a8e65cf 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,27 @@
-# household-objects-android
-household-objects-android
+# HHO — Household Objects
+
+HHO is a **self-hosted home inventory and organization system**. You run it on your own
+hardware (a Raspberry Pi, a NAS, a home server), and it helps a household track what it owns:
+what's in the garage, which box has the holiday lights, whether the drill is still under
+warranty. No cloud account, no subscription, no external service required to operate it.
+
+HHO ships as two coupled products :
+
+- **HHO Server** ( `https://github.com/ankek/household-objects-srv/server/`) — a single Go binary / container. SQLite storage, an embedded
+  Vue 3 web UI, and a documented public REST API. This is the whole product for a browser-only
+  household.
+- **HHO Android app** (this one repository,`/android-app/`) — native Kotlin + Jetpack Compose, offline-first,
+  barcode-driven stock control for standing in front of a shelf with no signal. Syncs to the
+  server. *(Not yet functional — see [Project status](#project-status) below.)*
+
+Licensed **AGPL-3.0-only**; see [License](#license).
+
+## Project status
+This project is under development — the HHO Server MVP
+
+## License
+
+HHO and all components are licensed under the **GNU Affero General Public License v3.0 only** (`AGPL-3.0-only`) — see
+[`LICENSE`](LICENSE). The AGPL's network-use clause (section 13) is the deliberate reason it was
+chosen over plain GPL: if you run a modified version of HHO as a network service, you must offer
+its source to your users. Sorry, bro. Sad but true.
\ No newline at end of file
diff --git a/android-app/.gitignore b/android-app/.gitignore
new file mode 100644
index 0000000..4b91077
--- /dev/null
+++ b/android-app/.gitignore
@@ -0,0 +1,24 @@
+.gradle/
+build/
+app/build/
+captures/
+.cxx/
+
+local.properties
+.kotlin/
+
+*.apk
+*.aab
+*.ap_
+*.aar
+*.dex
+*.class
+*.jks
+*.keystore
+output.json
+
+.idea/
+*.iml
+.navigation/
+
+!gradle/wrapper/gradle-wrapper.jar
diff --git a/android-app/app/build.gradle.kts b/android-app/app/build.gradle.kts
new file mode 100644
index 0000000..dc5863e
--- /dev/null
+++ b/android-app/app/build.gradle.kts
@@ -0,0 +1,500 @@
+import dev.hho.android.buildsrc.ClientVersion
+import org.openapitools.generator.gradle.plugin.tasks.GenerateTask
+import java.io.File
+
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.compose)
+    alias(libs.plugins.kotlin.serialization)
+    alias(libs.plugins.ksp)
+    alias(libs.plugins.hilt)
+    alias(libs.plugins.openapi.generator)
+}
+
+val hhoClientVersion = ClientVersion.validate("0.1.0")
+
+val releaseKeystore = providers.environmentVariable("HHO_KEYSTORE_FILE")
+    .orElse(providers.gradleProperty("hho.keystore.file"))
+    .orNull
+    ?.let(::file)
+    ?.takeIf { it.isFile }
+
+android {
+    namespace = "dev.hho.android"
+    compileSdk = libs.versions.compileSdk.get().toInt()
+
+    defaultConfig {
+        applicationId = "dev.hho.android"
+        minSdk = libs.versions.minSdk.get().toInt()
+        targetSdk = libs.versions.targetSdk.get().toInt()
+        versionCode = 1
+        versionName = hhoClientVersion
+
+        buildConfigField("String", "HHO_CLIENT_VERSION", "\"$hhoClientVersion\"")
+
+        testInstrumentationRunner = "dev.hho.android.HhoHiltTestRunner"
+    }
+
+    flavorDimensions += "distribution"
+    productFlavors {
+        create("gms") {
+            dimension = "distribution"
+        }
+        create("foss") {
+            dimension = "distribution"
+        }
+    }
+
+    signingConfigs {
+        if (releaseKeystore != null) {
+            create("release") {
+                storeFile = releaseKeystore
+                storePassword = providers.environmentVariable("HHO_KEYSTORE_PASSWORD")
+                    .orElse(providers.gradleProperty("hho.keystore.password")).orNull
+                keyAlias = providers.environmentVariable("HHO_KEY_ALIAS")
+                    .orElse(providers.gradleProperty("hho.key.alias")).orNull
+                keyPassword = providers.environmentVariable("HHO_KEY_PASSWORD")
+                    .orElse(providers.gradleProperty("hho.key.password")).orNull
+            }
+        }
+    }
+
+    buildTypes {
+        debug {
+            isMinifyEnabled = false
+        }
+        release {
+            isMinifyEnabled = false
+            isShrinkResources = false
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+            signingConfig = signingConfigs.findByName("release")
+        }
+    }
+
+    dependenciesInfo {
+        includeInApk = false
+        includeInBundle = false
+    }
+
+    compileOptions {
+        val java = JavaVersion.toVersion(libs.versions.jvmTarget.get())
+        sourceCompatibility = java
+        targetCompatibility = java
+    }
+
+    buildFeatures {
+        compose = true
+        buildConfig = true
+    }
+
+    testOptions {
+        unitTests {
+            isIncludeAndroidResources = true
+            all {
+                it.jvmArgs(
+                    "--add-opens=java.base/java.lang=ALL-UNNAMED",
+                    "--add-opens=java.base/java.util=ALL-UNNAMED",
+                    "--add-opens=java.base/java.io=ALL-UNNAMED",
+                    "--add-opens=java.base/java.security=ALL-UNNAMED",
+                    "--add-opens=java.base/java.net=ALL-UNNAMED",
+                    "--add-opens=java.base/java.text=ALL-UNNAMED",
+                    "--add-opens=java.base/java.lang.reflect=ALL-UNNAMED",
+                    "--add-opens=java.base/java.util.concurrent=ALL-UNNAMED",
+                    "--add-opens=java.base/jdk.internal.access=ALL-UNNAMED",
+                    "--add-opens=java.base/sun.security.x509=ALL-UNNAMED",
+                    "--add-opens=java.desktop/java.awt.font=ALL-UNNAMED",
+                )
+            }
+        }
+    }
+
+    sourceSets {
+        getByName("main").kotlin.srcDir("src/main/kotlin")
+        getByName("test").kotlin.srcDir("src/test/kotlin")
+        getByName("debug").assets.srcDir("schemas")
+        getByName("androidTest").kotlin.srcDir("src/androidTest/kotlin")
+        getByName("gms").kotlin.srcDir("src/gms/kotlin")
+        getByName("foss").kotlin.srcDir("src/foss/kotlin")
+        getByName("testGms").kotlin.srcDir("src/testGms/kotlin")
+        getByName("testFoss").kotlin.srcDir("src/testFoss/kotlin")
+    }
+}
+
+dependencies {
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.lifecycle.runtime.ktx)
+    implementation(libs.androidx.lifecycle.viewmodel.compose)
+    implementation(libs.androidx.activity.compose)
+
+    val composeBom = platform(libs.androidx.compose.bom)
+    implementation(composeBom)
+    androidTestImplementation(composeBom)
+
+    implementation(libs.androidx.compose.ui)
+    implementation(libs.androidx.compose.ui.graphics)
+    implementation(libs.androidx.compose.ui.tooling.preview)
+    implementation(libs.androidx.compose.material3)
+    debugImplementation(libs.androidx.compose.ui.tooling)
+
+    implementation(libs.hilt.android)
+    implementation(libs.androidx.hilt.navigation.compose)
+    ksp(libs.hilt.compiler)
+
+    implementation(libs.androidx.room.runtime)
+    implementation(libs.androidx.room.ktx)
+    ksp(libs.androidx.room.compiler)
+
+    implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.androidx.datastore.preferences)
+    implementation(libs.okhttp)
+
+    implementation(libs.kotlinx.serialization.json)
+
+    implementation(libs.androidx.camera.core)
+    implementation(libs.androidx.camera.camera2)
+    implementation(libs.androidx.camera.lifecycle)
+    implementation(libs.androidx.camera.view)
+    implementation(libs.androidx.appcompat)
+
+    "gmsImplementation"(libs.mlkit.barcode.scanning)
+
+    implementation(libs.zxing.core)
+
+    testImplementation(libs.junit)
+    testImplementation(libs.okhttp.mockwebserver)
+    testImplementation(libs.kotlinx.coroutines.test)
+
+    kspTest(libs.dagger.compiler)
+
+    testImplementation(libs.robolectric)
+    testImplementation(libs.androidx.room.testing)
+    testImplementation(libs.androidx.test.core)
+    testImplementation(libs.androidx.test.ext.junit)
+
+    implementation(libs.androidx.work.runtime.ktx)
+    implementation(libs.androidx.hilt.work)
+    ksp(libs.androidx.hilt.compiler)
+
+    testImplementation(libs.androidx.work.testing)
+
+    androidTestImplementation(libs.androidx.compose.ui.test.junit4)
+    androidTestImplementation(libs.androidx.test.ext.junit)
+    androidTestImplementation(libs.androidx.test.runner)
+    androidTestImplementation(libs.androidx.test.rules)
+    androidTestImplementation(libs.androidx.test.espresso.core)
+    androidTestImplementation(libs.hilt.android.testing)
+    kspAndroidTest(libs.hilt.compiler)
+}
+
+val mergedDebugManifest =
+    layout.buildDirectory.file("intermediates/merged_manifest/fossDebug/processFossDebugMainManifest/AndroidManifest.xml")
+
+val checkNoWorkManagerDefaultInitializer = tasks.register("checkNoWorkManagerDefaultInitializer") {
+    group = "verification"
+    description = "T158e: fails if the merged debug manifest still registers WorkManager's " +
+        "default androidx.startup initializer (which would bypass HiltWorkerFactory)."
+
+    dependsOn("processFossDebugMainManifest")
+    val manifestProvider = mergedDebugManifest
+    inputs.file(manifestProvider)
+
+    doLast {
+        val manifest = manifestProvider.get().asFile
+        check(manifest.isFile) {
+            "checkNoWorkManagerDefaultInitializer: merged manifest not found at ${manifest.path} " +
+                "— AGP's output path changed; update this task rather than letting it pass vacuously."
+        }
+        val androidNs = "http://schemas.android.com/apk/res/android"
+        val doc = javax.xml.parsers.DocumentBuilderFactory.newInstance()
+            .apply { isNamespaceAware = true }
+            .newDocumentBuilder()
+            .parse(manifest)
+        val metaData = doc.getElementsByTagName("meta-data")
+        val registered = (0 until metaData.length)
+            .map { (metaData.item(it) as org.w3c.dom.Element).getAttributeNS(androidNs, "name") }
+        if ("androidx.work.WorkManagerInitializer" in registered) {
+            throw GradleException(
+                "Merged manifest (${manifest.path}) still contains androidx.work.WorkManagerInitializer: " +
+                    "WorkManager would be initialised with its default WorkerFactory at process start, " +
+                    "bypassing HhoApplication's HiltWorkerFactory, so SyncWorker could never be created. " +
+                    "Restore the tools:node=\"remove\" meta-data entry in src/main/AndroidManifest.xml.",
+            )
+        }
+    }
+}
+
+tasks.configureEach {
+    if (name == "testGmsDebugUnitTest" || name == "testFossDebugUnitTest" || name == "check") {
+        dependsOn(checkNoWorkManagerDefaultInitializer)
+    }
+}
+
+ksp {
+    arg("room.schemaLocation", layout.projectDirectory.dir("schemas").asFile.path)
+    arg("room.generateKotlin", "true")
+}
+
+val apiClientPackagePath = "dev/hho/android/data/apiclient/generated"
+
+val openApiGenerateKotlinClient = tasks.register<GenerateTask>("openApiGenerateKotlinClient") {
+    group = "hho openapi"
+    description = "Generates the Kotlin API client from server/api/openapi.yaml into a scratch " +
+        "build directory (D3.3, T157a). Run `generateApiClient` instead to update the committed " +
+        "sources under data/apiclient/generated/."
+
+    generatorName.set("kotlin")
+    library.set("jvm-okhttp4")
+    inputSpec.set(rootProject.layout.projectDirectory.file("../server/api/openapi.yaml").asFile.absolutePath)
+    outputDir.set(layout.buildDirectory.dir("generated/openapi").get().asFile.path)
+    packageName.set("dev.hho.android.data.apiclient.generated")
+
+    configOptions.set(
+        mapOf(
+            "serializationLibrary" to "kotlinx_serialization",
+            "dateLibrary" to "java8",
+            "legacyDiscriminatorBehavior" to "false",
+            "enumPropertyNaming" to "PascalCase",
+        ),
+    )
+    globalProperties.set(
+        mapOf(
+            "apiTests" to "false",
+            "modelTests" to "false",
+            "apiDocs" to "false",
+            "modelDocs" to "false",
+        ),
+    )
+}
+
+val apiClientGeneratedDir = layout.projectDirectory.dir("src/main/kotlin/$apiClientPackagePath")
+val apiClientHeader = """
+    |// SPDX-License-Identifier: AGPL-3.0-only
+    |// Generated by OpenAPI Generator from server/api/openapi.yaml — DO NOT EDIT BY HAND.
+    |// Regenerate via `./gradlew :app:generateApiClient` (D3.3, T157a/T157b).
+
+""".trimMargin()
+
+tasks.register<Sync>("generateApiClient") {
+    group = "hho openapi"
+    description = "Regenerates the committed Kotlin API client under " +
+        "data/apiclient/generated/ from server/api/openapi.yaml (D3.3, T157a/T157b)."
+
+    dependsOn(openApiGenerateKotlinClient)
+    from(layout.buildDirectory.dir("generated/openapi/src/main/kotlin/$apiClientPackagePath"))
+    into(apiClientGeneratedDir)
+
+    doLast {
+        apiClientGeneratedDir.asFileTree.matching { include("**/*.kt") }.forEach { file ->
+            val text = file.readText()
+            if (!text.startsWith(apiClientHeader)) {
+                file.writeText(apiClientHeader + text)
+            }
+        }
+    }
+}
+
+val apiClientDriftStageDir = layout.buildDirectory.dir("generated/openapi-drift-check")
+
+val stageApiClientForDriftCheck = tasks.register<Sync>("stageApiClientForDriftCheck") {
+    group = "hho openapi"
+    description = "Regenerates the Kotlin API client into a scratch directory (never the " +
+        "committed src/ tree) for checkApiClientDrift to compare against (D3.3, T157d)."
+
+    dependsOn(openApiGenerateKotlinClient)
+    from(layout.buildDirectory.dir("generated/openapi/src/main/kotlin/$apiClientPackagePath"))
+    into(apiClientDriftStageDir)
+
+    doLast {
+        apiClientDriftStageDir.get().asFileTree.matching { include("**/*.kt") }.forEach { file ->
+            val text = file.readText()
+            if (!text.startsWith(apiClientHeader)) {
+                file.writeText(apiClientHeader + text)
+            }
+        }
+    }
+}
+
+tasks.register("checkApiClientDrift") {
+    group = "hho openapi"
+    description = "CI drift gate (D3.3, T157d, NFR-032): fails if the committed Kotlin API " +
+        "client under data/apiclient/generated/ differs, byte-for-byte, from what " +
+        "server/api/openapi.yaml generates today."
+
+    dependsOn(stageApiClientForDriftCheck)
+
+    doLast {
+        val committedDir = apiClientGeneratedDir.asFile
+        val stagedDir = apiClientDriftStageDir.get().asFile
+
+        fun relativeFiles(root: File) = root.walkTopDown().filter { it.isFile }
+            .map { it.relativeTo(root).path }.toSortedSet()
+
+        val committedFiles = relativeFiles(committedDir)
+        val stagedFiles = relativeFiles(stagedDir)
+        val staleInCommitted = (committedFiles - stagedFiles).toSortedSet()
+        val missingFromCommitted = (stagedFiles - committedFiles).toSortedSet()
+        val changed = (committedFiles intersect stagedFiles).filterTo(sortedSetOf()) { rel ->
+            !committedDir.resolve(rel).readBytes().contentEquals(stagedDir.resolve(rel).readBytes())
+        }
+
+        if (staleInCommitted.isEmpty() && missingFromCommitted.isEmpty() && changed.isEmpty()) {
+            logger.lifecycle(
+                "checkApiClientDrift: no drift — the committed API client matches " +
+                    "server/api/openapi.yaml.",
+            )
+            return@doLast
+        }
+
+        val message = buildString {
+            appendLine(
+                "Generated Kotlin API client drift detected: data/apiclient/generated/ no " +
+                    "longer matches what server/api/openapi.yaml generates.",
+            )
+            if (staleInCommitted.isNotEmpty()) {
+                appendLine("  stale (committed, no longer generated): $staleInCommitted")
+            }
+            if (missingFromCommitted.isNotEmpty()) {
+                appendLine("  missing (generated, not committed): $missingFromCommitted")
+            }
+            if (changed.isNotEmpty()) {
+                appendLine("  changed: $changed")
+            }
+            append("Fix: run './gradlew :app:generateApiClient' and commit the result.")
+        }
+        throw GradleException(message)
+    }
+}
+
+val apiClientAdditiveProbeDir = layout.buildDirectory.dir("generated/openapi-additive-probe")
+val apiClientAdditiveProbeSpec = apiClientAdditiveProbeDir.map { it.file("openapi.yaml") }
+val apiClientAdditiveProbeOutputDir = apiClientAdditiveProbeDir.map { it.dir("output") }
+
+val additiveProbeOperationId = "getDiagnosticsPing"
+val additiveProbePathYaml = """
+    |  /diagnostics/ping:
+    |    get:
+    |      operationId: $additiveProbeOperationId
+    |      tags: [diagnostics]
+    |      summary: "T157e synthetic additive-drift-tolerance probe — never implemented server-side."
+    |      responses:
+    |        "200":
+    |          description: OK
+    |          content:
+    |            application/json:
+    |              schema:
+    |                type: object
+    |                properties:
+    |                  status:
+    |                    type: string
+    |                required: [status]
+    |
+""".trimMargin()
+
+val stageAdditiveOpenApiProbeSpec = tasks.register("stageAdditiveOpenApiProbeSpec") {
+    group = "hho openapi"
+    description = "T157e: writes a scratch copy of server/api/openapi.yaml with one synthetic " +
+        "additive path grafted in, for checkApiClientAdditiveDriftTolerance to regenerate " +
+        "against. Never modifies the real openapi.yaml."
+
+    val realSpecFile = rootProject.layout.projectDirectory.file("../server/api/openapi.yaml").asFile
+    val outSpecProvider = apiClientAdditiveProbeSpec
+    inputs.file(realSpecFile)
+    outputs.file(outSpecProvider)
+
+    doLast {
+        val original = realSpecFile.readText()
+        check("/diagnostics/ping" !in original) {
+            "T157e's synthetic probe path '/diagnostics/ping' already exists in the real " +
+                "server/api/openapi.yaml — pick a different placeholder path for the probe, " +
+                "this check needs a path guaranteed not to be there yet."
+        }
+
+        val marker = "\npaths:\n"
+        val markerIndex = original.indexOf(marker)
+        check(markerIndex >= 0) {
+            "T157e: could not find a top-level 'paths:' section in server/api/openapi.yaml to " +
+                "graft the synthetic additive probe path onto."
+        }
+        val insertAt = markerIndex + marker.length
+        val mutated = original.substring(0, insertAt) + additiveProbePathYaml +
+            original.substring(insertAt)
+
+        val outFile = outSpecProvider.get().asFile
+        outFile.parentFile.mkdirs()
+        outFile.writeText(mutated)
+    }
+}
+
+val openApiGenerateAdditiveProbeClient = tasks.register<GenerateTask>("openApiGenerateAdditiveProbeClient") {
+    group = "hho openapi"
+    description = "T157e: regenerates the Kotlin API client from the mutated scratch spec " +
+        "(server/api/openapi.yaml plus one synthetic additive path) into its own scratch " +
+        "output directory."
+
+    dependsOn(stageAdditiveOpenApiProbeSpec)
+    generatorName.set("kotlin")
+    library.set("jvm-okhttp4")
+    inputSpec.set(apiClientAdditiveProbeSpec.get().asFile.absolutePath)
+    outputDir.set(apiClientAdditiveProbeOutputDir.get().asFile.path)
+    packageName.set("dev.hho.android.data.apiclient.generated")
+
+    configOptions.set(
+        mapOf(
+            "serializationLibrary" to "kotlinx_serialization",
+            "dateLibrary" to "java8",
+            "legacyDiscriminatorBehavior" to "false",
+            "enumPropertyNaming" to "PascalCase",
+        ),
+    )
+    globalProperties.set(
+        mapOf(
+            "apiTests" to "false",
+            "modelTests" to "false",
+            "apiDocs" to "false",
+            "modelDocs" to "false",
+        ),
+    )
+}
+
+tasks.register("checkApiClientAdditiveDriftTolerance") {
+    group = "hho openapi"
+    description = "T157e / NFR-032, D3.3 cross-phase check: proves an additive openapi.yaml " +
+        "path (a synthetic probe route standing in for a future real addition, e.g. D2.3's " +
+        "postponed /import/homebox/* per A161) regenerates cleanly instead of being treated " +
+        "as unexpected drift. Runs entirely against scratch copies of the spec and client " +
+        "output — never touches the real openapi.yaml or the committed generated/ client."
+
+    dependsOn(openApiGenerateAdditiveProbeClient)
+
+    doLast {
+        val outputDir = apiClientAdditiveProbeOutputDir.get().asFile
+        check(outputDir.exists() && outputDir.isDirectory) {
+            "checkApiClientAdditiveDriftTolerance: expected generator output directory at " +
+                "${outputDir.path} — the additive-probe generation run did not produce one."
+        }
+
+        val generatedFiles = outputDir.walkTopDown().filter { it.isFile }.toList()
+        check(generatedFiles.isNotEmpty()) {
+            "checkApiClientAdditiveDriftTolerance: additive-probe generation produced an empty " +
+                "output tree — regenerating against a spec with a new path must still emit files."
+        }
+
+        val newApiFile = generatedFiles.firstOrNull { it.name.equals("DiagnosticsApi.kt", ignoreCase = true) }
+        check(newApiFile != null) {
+            "checkApiClientAdditiveDriftTolerance: expected a generated DiagnosticsApi.kt for " +
+                "the synthetic /diagnostics/ping probe path (new tag => new file is how this " +
+                "check tells 'the new path was picked up' from 'generation silently ignored " +
+                "it'); got: ${generatedFiles.map { it.name }.sorted()}"
+        }
+        check(newApiFile.readText().contains(additiveProbeOperationId)) {
+            "checkApiClientAdditiveDriftTolerance: generated DiagnosticsApi.kt does not " +
+                "contain the probe operation '$additiveProbeOperationId'."
+        }
+
+        logger.lifecycle(
+            "checkApiClientAdditiveDriftTolerance: PASS — an additive openapi.yaml path " +
+                "regenerates cleanly (new file: ${newApiFile.relativeTo(outputDir)}), " +
+                "confirming the drift check above would pick it up rather than reject it.",
+        )
+    }
+}
diff --git a/android-app/app/proguard-rules.pro b/android-app/app/proguard-rules.pro
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/android-app/app/proguard-rules.pro
@@ -0,0 +1 @@
+
diff --git a/android-app/app/schemas/dev.hho.android.data.room.HhoDatabase/1.json b/android-app/app/schemas/dev.hho.android.data.room.HhoDatabase/1.json
new file mode 100644
index 0000000..f7ba19f
--- /dev/null
+++ b/android-app/app/schemas/dev.hho.android.data.room.HhoDatabase/1.json
@@ -0,0 +1,876 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 1,
+    "identityHash": "be4445a849992c8135699d0c150a8c88",
+    "entities": [
+      {
+        "tableName": "item",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `name` TEXT NOT NULL, `description` TEXT, `location_id` TEXT, `quantity` INTEGER, `short_code` TEXT, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "description",
+            "columnName": "description",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "locationId",
+            "columnName": "location_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "quantity",
+            "columnName": "quantity",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "shortCode",
+            "columnName": "short_code",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_item_location_id",
+            "unique": false,
+            "columnNames": [
+              "location_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_item_location_id` ON `${TABLE_NAME}` (`location_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "warranty_block",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT, `is_lifetime` INTEGER NOT NULL, `holder` TEXT, `provider` TEXT, `starts_on` INTEGER, `expires_on` INTEGER, `notes` TEXT, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "isLifetime",
+            "columnName": "is_lifetime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "holder",
+            "columnName": "holder",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "provider",
+            "columnName": "provider",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "startsOn",
+            "columnName": "starts_on",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "expiresOn",
+            "columnName": "expires_on",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "notes",
+            "columnName": "notes",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_warranty_block_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_warranty_block_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "sold_to_block",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT, `sale_price_minor` INTEGER NOT NULL, `buyer_name` TEXT, `sold_on` INTEGER, `notes` TEXT, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "salePriceMinor",
+            "columnName": "sale_price_minor",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "buyerName",
+            "columnName": "buyer_name",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "soldOn",
+            "columnName": "sold_on",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "notes",
+            "columnName": "notes",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_sold_to_block_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_sold_to_block_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "purchased_from_block",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT, `purchase_price_minor` INTEGER NOT NULL, `vendor` TEXT, `purchased_on` INTEGER, `order_reference` TEXT, `notes` TEXT, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "purchasePriceMinor",
+            "columnName": "purchase_price_minor",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "vendor",
+            "columnName": "vendor",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "purchasedOn",
+            "columnName": "purchased_on",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "orderReference",
+            "columnName": "order_reference",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "notes",
+            "columnName": "notes",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_purchased_from_block_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_purchased_from_block_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "item_identification",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT, `kind` TEXT NOT NULL, `value` TEXT NOT NULL, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "kind",
+            "columnName": "kind",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "value",
+            "columnName": "value",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_item_identification_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_item_identification_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          },
+          {
+            "name": "index_item_identification_value",
+            "unique": false,
+            "columnNames": [
+              "value"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_item_identification_value` ON `${TABLE_NAME}` (`value`)"
+          }
+        ]
+      },
+      {
+        "tableName": "item_custom_field",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT, `name` TEXT NOT NULL, `field_type` TEXT NOT NULL, `field_def_id` TEXT, `text_value` TEXT, `number_value` TEXT, `bool_value` INTEGER, `date_value` INTEGER, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "fieldType",
+            "columnName": "field_type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "fieldDefId",
+            "columnName": "field_def_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "textValue",
+            "columnName": "text_value",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "numberValue",
+            "columnName": "number_value",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "boolValue",
+            "columnName": "bool_value",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "dateValue",
+            "columnName": "date_value",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_item_custom_field_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_item_custom_field_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "stock_adjustment",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT, `delta` INTEGER NOT NULL, `resulting_quantity` INTEGER NOT NULL, `reason` TEXT, `note` TEXT, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "delta",
+            "columnName": "delta",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "resultingQuantity",
+            "columnName": "resulting_quantity",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "reason",
+            "columnName": "reason",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "note",
+            "columnName": "note",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_stock_adjustment_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_stock_adjustment_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "location",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `name` TEXT NOT NULL, `parent_id` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `version` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parentId",
+            "columnName": "parent_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_location_parent_id",
+            "unique": false,
+            "columnNames": [
+              "parent_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_location_parent_id` ON `${TABLE_NAME}` (`parent_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "label",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `name` TEXT NOT NULL, `color` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `version` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "color",
+            "columnName": "color",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "item_label",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT NOT NULL, `label_id` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "labelId",
+            "columnName": "label_id",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_item_label_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_item_label_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          },
+          {
+            "name": "index_item_label_label_id",
+            "unique": false,
+            "columnNames": [
+              "label_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_item_label_label_id` ON `${TABLE_NAME}` (`label_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "attachment",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT NOT NULL, `category` TEXT NOT NULL, `original_filename` TEXT NOT NULL, `content_type` TEXT NOT NULL, `size_bytes` INTEGER NOT NULL, `sha256` TEXT NOT NULL, `has_thumbnail` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `version` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "category",
+            "columnName": "category",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "originalFilename",
+            "columnName": "original_filename",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "contentType",
+            "columnName": "content_type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "sizeBytes",
+            "columnName": "size_bytes",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "sha256",
+            "columnName": "sha256",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasThumbnail",
+            "columnName": "has_thumbnail",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_attachment_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_attachment_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "sync_state",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `watermark` INTEGER NOT NULL, `lastSyncedAt` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "watermark",
+            "columnName": "watermark",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastSyncedAt",
+            "columnName": "lastSyncedAt",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'be4445a849992c8135699d0c150a8c88')"
+    ]
+  }
+}
\ No newline at end of file
diff --git a/android-app/app/schemas/dev.hho.android.data.room.HhoDatabase/2.json b/android-app/app/schemas/dev.hho.android.data.room.HhoDatabase/2.json
new file mode 100644
index 0000000..2996566
--- /dev/null
+++ b/android-app/app/schemas/dev.hho.android.data.room.HhoDatabase/2.json
@@ -0,0 +1,1311 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 2,
+    "identityHash": "4745a84ecf5a5ab0344dd116f6b92f45",
+    "entities": [
+      {
+        "tableName": "item",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `name` TEXT NOT NULL, `description` TEXT, `location_id` TEXT, `quantity` INTEGER, `short_code` TEXT, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "description",
+            "columnName": "description",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "locationId",
+            "columnName": "location_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "quantity",
+            "columnName": "quantity",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "shortCode",
+            "columnName": "short_code",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_item_location_id",
+            "unique": false,
+            "columnNames": [
+              "location_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_item_location_id` ON `${TABLE_NAME}` (`location_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "warranty_block",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT, `is_lifetime` INTEGER NOT NULL, `holder` TEXT, `provider` TEXT, `starts_on` INTEGER, `expires_on` INTEGER, `notes` TEXT, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "isLifetime",
+            "columnName": "is_lifetime",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "holder",
+            "columnName": "holder",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "provider",
+            "columnName": "provider",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "startsOn",
+            "columnName": "starts_on",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "expiresOn",
+            "columnName": "expires_on",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "notes",
+            "columnName": "notes",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_warranty_block_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_warranty_block_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "sold_to_block",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT, `sale_price_minor` INTEGER NOT NULL, `buyer_name` TEXT, `sold_on` INTEGER, `notes` TEXT, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "salePriceMinor",
+            "columnName": "sale_price_minor",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "buyerName",
+            "columnName": "buyer_name",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "soldOn",
+            "columnName": "sold_on",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "notes",
+            "columnName": "notes",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_sold_to_block_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_sold_to_block_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "purchased_from_block",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT, `purchase_price_minor` INTEGER NOT NULL, `vendor` TEXT, `purchased_on` INTEGER, `order_reference` TEXT, `notes` TEXT, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "purchasePriceMinor",
+            "columnName": "purchase_price_minor",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "vendor",
+            "columnName": "vendor",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "purchasedOn",
+            "columnName": "purchased_on",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "orderReference",
+            "columnName": "order_reference",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "notes",
+            "columnName": "notes",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_purchased_from_block_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_purchased_from_block_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "item_identification",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT, `kind` TEXT NOT NULL, `value` TEXT NOT NULL, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "kind",
+            "columnName": "kind",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "value",
+            "columnName": "value",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_item_identification_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_item_identification_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          },
+          {
+            "name": "index_item_identification_value",
+            "unique": false,
+            "columnNames": [
+              "value"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_item_identification_value` ON `${TABLE_NAME}` (`value`)"
+          }
+        ]
+      },
+      {
+        "tableName": "item_custom_field",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT, `name` TEXT NOT NULL, `field_type` TEXT NOT NULL, `field_def_id` TEXT, `text_value` TEXT, `number_value` TEXT, `bool_value` INTEGER, `date_value` INTEGER, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "fieldType",
+            "columnName": "field_type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "fieldDefId",
+            "columnName": "field_def_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "textValue",
+            "columnName": "text_value",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "numberValue",
+            "columnName": "number_value",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "boolValue",
+            "columnName": "bool_value",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "dateValue",
+            "columnName": "date_value",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_item_custom_field_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_item_custom_field_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "stock_adjustment",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT, `delta` INTEGER NOT NULL, `resulting_quantity` INTEGER NOT NULL, `reason` TEXT, `note` TEXT, `created_at` INTEGER, `updated_at` INTEGER, `version` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "delta",
+            "columnName": "delta",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "resultingQuantity",
+            "columnName": "resulting_quantity",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "reason",
+            "columnName": "reason",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "note",
+            "columnName": "note",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_stock_adjustment_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_stock_adjustment_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "location",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `name` TEXT NOT NULL, `parent_id` TEXT, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `version` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parentId",
+            "columnName": "parent_id",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_location_parent_id",
+            "unique": false,
+            "columnNames": [
+              "parent_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_location_parent_id` ON `${TABLE_NAME}` (`parent_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "label",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `name` TEXT NOT NULL, `color` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `version` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "color",
+            "columnName": "color",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "item_label",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT NOT NULL, `label_id` TEXT NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "labelId",
+            "columnName": "label_id",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_item_label_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_item_label_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          },
+          {
+            "name": "index_item_label_label_id",
+            "unique": false,
+            "columnNames": [
+              "label_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_item_label_label_id` ON `${TABLE_NAME}` (`label_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "attachment",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `group_change_seq` INTEGER NOT NULL, `item_id` TEXT NOT NULL, `category` TEXT NOT NULL, `original_filename` TEXT NOT NULL, `content_type` TEXT NOT NULL, `size_bytes` INTEGER NOT NULL, `sha256` TEXT NOT NULL, `has_thumbnail` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `version` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "groupChangeSeq",
+            "columnName": "group_change_seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "category",
+            "columnName": "category",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "originalFilename",
+            "columnName": "original_filename",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "contentType",
+            "columnName": "content_type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "sizeBytes",
+            "columnName": "size_bytes",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "sha256",
+            "columnName": "sha256",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasThumbnail",
+            "columnName": "has_thumbnail",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "updatedAt",
+            "columnName": "updated_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_attachment_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_attachment_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "sync_state",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `watermark` INTEGER NOT NULL, `lastSyncedAt` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "watermark",
+            "columnName": "watermark",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastSyncedAt",
+            "columnName": "lastSyncedAt",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "outbox_mutation",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`seq` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `mutation_id` TEXT NOT NULL, `entity_type` TEXT NOT NULL, `entity_id` TEXT NOT NULL, `op` TEXT NOT NULL, `base_version` INTEGER NOT NULL, `fields_json` TEXT NOT NULL, `state` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT, `last_attempt_at` INTEGER, `created_at` INTEGER NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "seq",
+            "columnName": "seq",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "mutationId",
+            "columnName": "mutation_id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "entityType",
+            "columnName": "entity_type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "entityId",
+            "columnName": "entity_id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "op",
+            "columnName": "op",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "baseVersion",
+            "columnName": "base_version",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "fieldsJson",
+            "columnName": "fields_json",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "state",
+            "columnName": "state",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "attemptCount",
+            "columnName": "attempt_count",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastError",
+            "columnName": "last_error",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "lastAttemptAt",
+            "columnName": "last_attempt_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "seq"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_outbox_mutation_mutation_id",
+            "unique": true,
+            "columnNames": [
+              "mutation_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_outbox_mutation_mutation_id` ON `${TABLE_NAME}` (`mutation_id`)"
+          },
+          {
+            "name": "index_outbox_mutation_state_seq",
+            "unique": false,
+            "columnNames": [
+              "state",
+              "seq"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_outbox_mutation_state_seq` ON `${TABLE_NAME}` (`state`, `seq`)"
+          },
+          {
+            "name": "index_outbox_mutation_entity_type_entity_id",
+            "unique": false,
+            "columnNames": [
+              "entity_type",
+              "entity_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_outbox_mutation_entity_type_entity_id` ON `${TABLE_NAME}` (`entity_type`, `entity_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "receiving_session",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `vendor` TEXT NOT NULL, `order_reference` TEXT, `purchased_on` INTEGER, `status` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "vendor",
+            "columnName": "vendor",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "orderReference",
+            "columnName": "order_reference",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "purchasedOn",
+            "columnName": "purchased_on",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "status",
+            "columnName": "status",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "completedAt",
+            "columnName": "completed_at",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_receiving_session_status",
+            "unique": false,
+            "columnNames": [
+              "status"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_receiving_session_status` ON `${TABLE_NAME}` (`status`)"
+          }
+        ]
+      },
+      {
+        "tableName": "receiving_line",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`session_id` TEXT NOT NULL, `item_id` TEXT NOT NULL, `expected_qty` INTEGER, `received_qty` INTEGER NOT NULL, PRIMARY KEY(`session_id`, `item_id`))",
+        "fields": [
+          {
+            "fieldPath": "sessionId",
+            "columnName": "session_id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "expectedQty",
+            "columnName": "expected_qty",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "receivedQty",
+            "columnName": "received_qty",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "session_id",
+            "item_id"
+          ]
+        }
+      },
+      {
+        "tableName": "photo_queue_entry",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `item_id` TEXT NOT NULL, `file_path` TEXT NOT NULL, `sha256` TEXT NOT NULL, `size_bytes` INTEGER NOT NULL, `category` TEXT NOT NULL, `state` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `next_attempt_at` INTEGER, `last_error` TEXT, `created_at` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "itemId",
+            "columnName": "item_id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "filePath",
+            "columnName": "file_path",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "sha256",
+            "columnName": "sha256",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "sizeBytes",
+            "columnName": "size_bytes",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "category",
+            "columnName": "category",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "state",
+            "columnName": "state",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "attemptCount",
+            "columnName": "attempt_count",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "nextAttemptAt",
+            "columnName": "next_attempt_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "lastError",
+            "columnName": "last_error",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "createdAt",
+            "columnName": "created_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_photo_queue_entry_state_created_at",
+            "unique": false,
+            "columnNames": [
+              "state",
+              "created_at"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_photo_queue_entry_state_created_at` ON `${TABLE_NAME}` (`state`, `created_at`)"
+          },
+          {
+            "name": "index_photo_queue_entry_item_id",
+            "unique": false,
+            "columnNames": [
+              "item_id"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_photo_queue_entry_item_id` ON `${TABLE_NAME}` (`item_id`)"
+          }
+        ]
+      },
+      {
+        "tableName": "conflict_record",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `mutation_id` TEXT NOT NULL, `entity_type` TEXT NOT NULL, `entity_id` TEXT NOT NULL, `field_name` TEXT NOT NULL, `losing_value_json` TEXT, `server_value_json` TEXT, `detected_at` INTEGER NOT NULL, `origin` TEXT NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "mutationId",
+            "columnName": "mutation_id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "entityType",
+            "columnName": "entity_type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "entityId",
+            "columnName": "entity_id",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "fieldName",
+            "columnName": "field_name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "losingValueJson",
+            "columnName": "losing_value_json",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "serverValueJson",
+            "columnName": "server_value_json",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "detectedAt",
+            "columnName": "detected_at",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "origin",
+            "columnName": "origin",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_conflict_record_mutation_id_entity_id_field_name",
+            "unique": true,
+            "columnNames": [
+              "mutation_id",
+              "entity_id",
+              "field_name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_conflict_record_mutation_id_entity_id_field_name` ON `${TABLE_NAME}` (`mutation_id`, `entity_id`, `field_name`)"
+          }
+        ]
+      },
+      {
+        "tableName": "sync_run_state",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `last_run_at` INTEGER, `last_push_at` INTEGER, `last_error` TEXT, `last_error_at` INTEGER, `conflict_cursor` TEXT, `reconcile_pending` INTEGER NOT NULL DEFAULT 0, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastRunAt",
+            "columnName": "last_run_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "lastPushAt",
+            "columnName": "last_push_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "lastError",
+            "columnName": "last_error",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "lastErrorAt",
+            "columnName": "last_error_at",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "conflictCursor",
+            "columnName": "conflict_cursor",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "reconcilePending",
+            "columnName": "reconcile_pending",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '4745a84ecf5a5ab0344dd116f6b92f45')"
+    ]
+  }
+}
\ No newline at end of file
diff --git a/android-app/app/src/androidTest/kotlin/dev/hho/android/HhoHiltTestRunner.kt b/android-app/app/src/androidTest/kotlin/dev/hho/android/HhoHiltTestRunner.kt
new file mode 100644
index 0000000..d09639c
--- /dev/null
+++ b/android-app/app/src/androidTest/kotlin/dev/hho/android/HhoHiltTestRunner.kt
@@ -0,0 +1,11 @@
+package dev.hho.android
+
+import android.app.Application
+import android.content.Context
+import androidx.test.runner.AndroidJUnitRunner
+import dagger.hilt.android.testing.HiltTestApplication
+
+class HhoHiltTestRunner : AndroidJUnitRunner() {
+    override fun newApplication(cl: ClassLoader?, className: String?, context: Context?): Application =
+        super.newApplication(cl, HiltTestApplication::class.java.name, context)
+}
diff --git a/android-app/app/src/androidTest/kotlin/dev/hho/android/testing/AirplaneModeRule.kt b/android-app/app/src/androidTest/kotlin/dev/hho/android/testing/AirplaneModeRule.kt
new file mode 100644
index 0000000..885bc69
--- /dev/null
+++ b/android-app/app/src/androidTest/kotlin/dev/hho/android/testing/AirplaneModeRule.kt
@@ -0,0 +1,50 @@
+package dev.hho.android.testing
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.os.SystemClock
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.rules.ExternalResource
+import java.io.FileInputStream
+
+class AirplaneModeRule : ExternalResource() {
+
+    private val instrumentation get() = InstrumentationRegistry.getInstrumentation()
+
+    override fun before() {
+        shell("cmd connectivity airplane-mode enable")
+        shell("svc wifi disable")
+        shell("svc data disable")
+        val deadline = SystemClock.elapsedRealtime() + TIMEOUT_MILLIS
+        while (hasInternet()) {
+            check(SystemClock.elapsedRealtime() < deadline) {
+                "Device still reports an active internet-capable network ${TIMEOUT_MILLIS}ms after enabling airplane mode"
+            }
+            Thread.sleep(POLL_MILLIS)
+        }
+    }
+
+    override fun after() {
+        shell("cmd connectivity airplane-mode disable")
+        shell("svc wifi enable")
+        shell("svc data enable")
+    }
+
+    fun hasInternet(): Boolean {
+        val cm = instrumentation.targetContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+        val caps = cm.getNetworkCapabilities(cm.activeNetwork ?: return false) ?: return false
+        return caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+    }
+
+    private fun shell(command: String) {
+        instrumentation.uiAutomation.executeShellCommand(command).use { pfd ->
+            FileInputStream(pfd.fileDescriptor).use { it.readBytes() }
+        }
+    }
+
+    private companion object {
+        const val TIMEOUT_MILLIS = 20_000L
+        const val POLL_MILLIS = 250L
+    }
+}
diff --git a/android-app/app/src/androidTest/kotlin/dev/hho/android/testing/TestModules.kt b/android-app/app/src/androidTest/kotlin/dev/hho/android/testing/TestModules.kt
new file mode 100644
index 0000000..9a60729
--- /dev/null
+++ b/android-app/app/src/androidTest/kotlin/dev/hho/android/testing/TestModules.kt
@@ -0,0 +1,96 @@
+package dev.hho.android.testing
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.room.Room
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import dagger.hilt.testing.TestInstallIn
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.di.DataStoreModule
+import dev.hho.android.di.DeviceTokenDataStore
+import dev.hho.android.di.NetworkModule
+import dev.hho.android.di.ProbeHttpClient
+import dev.hho.android.di.RoomModule
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import java.io.File
+import java.io.IOException
+import java.util.UUID
+import java.util.Collections
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class NetworkTripwire @Inject constructor() : Interceptor {
+    val requests: MutableList<String> = Collections.synchronizedList(mutableListOf())
+
+    override fun intercept(chain: Interceptor.Chain): okhttp3.Response {
+        requests += "${chain.request().method} ${chain.request().url}"
+        throw IOException("NetworkTripwire: network access attempted in an offline test")
+    }
+}
+
+@Module
+@TestInstallIn(components = [SingletonComponent::class], replaces = [RoomModule::class])
+object TestRoomModule {
+    @Provides
+    @Singleton
+    fun provideDatabase(@ApplicationContext context: Context): HhoDatabase =
+        Room.inMemoryDatabaseBuilder(context, HhoDatabase::class.java).allowMainThreadQueries().build()
+
+    @Provides fun itemDao(db: HhoDatabase) = db.itemDao()
+    @Provides fun warrantyBlockDao(db: HhoDatabase) = db.warrantyBlockDao()
+    @Provides fun soldToBlockDao(db: HhoDatabase) = db.soldToBlockDao()
+    @Provides fun purchasedFromBlockDao(db: HhoDatabase) = db.purchasedFromBlockDao()
+    @Provides fun itemIdentificationDao(db: HhoDatabase) = db.itemIdentificationDao()
+    @Provides fun itemCustomFieldDao(db: HhoDatabase) = db.itemCustomFieldDao()
+    @Provides fun stockAdjustmentDao(db: HhoDatabase) = db.stockAdjustmentDao()
+    @Provides fun locationDao(db: HhoDatabase) = db.locationDao()
+    @Provides fun labelDao(db: HhoDatabase) = db.labelDao()
+    @Provides fun itemLabelDao(db: HhoDatabase) = db.itemLabelDao()
+    @Provides fun attachmentDao(db: HhoDatabase) = db.attachmentDao()
+    @Provides fun syncStateDao(db: HhoDatabase) = db.syncStateDao()
+    @Provides fun outboxDao(db: HhoDatabase) = db.outboxDao()
+    @Provides fun receivingDao(db: HhoDatabase) = db.receivingDao()
+    @Provides fun photoQueueDao(db: HhoDatabase) = db.photoQueueDao()
+    @Provides fun conflictRecordDao(db: HhoDatabase) = db.conflictRecordDao()
+    @Provides fun syncRunStateDao(db: HhoDatabase) = db.syncRunStateDao()
+}
+
+@Module
+@TestInstallIn(components = [SingletonComponent::class], replaces = [NetworkModule::class])
+object TestNetworkModule {
+    @Provides
+    @Singleton
+    fun provideOkHttpClient(tripwire: NetworkTripwire): OkHttpClient =
+        OkHttpClient.Builder().addInterceptor(tripwire).build()
+
+    @Provides
+    @Singleton
+    @ProbeHttpClient
+    fun provideProbeOkHttpClient(tripwire: NetworkTripwire): OkHttpClient =
+        OkHttpClient.Builder().addInterceptor(tripwire).build()
+}
+
+@Module
+@TestInstallIn(components = [SingletonComponent::class], replaces = [DataStoreModule::class])
+object TestDataStoreModule {
+    @Provides
+    @Singleton
+    fun provideSettingsDataStore(@ApplicationContext context: Context): DataStore<Preferences> = fresh(context)
+
+    @Provides
+    @Singleton
+    @DeviceTokenDataStore
+    fun provideDeviceTokenDataStore(@ApplicationContext context: Context): DataStore<Preferences> = fresh(context)
+
+    private fun fresh(context: Context): DataStore<Preferences> =
+        PreferenceDataStoreFactory.create(
+            produceFile = { File(context.cacheDir, "test-${UUID.randomUUID()}.preferences_pb") },
+        )
+}
diff --git a/android-app/app/src/androidTest/kotlin/dev/hho/android/ui/items/OfflineEditsInstrumentedTest.kt b/android-app/app/src/androidTest/kotlin/dev/hho/android/ui/items/OfflineEditsInstrumentedTest.kt
new file mode 100644
index 0000000..418f270
--- /dev/null
+++ b/android-app/app/src/androidTest/kotlin/dev/hho/android/ui/items/OfflineEditsInstrumentedTest.kt
@@ -0,0 +1,160 @@
+package dev.hho.android.ui.items
+
+import android.view.ViewGroup
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.hasSetTextAction
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performScrollTo
+import androidx.compose.ui.test.performTextInput
+import androidx.compose.ui.test.performTextReplacement
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import dev.hho.android.MainActivity
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.testing.AirplaneModeRule
+import dev.hho.android.testing.NetworkTripwire
+import dev.hho.android.ui.theme.HhoTheme
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.RuleChain
+import org.junit.runner.RunWith
+import javax.inject.Inject
+
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class OfflineEditsInstrumentedTest {
+
+    private val hiltRule = HiltAndroidRule(this)
+    private val airplane = AirplaneModeRule()
+    private val compose = createAndroidComposeRule<MainActivity>()
+
+    @get:Rule
+    val chain: RuleChain = RuleChain.outerRule(hiltRule).around(airplane).around(compose)
+
+    @Inject lateinit var db: HhoDatabase
+
+    @Inject lateinit var tripwire: NetworkTripwire
+
+    private sealed interface Screen {
+        data object List : Screen
+        data class Detail(val id: String) : Screen
+        data class Form(val id: String?, val visit: Int) : Screen
+    }
+
+    @Before
+    fun seed() {
+        hiltRule.inject()
+        runBlocking {
+            db.itemDao().upsertAll(
+                listOf(ItemEntity(DRILL, 1L, "Cordless Drill", "A cordless drill", null, 3L, "DR-1", 1L, 1L, 1L)),
+            )
+        }
+        compose.activityRule.scenario.onActivity { activity ->
+            val host = activity.findViewById<ViewGroup>(android.R.id.content).getChildAt(0) as ComposeView
+            host.setContent {
+                HhoTheme(darkTheme = false) {
+                    var screen by remember { mutableStateOf<Screen>(Screen.List) }
+                    var visits by remember { mutableIntStateOf(0) }
+                    when (val s = screen) {
+                        Screen.List -> ItemListScreen(
+                            onItemClick = { screen = Screen.Detail(it) },
+                            onNewItem = { screen = Screen.Form(null, ++visits) },
+                        )
+                        is Screen.Detail -> ItemDetailScreen(
+                            itemId = s.id,
+                            onBack = { screen = Screen.List },
+                            onEdit = { screen = Screen.Form(s.id, ++visits) },
+                        )
+                        is Screen.Form -> ItemFormScreen(
+                            itemId = s.id,
+                            viewModel = hiltViewModel(key = "form-${s.visit}"),
+                            onSaved = { screen = Screen.Detail(it) },
+                            onCancel = { screen = if (s.id == null) Screen.List else Screen.Detail(s.id) },
+                        )
+                    }
+                }
+            }
+        }
+        compose.waitForIdle()
+    }
+
+    @After
+    fun assertNoNetworkAttempted() {
+        assertEquals("network requests were attempted while offline", emptyList<String>(), tripwire.requests.toList())
+    }
+
+    @Test
+    fun editAdjustAndCreateWorkOfflineAndQueueDistinctMutations() {
+        assertTrue("device is not offline", !airplane.hasInternet())
+
+        compose.onNodeWithText("Cordless Drill").performClick()
+        awaitText("Quantity: 3")
+        compose.onNodeWithText("Edit").performClick()
+        awaitText("Edit item")
+        compose.onNode(hasSetTextAction() and hasText("Name (required)")).performTextReplacement("Impact Driver")
+        compose.onNodeWithText("Save").performClick()
+        awaitText("Impact Driver")
+        shown("Impact Driver")
+
+        compose.onNodeWithText("Adjust quantity").performClick()
+        compose.onNodeWithText("+1").performClick()
+        compose.onNodeWithText("+1").performClick()
+        compose.onNodeWithText("Confirm").performClick()
+        awaitText("Quantity: 6")
+        shown("Quantity: 6")
+
+        compose.onNodeWithText("Back").performClick()
+        compose.onNodeWithText("New item").performClick()
+        awaitText("Identifier (optional)")
+        compose.onNode(hasSetTextAction() and hasText("Name (required)")).performTextInput("Label Maker")
+        compose.onNodeWithText("barcode").performScrollTo().performClick()
+        compose.onNode(hasSetTextAction() and hasText("Identifier value")).performScrollTo().performTextInput("4006381333931")
+        compose.onNodeWithText("Create").performScrollTo().performClick()
+        awaitText("Label Maker")
+        shown("Label Maker")
+        shown("barcode: 4006381333931")
+
+        val rows = runBlocking { db.outboxDao().getAllOrdered() }
+        assertEquals(4, rows.size)
+        assertEquals(listOf("item", "stock_adjustment", "item", "item_identification"), rows.map { it.entityType })
+        assertEquals(DRILL, rows[0].entityId)
+        assertEquals("mutation_ids must be distinct", 4, rows.map { it.mutationId }.toSet().size)
+        assertEquals(listOf("upsert", "upsert", "upsert", "upsert"), rows.map { it.op })
+        assertEquals("creates are based on version 0", listOf(0L, 0L, 0L), listOf(rows[1], rows[2], rows[3]).map { it.baseVersion })
+        assertTrue(rows[0].fieldsJson.contains("Impact Driver"))
+        assertTrue(rows[1].fieldsJson.contains("\"delta\""))
+        assertTrue(rows[3].fieldsJson.contains("4006381333931"))
+        assertTrue("no item mutation may carry quantity", rows.filter { it.entityType == "item" }.none { it.fieldsJson.contains("quantity") })
+    }
+
+    private fun awaitText(text: String) {
+        compose.waitUntil(WAIT_MILLIS) { compose.onAllNodesWithText(text).fetchSemanticsNodes().isNotEmpty() }
+    }
+
+    private fun shown(text: String) {
+        compose.onNodeWithText(text).performScrollTo().assertIsDisplayed()
+    }
+
+    private companion object {
+        const val DRILL = "item-1"
+        const val WAIT_MILLIS = 10_000L
+    }
+}
diff --git a/android-app/app/src/androidTest/kotlin/dev/hho/android/ui/items/OfflineItemsInstrumentedTest.kt b/android-app/app/src/androidTest/kotlin/dev/hho/android/ui/items/OfflineItemsInstrumentedTest.kt
new file mode 100644
index 0000000..ee74107
--- /dev/null
+++ b/android-app/app/src/androidTest/kotlin/dev/hho/android/ui/items/OfflineItemsInstrumentedTest.kt
@@ -0,0 +1,291 @@
+package dev.hho.android.ui.items
+
+import android.view.ViewGroup
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.test.assertCountEquals
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.performScrollTo
+import androidx.compose.ui.test.hasSetTextAction
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTextInput
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemCustomFieldEntity
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemIdentificationEntity
+import dev.hho.android.data.room.ItemLabelEntity
+import dev.hho.android.data.room.LabelEntity
+import dev.hho.android.data.room.LocationEntity
+import dev.hho.android.data.room.PurchasedFromBlockEntity
+import dev.hho.android.data.room.SoldToBlockEntity
+import dev.hho.android.data.room.StockAdjustmentEntity
+import dev.hho.android.data.room.WarrantyBlockEntity
+import dev.hho.android.testing.AirplaneModeRule
+import dev.hho.android.MainActivity
+import dev.hho.android.testing.NetworkTripwire
+import dev.hho.android.ui.theme.HhoTheme
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.RuleChain
+import org.junit.runner.RunWith
+import java.math.BigDecimal
+import java.time.LocalDate
+import javax.inject.Inject
+
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class OfflineItemsInstrumentedTest {
+
+    private val hiltRule = HiltAndroidRule(this)
+    private val airplane = AirplaneModeRule()
+    private val compose = createAndroidComposeRule<MainActivity>()
+
+    @get:Rule
+    val chain: RuleChain = RuleChain.outerRule(hiltRule).around(airplane).around(compose)
+
+    @Inject lateinit var db: HhoDatabase
+
+    @Inject lateinit var tripwire: NetworkTripwire
+
+    @Before
+    fun seed() {
+        hiltRule.inject()
+        runBlocking { seedFixtures() }
+        compose.activityRule.scenario.onActivity { activity ->
+            val host = activity.findViewById<ViewGroup>(android.R.id.content).getChildAt(0) as ComposeView
+            host.setContent {
+            HhoTheme(darkTheme = false) {
+                var selected by rememberSaveable { mutableStateOf<String?>(null) }
+                val id = selected
+                if (id == null) {
+                    ItemListScreen(onItemClick = { selected = it })
+                } else {
+                    ItemDetailScreen(itemId = id, onBack = { selected = null })
+                }
+            }
+            }
+        }
+        compose.waitForIdle()
+    }
+
+    @After
+    fun assertNoNetworkAttempted() {
+        assertEquals("network requests were attempted while offline", emptyList<String>(), tripwire.requests.toList())
+    }
+
+    @Test
+    fun deviceIsActuallyOffline() {
+        assertFalse("airplane mode did not take the device offline", airplane.hasInternet())
+    }
+
+    @Test
+    fun listShowsAllSeededItems() {
+        compose.onNodeWithText("Cordless Drill").assertExists()
+        compose.onNodeWithText("Garden Hose").assertExists()
+        compose.onNodeWithText("Stepladder").assertExists()
+        compose.onNodeWithText("Qty 3 · DR-1").assertExists()
+    }
+
+    @Test
+    fun searchByNameFilters() {
+        search("hose")
+        compose.onNodeWithText("Garden Hose").assertExists()
+        compose.onAllNodesWithText("Cordless Drill").assertCountEquals(0)
+        compose.onAllNodesWithText("Stepladder").assertCountEquals(0)
+    }
+
+    @Test
+    fun searchByIdentifierValueFilters() {
+        search("SN-DRILL")
+        compose.onNodeWithText("Cordless Drill").assertExists()
+        compose.onAllNodesWithText("Garden Hose").assertCountEquals(0)
+        compose.onAllNodesWithText("Stepladder").assertCountEquals(0)
+    }
+
+    @Test
+    fun searchWithNoMatchShowsNoMatchesState() {
+        search("zzz-nothing")
+        compose.onNodeWithText("No items, short codes, or scanned values match \"zzz-nothing\".").assertExists()
+        compose.onAllNodesWithText("Cordless Drill").assertCountEquals(0)
+    }
+
+    @Test
+    fun detailShowsCoreFieldsLocationAndLabels() {
+        openDrill()
+        shown("A cordless drill")
+        shown("Quantity: 3")
+        shown("Short code: DR-1")
+        shown("Location: Garage")
+        shown("Labels: Power tools, Fragile")
+    }
+
+    @Test
+    fun detailShowsWarrantySoldToAndPurchasedFromBlocks() {
+        openDrill()
+        shown("Warranty")
+        shown("Holder: Jane Doe")
+        shown("Provider: Acme Warranties")
+        shown("Starts: 2024-01-01")
+        shown("Expires: 2026-01-01")
+        shown("Sold to")
+        shown("Sale price (minor units): 5000")
+        shown("Buyer: Alex Buyer")
+        shown("Purchased from")
+        shown("Purchase price (minor units): 12000")
+        shown("Vendor: Hardware Store")
+        shown("Order reference: PO-42")
+    }
+
+    @Test
+    fun detailShowsIdentifiersAndEveryCustomFieldType() {
+        openDrill()
+        shown("Identifiers")
+        shown("barcode: 0123456789012")
+        shown("serial: SN-DRILL-77")
+        shown("Custom fields")
+        shown("Colour: Red")
+        shown("Voltage: 18.5")
+        shown("Cordless: Yes")
+        shown("Bought: 2023-03-01")
+    }
+
+    @Test
+    fun detailShowsStockHistory() {
+        openDrill()
+        shown("Stock history")
+        shown("+5 → 5 (initial)")
+        shown("-2 → 3 (loan)")
+        shown("Note: lent to a neighbour")
+    }
+
+    @Test
+    fun richItemLastStockRowIsReachableByScrolling() {
+        compose.onNode(hasText("Server Rack")).performClick()
+        compose.waitUntil(WAIT_MILLIS) {
+            compose.onAllNodesWithText("Short code: RACK-9").fetchSemanticsNodes().isNotEmpty()
+        }
+        shown("Note: adjustment note 30")
+        shown("+1 → 30 (adjust 30)")
+        shown("rack-id-1: RACK-VAL-1")
+    }
+
+    @Test
+    fun backFromDetailReturnsToList() {
+        openDrill()
+        compose.onNodeWithText("Back").performClick()
+        compose.onNodeWithText("Garden Hose").assertExists()
+        compose.onNodeWithText("Stepladder").assertExists()
+    }
+
+    @Test
+    fun itemWithoutBlocksOmitsThem() {
+        compose.onNodeWithText("Stepladder").performClick()
+        compose.onNodeWithText("Back").assertExists()
+        compose.onAllNodesWithText("Warranty").assertCountEquals(0)
+        compose.onAllNodesWithText("Identifiers").assertCountEquals(0)
+    }
+
+    private fun shown(text: String) {
+        compose.onNodeWithText(text).performScrollTo().assertIsDisplayed()
+    }
+
+    private fun search(query: String) {
+        compose.onNode(hasSetTextAction()).performTextInput(query)
+        compose.waitForIdle()
+    }
+
+    private fun openDrill() {
+        compose.onNode(hasText("Cordless Drill")).performClick()
+        compose.waitUntil(WAIT_MILLIS) {
+            compose.onAllNodesWithText("Location: Garage").fetchSemanticsNodes().isNotEmpty()
+        }
+    }
+
+    private suspend fun seedFixtures() {
+        db.locationDao().upsert(LocationEntity("loc-1", 1L, "Garage", null, 1L, 1L, 1L))
+        db.labelDao().upsert(LabelEntity("label-1", 1L, "Power tools", "#ffffff", 1L, 1L, 1L))
+        db.labelDao().upsert(LabelEntity("label-2", 1L, "Fragile", "#ffffff", 1L, 1L, 1L))
+        db.itemDao().upsertAll(
+            listOf(
+                item("item-1", "Cordless Drill", locationId = "loc-1", quantity = 3L, shortCode = "DR-1", description = "A cordless drill"),
+                item("item-2", "Garden Hose", quantity = 1L, shortCode = "GH-2", description = null),
+                item("item-4", "Server Rack", quantity = 30L, shortCode = "RACK-9", description = null),
+                item("item-3", "Stepladder", quantity = null, shortCode = null, description = null),
+            ),
+        )
+        db.itemLabelDao().upsert(ItemLabelEntity("il-1", 1L, "item-1", "label-1"))
+        db.itemLabelDao().upsert(ItemLabelEntity("il-2", 1L, "item-1", "label-2"))
+        db.warrantyBlockDao().upsert(
+            WarrantyBlockEntity(
+                "w-1", 1L, "item-1", false, "Jane Doe", "Acme Warranties",
+                LocalDate.of(2024, 1, 1), LocalDate.of(2026, 1, 1), "Keep receipt", 1L, 1L, 1L,
+            ),
+        )
+        db.soldToBlockDao().upsert(
+            SoldToBlockEntity("s-1", 1L, "item-1", 5_000L, "Alex Buyer", LocalDate.of(2024, 6, 1), "Yard sale", 1L, 1L, 1L),
+        )
+        db.purchasedFromBlockDao().upsert(
+            PurchasedFromBlockEntity(
+                "p-1", 1L, "item-1", 12_000L, "Hardware Store", LocalDate.of(2023, 3, 1), "PO-42", "On sale", 1L, 1L, 1L,
+            ),
+        )
+        db.itemIdentificationDao().upsert(identifier("id-1", "item-1", "barcode", "0123456789012"))
+        db.itemIdentificationDao().upsert(identifier("id-2", "item-1", "serial", "SN-DRILL-77"))
+        db.itemIdentificationDao().upsert(identifier("id-3", "item-2", "barcode", "9998887776665"))
+        db.itemCustomFieldDao().upsert(customField("cf-1", "Colour", "text", textValue = "Red"))
+        db.itemCustomFieldDao().upsert(customField("cf-2", "Voltage", "number", numberValue = BigDecimal("18.5")))
+        db.itemCustomFieldDao().upsert(customField("cf-3", "Cordless", "boolean", boolValue = true))
+        db.itemCustomFieldDao().upsert(customField("cf-4", "Bought", "date", dateValue = LocalDate.of(2023, 3, 1)))
+        for (n in 1..RICH_ROWS) {
+            db.itemIdentificationDao().upsert(identifier("rid-$n", "item-4", "rack-id-$n", "RACK-VAL-$n"))
+            db.itemCustomFieldDao().upsert(customField("rcf-$n", "Field $n", "text", textValue = "Value $n", itemId = "item-4"))
+            db.stockAdjustmentDao().upsert(
+                StockAdjustmentEntity("rsa-$n", 1L, "item-4", 1L, n.toLong(), "adjust $n", "adjustment note $n", n.toLong(), n.toLong(), 1L),
+            )
+        }
+        db.stockAdjustmentDao().upsert(stock("sa-1", 5L, 5L, "initial", null, 1L))
+        db.stockAdjustmentDao().upsert(stock("sa-2", -2L, 3L, "loan", "lent to a neighbour", 2L))
+    }
+
+    private fun item(id: String, name: String, locationId: String? = null, quantity: Long?, shortCode: String?, description: String?) =
+        ItemEntity(id, 1L, name, description, locationId, quantity, shortCode, 1L, 1L, 1L)
+
+    private fun identifier(id: String, itemId: String, kind: String, value: String) =
+        ItemIdentificationEntity(id, 1L, itemId, kind, value, 1L, 1L, 1L)
+
+    private fun customField(
+        id: String,
+        name: String,
+        type: String,
+        textValue: String? = null,
+        numberValue: BigDecimal? = null,
+        boolValue: Boolean? = null,
+        dateValue: LocalDate? = null,
+        itemId: String = "item-1",
+    ) = ItemCustomFieldEntity(
+        id, 1L, itemId, name, type, null, textValue, numberValue, boolValue, dateValue, 1L, 1L, 1L,
+    )
+
+    private fun stock(id: String, delta: Long, resulting: Long, reason: String?, note: String?, at: Long) =
+        StockAdjustmentEntity(id, 1L, "item-1", delta, resulting, reason, note, at, at, 1L)
+
+    private companion object {
+        const val WAIT_MILLIS = 10_000L
+        const val RICH_ROWS = 30
+    }
+}
diff --git a/android-app/app/src/foss/kotlin/dev/hho/android/di/ScannerModule.kt b/android-app/app/src/foss/kotlin/dev/hho/android/di/ScannerModule.kt
new file mode 100644
index 0000000..38c7ab7
--- /dev/null
+++ b/android-app/app/src/foss/kotlin/dev/hho/android/di/ScannerModule.kt
@@ -0,0 +1,18 @@
+package dev.hho.android.di
+
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import dev.hho.android.data.scanner.BarcodeScanner
+import dev.hho.android.data.scanner.ZxingBarcodeScanner
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+abstract class ScannerModule {
+
+    @Binds
+    @Singleton
+    abstract fun bindBarcodeScanner(impl: ZxingBarcodeScanner): BarcodeScanner
+}
diff --git a/android-app/app/src/gms/kotlin/dev/hho/android/data/scanner/MlKitBarcodeScanner.kt b/android-app/app/src/gms/kotlin/dev/hho/android/data/scanner/MlKitBarcodeScanner.kt
new file mode 100644
index 0000000..c0cac02
--- /dev/null
+++ b/android-app/app/src/gms/kotlin/dev/hho/android/data/scanner/MlKitBarcodeScanner.kt
@@ -0,0 +1,57 @@
+package dev.hho.android.data.scanner
+
+import androidx.camera.core.ImageProxy
+import com.google.android.gms.tasks.Task
+import com.google.mlkit.vision.barcode.BarcodeScanning
+import com.google.mlkit.vision.barcode.common.Barcode
+import com.google.mlkit.vision.common.InputImage
+import kotlinx.coroutines.suspendCancellableCoroutine
+import javax.inject.Inject
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+class MlKitBarcodeScanner
+    @Inject
+    constructor() : BarcodeScanner {
+
+        private val client: com.google.mlkit.vision.barcode.BarcodeScanner by lazy { BarcodeScanning.getClient() }
+
+        override suspend fun scan(imageProxy: ImageProxy): List<DecodedBarcode> {
+            val mediaImage = imageProxy.image ?: return emptyList()
+            val inputImage = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
+            val barcodes = client.process(inputImage).await()
+            return barcodes.mapNotNull { mapMlKitBarcode(it.rawValue, it.format) }
+        }
+
+        override fun close() {
+            client.close()
+        }
+    }
+
+internal fun mapMlKitBarcode(rawValue: String?, mlKitFormat: Int): DecodedBarcode? =
+    rawValue?.let { DecodedBarcode(it, mapMlKitFormat(mlKitFormat)) }
+
+internal fun mapMlKitFormat(mlKitFormat: Int): BarcodeFormat =
+    when (mlKitFormat) {
+        Barcode.FORMAT_QR_CODE -> BarcodeFormat.QR_CODE
+        Barcode.FORMAT_AZTEC -> BarcodeFormat.AZTEC
+        Barcode.FORMAT_DATA_MATRIX -> BarcodeFormat.DATA_MATRIX
+        Barcode.FORMAT_PDF417 -> BarcodeFormat.PDF_417
+        Barcode.FORMAT_CODE_39 -> BarcodeFormat.CODE_39
+        Barcode.FORMAT_CODE_93 -> BarcodeFormat.CODE_93
+        Barcode.FORMAT_CODE_128 -> BarcodeFormat.CODE_128
+        Barcode.FORMAT_CODABAR -> BarcodeFormat.CODABAR
+        Barcode.FORMAT_ITF -> BarcodeFormat.ITF
+        Barcode.FORMAT_EAN_8 -> BarcodeFormat.EAN_8
+        Barcode.FORMAT_EAN_13 -> BarcodeFormat.EAN_13
+        Barcode.FORMAT_UPC_A -> BarcodeFormat.UPC_A
+        Barcode.FORMAT_UPC_E -> BarcodeFormat.UPC_E
+        else -> BarcodeFormat.UNKNOWN
+    }
+
+private suspend fun <T> Task<T>.await(): T =
+    suspendCancellableCoroutine { continuation ->
+        addOnSuccessListener { continuation.resume(it) }
+        addOnFailureListener { continuation.resumeWithException(it) }
+        addOnCanceledListener { continuation.cancel() }
+    }
diff --git a/android-app/app/src/gms/kotlin/dev/hho/android/di/ScannerModule.kt b/android-app/app/src/gms/kotlin/dev/hho/android/di/ScannerModule.kt
new file mode 100644
index 0000000..2268220
--- /dev/null
+++ b/android-app/app/src/gms/kotlin/dev/hho/android/di/ScannerModule.kt
@@ -0,0 +1,18 @@
+package dev.hho.android.di
+
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import dev.hho.android.data.scanner.BarcodeScanner
+import dev.hho.android.data.scanner.MlKitBarcodeScanner
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+abstract class ScannerModule {
+
+    @Binds
+    @Singleton
+    abstract fun bindBarcodeScanner(impl: MlKitBarcodeScanner): BarcodeScanner
+}
diff --git a/android-app/app/src/main/AndroidManifest.xml b/android-app/app/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..192f07f
--- /dev/null
+++ b/android-app/app/src/main/AndroidManifest.xml
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-feature
+        android:name="android.hardware.camera"
+        android:required="false" />
+
+    <application
+        android:name=".HhoApplication"
+        android:allowBackup="false"
+        android:icon="@android:drawable/sym_def_app_icon"
+        android:label="@string/app_name"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.Hho"
+        android:usesCleartextTraffic="true">
+
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:label="@string/app_name"
+            android:launchMode="singleTop"
+            android:theme="@style/Theme.Hho">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="https" />
+                <data android:scheme="http" />
+                <data android:host="*" />
+                <data android:pathPrefix="/i/" />
+            </intent-filter>
+        </activity>
+        <provider
+            android:name="androidx.startup.InitializationProvider"
+            android:authorities="${applicationId}.androidx-startup"
+            android:exported="false"
+            tools:node="merge">
+            <meta-data
+                android:name="androidx.work.WorkManagerInitializer"
+                android:value="androidx.startup"
+                tools:node="remove" />
+        </provider>
+    </application>
+
+</manifest>
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/HhoApplication.kt b/android-app/app/src/main/kotlin/dev/hho/android/HhoApplication.kt
new file mode 100644
index 0000000..9100bd7
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/HhoApplication.kt
@@ -0,0 +1,26 @@
+package dev.hho.android
+
+import android.app.Application
+import androidx.hilt.work.HiltWorkerFactory
+import androidx.work.Configuration
+import dagger.hilt.android.HiltAndroidApp
+import dev.hho.android.data.sync.SyncScheduler
+import javax.inject.Inject
+
+@HiltAndroidApp
+class HhoApplication : Application(), Configuration.Provider {
+
+    @Inject
+    lateinit var hiltWorkerFactory: HiltWorkerFactory
+
+    @Inject
+    lateinit var syncScheduler: SyncScheduler
+
+    override val workManagerConfiguration: Configuration
+        get() = Configuration.Builder().setWorkerFactory(hiltWorkerFactory).build()
+
+    override fun onCreate() {
+        super.onCreate()
+        syncScheduler.schedulePeriodic()
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/MainActivity.kt b/android-app/app/src/main/kotlin/dev/hho/android/MainActivity.kt
new file mode 100644
index 0000000..51fd89d
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/MainActivity.kt
@@ -0,0 +1,47 @@
+package dev.hho.android
+
+import android.content.Intent
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import dagger.hilt.android.AndroidEntryPoint
+import dev.hho.android.ui.HhoApp
+import dev.hho.android.ui.deeplink.ItemDeepLink
+import dev.hho.android.ui.deeplink.parseItemDeepLink
+import dev.hho.android.ui.theme.HhoTheme
+
+@AndroidEntryPoint
+class MainActivity : ComponentActivity() {
+
+    private var pendingDeepLink by mutableStateOf<ItemDeepLink?>(null)
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+        if (savedInstanceState == null) captureDeepLink(intent)
+        setContent {
+            HhoTheme {
+                HhoApp(
+                    pendingDeepLink = pendingDeepLink,
+                    onDeepLinkHandled = { pendingDeepLink = null },
+                )
+            }
+        }
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+        captureDeepLink(intent)
+    }
+
+    private fun captureDeepLink(intent: Intent?) {
+        if (intent?.action == Intent.ACTION_VIEW) {
+            parseItemDeepLink(intent.dataString)?.let { pendingDeepLink = it }
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/ApiError.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/ApiError.kt
new file mode 100644
index 0000000..85bedda
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/ApiError.kt
@@ -0,0 +1,34 @@
+package dev.hho.android.data.apiclient
+
+sealed class ApiError(message: String, cause: Throwable? = null) : Exception(message, cause) {
+    class NoInstanceConfigured(cause: Throwable) :
+        ApiError("No self-hosted instance is configured yet", cause)
+
+    class Unauthorized(cause: Throwable? = null) : ApiError("Not authenticated", cause)
+
+    class NotFound(cause: Throwable? = null) : ApiError("Not found", cause)
+
+    class Conflict(val detail: String?, cause: Throwable? = null) :
+        ApiError("Conflict" + (detail?.let { ": $it" } ?: ""), cause)
+
+    open class Validation(val status: Int, val detail: String?, cause: Throwable? = null) :
+        ApiError("Client error $status" + (detail?.let { ": $it" } ?: ""), cause)
+
+    class PayloadTooLarge(detail: String?, cause: Throwable? = null) : Validation(413, detail, cause)
+
+    class UpgradeRequired(val minimumVersion: String, val detail: String?, cause: Throwable? = null) :
+        ApiError(
+            "Client too old — server requires at least $minimumVersion" + (detail?.let { ": $it" } ?: ""),
+            cause,
+        )
+
+    class Server(val status: Int, val detail: String?, cause: Throwable? = null) :
+        ApiError("Server error $status" + (detail?.let { ": $it" } ?: ""), cause)
+
+    class Network(cause: Throwable) : ApiError("Network failure", cause)
+
+    class UnexpectedPayload(val detail: String, cause: Throwable? = null) :
+        ApiError("Unexpected response payload: $detail", cause)
+
+    class Unknown(cause: Throwable) : ApiError(cause.message ?: "Unexpected error", cause)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/AttachmentInfo.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/AttachmentInfo.kt
new file mode 100644
index 0000000..0aa25df
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/AttachmentInfo.kt
@@ -0,0 +1,46 @@
+package dev.hho.android.data.apiclient
+
+import dev.hho.android.data.apiclient.generated.apis.AttachmentsApi
+import dev.hho.android.data.apiclient.generated.models.Attachment
+
+enum class AttachmentCategory(val wire: String) {
+    IMAGE("image"),
+    MANUAL("manual"),
+    WARRANTY("warranty"),
+    RECEIPT("receipt"),
+    GENERAL("general"),
+}
+
+data class AttachmentInfo(
+    val id: String,
+    val itemId: String,
+    val category: String,
+    val originalFilename: String,
+    val contentType: String,
+    val sizeBytes: Long,
+    val sha256: String,
+    val createdAt: Long,
+    val hasThumbnail: Boolean,
+)
+
+internal fun AttachmentCategory.toGenerated(): AttachmentsApi.CategoryUploadItemAttachment =
+    when (this) {
+        AttachmentCategory.IMAGE -> AttachmentsApi.CategoryUploadItemAttachment.Image
+        AttachmentCategory.MANUAL -> AttachmentsApi.CategoryUploadItemAttachment.Manual
+        AttachmentCategory.WARRANTY -> AttachmentsApi.CategoryUploadItemAttachment.Warranty
+        AttachmentCategory.RECEIPT -> AttachmentsApi.CategoryUploadItemAttachment.Receipt
+        AttachmentCategory.GENERAL -> AttachmentsApi.CategoryUploadItemAttachment.General
+    }
+
+internal fun Attachment.toInfo(): AttachmentInfo =
+    AttachmentInfo(
+        id = id,
+        itemId = itemId,
+        category = category.value,
+        originalFilename = originalFilename,
+        contentType = contentType,
+        sizeBytes = sizeBytes,
+        sha256 = sha256,
+        createdAt = createdAt,
+        hasThumbnail = hasThumbnail,
+    )
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/HhoApiClient.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/HhoApiClient.kt
new file mode 100644
index 0000000..c2d27eb
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/HhoApiClient.kt
@@ -0,0 +1,328 @@
+package dev.hho.android.data.apiclient
+
+import dev.hho.android.data.apiclient.generated.apis.AttachmentsApi
+import dev.hho.android.data.apiclient.generated.apis.AuthApi
+import dev.hho.android.data.apiclient.generated.apis.StatusApi
+import dev.hho.android.data.apiclient.generated.apis.SyncApi
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.Response as GeneratedResponse
+import dev.hho.android.data.apiclient.generated.models.DeviceTokenIssueRequest
+import dev.hho.android.data.apiclient.generated.models.DeviceTokenIssueResponse
+import dev.hho.android.data.apiclient.generated.models.LoginRequest
+import dev.hho.android.data.apiclient.generated.models.LoginResponse
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.StatusResponse
+import dev.hho.android.data.apiclient.generated.models.SyncConflictLogResponse
+import dev.hho.android.data.apiclient.generated.models.SyncPullRequest
+import dev.hho.android.data.apiclient.generated.models.SyncPushResponse
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.NoInstanceUrlConfiguredException
+import dev.hho.android.di.ProbeHttpClient
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.put
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import java.io.File
+import java.io.IOException
+import javax.inject.Inject
+import javax.inject.Singleton
+
+private const val PLACEHOLDER_BASE_URL = "http://placeholder.invalid/api/v1"
+
+private val JSON_MEDIA_TYPE = "application/json; charset=utf-8".toMediaType()
+
+private const val SESSION_COOKIE_NAME = "hho_session"
+
+data class LoginOutcome(
+    val response: LoginResponse,
+    val sessionCookie: String,
+)
+
+@Singleton
+class HhoApiClient
+    @Inject
+    constructor(
+        private val httpClient: OkHttpClient,
+        @ProbeHttpClient private val probeHttpClient: OkHttpClient,
+    ) {
+        private val statusApi = StatusApi(PLACEHOLDER_BASE_URL, httpClient)
+        private val authApi = AuthApi(PLACEHOLDER_BASE_URL, httpClient)
+        private val attachmentsApi = AttachmentsApi(PLACEHOLDER_BASE_URL, httpClient)
+        private val syncApi = SyncApi(PLACEHOLDER_BASE_URL, httpClient)
+
+        suspend fun getStatus(): Result<StatusResponse> = apiCall { statusApi.getStatus() }
+
+        suspend fun probeInstance(candidateBaseUrl: HttpUrl): Result<StatusResponse> =
+            apiCall {
+                val probeBasePath = candidateBaseUrl.newBuilder().addPathSegments("api/v1").build().toString()
+                StatusApi(probeBasePath, probeHttpClient).getStatus()
+            }
+
+        suspend fun login(
+            username: String,
+            password: String,
+        ): Result<LoginOutcome> =
+            apiCall {
+                val httpResponse = authApi.loginWithHttpInfo(LoginRequest(username = username, password = password), null)
+                val body = httpResponse.bodyOrThrow()
+                val sessionCookie = httpResponse.headers.sessionCookieValue()
+                    ?: throw MissingSessionCookieException()
+                LoginOutcome(response = body, sessionCookie = sessionCookie)
+            }
+
+        suspend fun issueDeviceToken(
+            deviceLabel: String,
+            sessionCookie: String,
+        ): Result<DeviceTokenIssueResponse> =
+            apiCall {
+                val cookieScopedClient =
+                    httpClient.newBuilder()
+                        .apply { interceptors().removeAll { it is AuthHeaderInterceptor } }
+                        .addInterceptor { chain ->
+                            chain.proceed(chain.request().newBuilder().header("Cookie", sessionCookie).build())
+                        }
+                        .build()
+                AuthApi(PLACEHOLDER_BASE_URL, cookieScopedClient)
+                    .issueDeviceToken(DeviceTokenIssueRequest(deviceLabel = deviceLabel))
+            }
+
+        suspend fun downloadAttachment(
+            itemId: String,
+            attachmentId: String,
+        ): Result<File> =
+            apiCall {
+                attachmentsApi.downloadItemAttachment(itemID = itemId, attachmentID = attachmentId)
+            }
+
+        suspend fun uploadAttachment(
+            itemId: String,
+            category: AttachmentCategory,
+            file: File,
+        ): Result<AttachmentInfo> =
+            apiCall {
+                attachmentsApi
+                    .uploadItemAttachment(itemID = itemId, category = category.toGenerated(), file = file)
+                    .toInfo()
+            }
+
+        suspend fun listAttachments(itemId: String): Result<List<AttachmentInfo>> =
+            apiCall {
+                attachmentsApi.listItemAttachments(itemID = itemId).attachments.map { it.toInfo() }
+            }
+
+        suspend fun syncPull(
+            deviceId: String,
+            since: Long,
+            limit: Int,
+        ): Result<SyncPullOutcome> =
+            apiCall {
+                val requestJson =
+                    Serializer.kotlinxSerializationJson.encodeToString(
+                        SyncPullRequest(deviceId = deviceId, since = since, limit = limit),
+                    )
+                val request =
+                    Request.Builder()
+                        .url(PLACEHOLDER_BASE_URL.toHttpUrl().newBuilder().addPathSegments("sync/pull").build())
+                        .post(requestJson.toRequestBody(JSON_MEDIA_TYPE))
+                        .header("Accept", "application/json, application/problem+json")
+                        .build()
+
+                httpClient.newCall(request).execute().use { response ->
+                    val bodyString = response.body?.string().orEmpty()
+                    if (!response.isSuccessful) {
+                        throw httpStatusToApiError(response.code, bodyString)
+                    }
+                    SyncChangeDecoder.decodePullResponse(
+                        Serializer.kotlinxSerializationJson.parseToJsonElement(bodyString),
+                    )
+                }
+            }
+
+        suspend fun syncPush(
+            deviceId: String,
+            mutations: List<PushMutation>,
+        ): Result<SyncPushOutcome> =
+            apiCall {
+                val requestJson = encodePushRequest(deviceId, mutations)
+                val request =
+                    Request.Builder()
+                        .url(PLACEHOLDER_BASE_URL.toHttpUrl().newBuilder().addPathSegments("sync/push").build())
+                        .post(requestJson.toRequestBody(JSON_MEDIA_TYPE))
+                        .header("Accept", "application/json, application/problem+json")
+                        .build()
+
+                httpClient.newCall(request).execute().use { response ->
+                    val bodyString = response.body?.string().orEmpty()
+                    if (response.code == 400) {
+                        val detail =
+                            runCatching { Serializer.kotlinxSerializationJson.decodeFromString<Problem>(bodyString).detail }.getOrNull()
+                        if (detail != null && detail.startsWith(SyncPushDetailParser.STRUCTURAL_PREFIX)) {
+                            return@use SyncPushDetailParser.parse(detail)
+                        }
+                    }
+                    if (!response.isSuccessful) {
+                        throw httpStatusToApiError(response.code, bodyString)
+                    }
+                    val decoded = Serializer.kotlinxSerializationJson.decodeFromString<SyncPushResponse>(bodyString)
+                    SyncPushOutcome.Success(decoded.applied, decoded.skipped, decoded.conflicts, decoded.newWatermark)
+                }
+            }
+
+        suspend fun getConflicts(
+            after: String? = null,
+            limit: Int = 50,
+        ): Result<SyncConflictLogResponse> = apiCall { syncApi.listSyncConflicts(limit = limit, after = after) }
+
+        private suspend fun <T> apiCall(block: () -> T): Result<T> =
+            withContext(Dispatchers.IO) {
+                try {
+                    Result.success(block())
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (e: Throwable) {
+                    Result.failure(e.toApiError())
+                }
+            }
+    }
+
+private fun encodePushRequest(
+    deviceId: String,
+    mutations: List<PushMutation>,
+): String {
+    val root: JsonObject =
+        buildJsonObject {
+            put("device_id", deviceId)
+            put(
+                "mutations",
+                JsonArray(
+                    mutations.map { m ->
+                        buildJsonObject {
+                            put("mutation_id", m.mutationId)
+                            put("entity_type", m.entityType)
+                            put("entity_id", m.entityId)
+                            put("base_version", m.baseVersion)
+                            put("fields", JsonObject(m.fields))
+                            m.op?.let { put("op", JsonPrimitive(it)) }
+                        }
+                    },
+                ),
+            )
+        }
+    return root.toString()
+}
+
+private fun Throwable.toApiError(): ApiError =
+    when (this) {
+        is ApiError -> this
+        is NoInstanceUrlConfiguredException -> ApiError.NoInstanceConfigured(this)
+        is ClientException -> toApiError()
+        is ServerException -> ApiError.Server(statusCode, problemDetailOf(response), this)
+        is MissingSessionCookieException -> ApiError.UnexpectedPayload(message ?: toString(), this)
+        is UnknownSyncEntityTypeException -> ApiError.UnexpectedPayload(message ?: toString(), this)
+        is MalformedSyncPullResponseException -> ApiError.UnexpectedPayload(message ?: toString(), this)
+        is SerializationException -> ApiError.UnexpectedPayload(message ?: "malformed response body", this)
+        is UnsupportedOperationException -> ApiError.UnexpectedPayload(message ?: "unsupported response content type", this)
+        is IOException -> ApiError.Network(this)
+        else -> ApiError.Unknown(this)
+    }
+
+private fun ClientException.toApiError(): ApiError {
+    if (statusCode == 426) {
+        upgradeRequiredProblemOf(response)?.let { return ApiError.UpgradeRequired(it.minimumVersion, it.detail, this) }
+    }
+    val detail = problemDetailOf(response)
+    return when (statusCode) {
+        401 -> ApiError.Unauthorized(this)
+        404 -> ApiError.NotFound(this)
+        413 -> ApiError.PayloadTooLarge(detail, this)
+        409 -> ApiError.Conflict(detail, this)
+        else -> ApiError.Validation(statusCode, detail, this)
+    }
+}
+
+private fun httpStatusToApiError(
+    statusCode: Int,
+    rawBody: String,
+): ApiError {
+    if (statusCode == 426) {
+        runCatching { Serializer.kotlinxSerializationJson.decodeFromString<UpgradeRequiredProblem>(rawBody) }
+            .getOrNull()
+            ?.let { return ApiError.UpgradeRequired(it.minimumVersion, it.detail) }
+    }
+    val detail = runCatching { Serializer.kotlinxSerializationJson.decodeFromString<Problem>(rawBody).detail }.getOrNull()
+    return when (statusCode) {
+        401 -> ApiError.Unauthorized()
+        404 -> ApiError.NotFound()
+        413 -> ApiError.PayloadTooLarge(detail)
+        409 -> ApiError.Conflict(detail)
+        in 500..599 -> ApiError.Server(statusCode, detail)
+        else -> ApiError.Validation(statusCode, detail)
+    }
+}
+
+private fun upgradeRequiredProblemOf(response: GeneratedResponse?): UpgradeRequiredProblem? {
+    val rawBody =
+        when (response) {
+            is ClientError<*> -> response.body as? String
+            is ServerError<*> -> response.body as? String
+            else -> null
+        } ?: return null
+    return runCatching { Serializer.kotlinxSerializationJson.decodeFromString<UpgradeRequiredProblem>(rawBody) }.getOrNull()
+}
+
+private fun problemDetailOf(response: GeneratedResponse?): String? {
+    val rawBody =
+        when (response) {
+            is ClientError<*> -> response.body as? String
+            is ServerError<*> -> response.body as? String
+            else -> null
+        } ?: return null
+    return runCatching { Serializer.kotlinxSerializationJson.decodeFromString<Problem>(rawBody).detail }.getOrNull()
+}
+
+@Suppress("UNCHECKED_CAST")
+private fun <T : Any> ApiResponse<T?>.bodyOrThrow(): T =
+    when (responseType) {
+        ResponseType.Success -> (this as Success<*>).data as T
+        ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+        ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+        ResponseType.ClientError -> {
+            val error = this as ClientError<*>
+            throw ClientException("Client error : ${error.statusCode} ${error.message.orEmpty()}", error.statusCode, this)
+        }
+        ResponseType.ServerError -> {
+            val error = this as ServerError<*>
+            throw ServerException("Server error : ${error.statusCode} ${error.message.orEmpty()} ${error.body}", error.statusCode, this)
+        }
+    }
+
+private fun Map<String, List<String>>.sessionCookieValue(): String? =
+    entries
+        .firstOrNull { it.key.equals("Set-Cookie", ignoreCase = true) }
+        ?.value
+        ?.map { it.substringBefore(';') }
+        ?.firstOrNull { it.startsWith("$SESSION_COOKIE_NAME=") }
+
+private class MissingSessionCookieException :
+    Exception("Login succeeded but the response carried no $SESSION_COOKIE_NAME session cookie")
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/SyncChange.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/SyncChange.kt
new file mode 100644
index 0000000..af6622a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/SyncChange.kt
@@ -0,0 +1,213 @@
+package dev.hho.android.data.apiclient
+
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+import dev.hho.android.data.apiclient.generated.models.Attachment
+import dev.hho.android.data.apiclient.generated.models.Identification
+import dev.hho.android.data.apiclient.generated.models.Item
+import dev.hho.android.data.apiclient.generated.models.ItemCustomField
+import dev.hho.android.data.apiclient.generated.models.ItemLabelAssignment
+import dev.hho.android.data.apiclient.generated.models.Label
+import dev.hho.android.data.apiclient.generated.models.Location
+import dev.hho.android.data.apiclient.generated.models.PurchaseBlock
+import dev.hho.android.data.apiclient.generated.models.SaleBlock
+import dev.hho.android.data.apiclient.generated.models.StockAdjustment
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryAttachment
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryItem
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryItemCustomField
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryItemIdentification
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryItemLabel
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryLabel
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryLocation
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryPurchasedFromBlock
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntrySoldToBlock
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryStockAdjustment
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryWarrantyBlock
+import dev.hho.android.data.apiclient.generated.models.SyncTombstoneEntry
+import dev.hho.android.data.apiclient.generated.models.WarrantyBlock
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.decodeFromJsonElement
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.longOrNull
+
+sealed interface SyncChange {
+    val id: String
+
+    val groupChangeSeq: Long
+
+    data class ItemChange(override val id: String, override val groupChangeSeq: Long, val data: Item) : SyncChange
+
+    data class WarrantyBlockChange(
+        override val id: String,
+        override val groupChangeSeq: Long,
+        val data: WarrantyBlock,
+    ) : SyncChange
+
+    data class SoldToBlockChange(
+        override val id: String,
+        override val groupChangeSeq: Long,
+        val data: SaleBlock,
+    ) : SyncChange
+
+    data class PurchasedFromBlockChange(
+        override val id: String,
+        override val groupChangeSeq: Long,
+        val data: PurchaseBlock,
+    ) : SyncChange
+
+    data class ItemIdentificationChange(
+        override val id: String,
+        override val groupChangeSeq: Long,
+        val data: Identification,
+    ) : SyncChange
+
+    data class ItemCustomFieldChange(
+        override val id: String,
+        override val groupChangeSeq: Long,
+        val data: ItemCustomField,
+    ) : SyncChange
+
+    data class StockAdjustmentChange(
+        override val id: String,
+        override val groupChangeSeq: Long,
+        val data: StockAdjustment,
+    ) : SyncChange
+
+    data class LocationChange(
+        override val id: String,
+        override val groupChangeSeq: Long,
+        val data: Location,
+    ) : SyncChange
+
+    data class LabelChange(override val id: String, override val groupChangeSeq: Long, val data: Label) : SyncChange
+
+    data class ItemLabelChange(
+        override val id: String,
+        override val groupChangeSeq: Long,
+        val data: ItemLabelAssignment,
+    ) : SyncChange
+
+    data class AttachmentChange(
+        override val id: String,
+        override val groupChangeSeq: Long,
+        val data: Attachment,
+    ) : SyncChange
+}
+
+sealed interface SyncPullOutcome {
+    data class Page(
+        val changes: List<SyncChange>,
+        val tombstones: List<SyncTombstoneEntry>,
+        val nextWatermark: Long,
+        val hasMore: Boolean,
+    ) : SyncPullOutcome
+
+    data object CursorTooOld : SyncPullOutcome
+}
+
+class UnknownSyncEntityTypeException(val rawEntityType: String?) :
+    IllegalStateException("Unknown sync entity_type: $rawEntityType — client/server drift (A7 closed set)")
+
+class MalformedSyncPullResponseException(detail: String, cause: Throwable? = null) :
+    IllegalStateException("Malformed /sync/pull response: $detail", cause)
+
+internal object SyncChangeDecoder {
+
+    private val json = Serializer.kotlinxSerializationJson
+
+    fun decodePullResponse(root: JsonElement): SyncPullOutcome {
+        val obj =
+            root as? JsonObject
+                ?: throw MalformedSyncPullResponseException("expected a JSON object, got $root")
+
+        if (obj["cursor_too_old"]?.jsonPrimitive?.booleanOrNull == true) {
+            return SyncPullOutcome.CursorTooOld
+        }
+
+        try {
+            val changesJson =
+                obj["changes"] as? JsonArray
+                    ?: throw MalformedSyncPullResponseException("missing or non-array 'changes'")
+            val tombstonesJson =
+                obj["tombstones"] as? JsonArray
+                    ?: throw MalformedSyncPullResponseException("missing or non-array 'tombstones'")
+            val nextWatermark =
+                obj["next_watermark"]?.jsonPrimitive?.longOrNull
+                    ?: throw MalformedSyncPullResponseException("missing or non-numeric 'next_watermark'")
+            val hasMore =
+                obj["has_more"]?.jsonPrimitive?.booleanOrNull
+                    ?: throw MalformedSyncPullResponseException("missing or non-boolean 'has_more'")
+
+            return SyncPullOutcome.Page(
+                changes = changesJson.map { decodeChange(it) },
+                tombstones = tombstonesJson.map { json.decodeFromJsonElement<SyncTombstoneEntry>(it) },
+                nextWatermark = nextWatermark,
+                hasMore = hasMore,
+            )
+        } catch (e: SerializationException) {
+            throw MalformedSyncPullResponseException(e.message ?: "decode failure", e)
+        }
+    }
+
+    fun decodeChange(element: JsonElement): SyncChange {
+        val entityType =
+            (element as? JsonObject)?.get("entity_type")?.jsonPrimitive?.contentOrNull
+                ?: throw UnknownSyncEntityTypeException(rawEntityType = null)
+
+        return try {
+            when (entityType) {
+                "item" ->
+                    json.decodeFromJsonElement<SyncChangeEntryItem>(element).let {
+                        SyncChange.ItemChange(it.id, it.groupChangeSeq, it.data)
+                    }
+                "warranty_block" ->
+                    json.decodeFromJsonElement<SyncChangeEntryWarrantyBlock>(element).let {
+                        SyncChange.WarrantyBlockChange(it.id, it.groupChangeSeq, it.data)
+                    }
+                "sold_to_block" ->
+                    json.decodeFromJsonElement<SyncChangeEntrySoldToBlock>(element).let {
+                        SyncChange.SoldToBlockChange(it.id, it.groupChangeSeq, it.data)
+                    }
+                "purchased_from_block" ->
+                    json.decodeFromJsonElement<SyncChangeEntryPurchasedFromBlock>(element).let {
+                        SyncChange.PurchasedFromBlockChange(it.id, it.groupChangeSeq, it.data)
+                    }
+                "item_identification" ->
+                    json.decodeFromJsonElement<SyncChangeEntryItemIdentification>(element).let {
+                        SyncChange.ItemIdentificationChange(it.id, it.groupChangeSeq, it.data)
+                    }
+                "item_custom_field" ->
+                    json.decodeFromJsonElement<SyncChangeEntryItemCustomField>(element).let {
+                        SyncChange.ItemCustomFieldChange(it.id, it.groupChangeSeq, it.data)
+                    }
+                "stock_adjustment" ->
+                    json.decodeFromJsonElement<SyncChangeEntryStockAdjustment>(element).let {
+                        SyncChange.StockAdjustmentChange(it.id, it.groupChangeSeq, it.data)
+                    }
+                "location" ->
+                    json.decodeFromJsonElement<SyncChangeEntryLocation>(element).let {
+                        SyncChange.LocationChange(it.id, it.groupChangeSeq, it.data)
+                    }
+                "label" ->
+                    json.decodeFromJsonElement<SyncChangeEntryLabel>(element).let {
+                        SyncChange.LabelChange(it.id, it.groupChangeSeq, it.data)
+                    }
+                "item_label" ->
+                    json.decodeFromJsonElement<SyncChangeEntryItemLabel>(element).let {
+                        SyncChange.ItemLabelChange(it.id, it.groupChangeSeq, it.data)
+                    }
+                "attachment" ->
+                    json.decodeFromJsonElement<SyncChangeEntryAttachment>(element).let {
+                        SyncChange.AttachmentChange(it.id, it.groupChangeSeq, it.data)
+                    }
+                else -> throw UnknownSyncEntityTypeException(entityType)
+            }
+        } catch (e: SerializationException) {
+            throw MalformedSyncPullResponseException("entity_type=$entityType: ${e.message}", e)
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/SyncPushOutcome.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/SyncPushOutcome.kt
new file mode 100644
index 0000000..4196166
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/SyncPushOutcome.kt
@@ -0,0 +1,47 @@
+package dev.hho.android.data.apiclient
+
+import dev.hho.android.data.apiclient.generated.models.SyncAppliedEntry
+import dev.hho.android.data.apiclient.generated.models.SyncConflictEntry
+import dev.hho.android.data.apiclient.generated.models.SyncSkippedEntry
+import kotlinx.serialization.json.JsonElement
+
+data class PushMutation(
+    val mutationId: String,
+    val entityType: String,
+    val entityId: String,
+    val baseVersion: Long,
+    val fields: Map<String, JsonElement>,
+    val op: String? = null,
+)
+
+sealed interface SyncPushOutcome {
+    data class Success(
+        val applied: List<SyncAppliedEntry>,
+        val skipped: List<SyncSkippedEntry>,
+        val conflicts: List<SyncConflictEntry>,
+        val newWatermark: Long,
+    ) : SyncPushOutcome
+
+    data class StructuralRejection(
+        val index: Int?,
+        val mutationId: String?,
+        val detail: String,
+    ) : SyncPushOutcome
+}
+
+internal object SyncPushDetailParser {
+    const val STRUCTURAL_PREFIX = "mutations["
+
+    private val pattern = Regex("""^mutations\[(\d+)] \(mutation_id="((?:[^"\\]|\\.)*)"\): .*""", RegexOption.DOT_MATCHES_ALL)
+
+    fun parse(detail: String): SyncPushOutcome.StructuralRejection {
+        val match = pattern.matchEntire(detail)
+        val index = match?.groupValues?.get(1)?.toIntOrNull()
+        val id = match?.groupValues?.get(2)?.replace(Regex("""\\(.)"""), "$1")
+        return if (index == null || id == null) {
+            SyncPushOutcome.StructuralRejection(null, null, detail)
+        } else {
+            SyncPushOutcome.StructuralRejection(index, id, detail)
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/AttachmentsApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/AttachmentsApi.kt
new file mode 100644
index 0000000..97eba6b
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/AttachmentsApi.kt
@@ -0,0 +1,300 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.Attachment
+import dev.hho.android.data.apiclient.generated.models.AttachmentListResponse
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class AttachmentsApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun deleteItemAttachment(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = deleteItemAttachmentWithHttpInfo(itemID = itemID, attachmentID = attachmentID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun deleteItemAttachmentWithHttpInfo(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = deleteItemAttachmentRequestConfig(itemID = itemID, attachmentID = attachmentID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun deleteItemAttachmentRequestConfig(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/items/{itemID}/attachments/{attachmentID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"attachmentID"+"}", encodeURIComponent(attachmentID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun downloadItemAttachment(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : java.io.File {
+        val localVarResponse = downloadItemAttachmentWithHttpInfo(itemID = itemID, attachmentID = attachmentID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as java.io.File
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun downloadItemAttachmentWithHttpInfo(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<java.io.File?> {
+        val localVariableConfig = downloadItemAttachmentRequestConfig(itemID = itemID, attachmentID = attachmentID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, java.io.File>(
+            localVariableConfig
+        )
+    }
+
+    fun downloadItemAttachmentRequestConfig(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/octet-stream, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/attachments/{attachmentID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"attachmentID"+"}", encodeURIComponent(attachmentID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun downloadItemAttachmentThumbnail(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : java.io.File {
+        val localVarResponse = downloadItemAttachmentThumbnailWithHttpInfo(itemID = itemID, attachmentID = attachmentID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as java.io.File
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun downloadItemAttachmentThumbnailWithHttpInfo(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<java.io.File?> {
+        val localVariableConfig = downloadItemAttachmentThumbnailRequestConfig(itemID = itemID, attachmentID = attachmentID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, java.io.File>(
+            localVariableConfig
+        )
+    }
+
+    fun downloadItemAttachmentThumbnailRequestConfig(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/attachments/{attachmentID}/thumbnail".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"attachmentID"+"}", encodeURIComponent(attachmentID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listItemAttachments(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : AttachmentListResponse {
+        val localVarResponse = listItemAttachmentsWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as AttachmentListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listItemAttachmentsWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<AttachmentListResponse?> {
+        val localVariableConfig = listItemAttachmentsRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, AttachmentListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listItemAttachmentsRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/attachments".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+     enum class CategoryUploadItemAttachment(val value: kotlin.String) {
+         @SerialName(value = "image") Image("image"),
+         @SerialName(value = "manual") Manual("manual"),
+         @SerialName(value = "warranty") Warranty("warranty"),
+         @SerialName(value = "receipt") Receipt("receipt"),
+         @SerialName(value = "general") General("general");
+
+        override fun toString(): kotlin.String = "$value"
+     }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun uploadItemAttachment(itemID: kotlin.String, category: CategoryUploadItemAttachment, file: java.io.File, xHHOClientVersion: kotlin.String? = null) : Attachment {
+        val localVarResponse = uploadItemAttachmentWithHttpInfo(itemID = itemID, category = category, file = file, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Attachment
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun uploadItemAttachmentWithHttpInfo(itemID: kotlin.String, category: CategoryUploadItemAttachment, file: java.io.File, xHHOClientVersion: kotlin.String?) : ApiResponse<Attachment?> {
+        val localVariableConfig = uploadItemAttachmentRequestConfig(itemID = itemID, category = category, file = file, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Map<String, PartConfig<*>>, Attachment>(
+            localVariableConfig
+        )
+    }
+
+    fun uploadItemAttachmentRequestConfig(itemID: kotlin.String, category: CategoryUploadItemAttachment, file: java.io.File, xHHOClientVersion: kotlin.String?) : RequestConfig<Map<String, PartConfig<*>>> {
+        val localVariableBody = mapOf(
+            "category" to PartConfig(body = category.value, headers = mutableMapOf()),
+            "file" to PartConfig(body = file, headers = mutableMapOf("Content-Type" to "*/*")),)
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf("Content-Type" to "multipart/form-data")
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/items/{itemID}/attachments".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/AuthApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/AuthApi.kt
new file mode 100644
index 0000000..2bfe2a5
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/AuthApi.kt
@@ -0,0 +1,481 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.DeviceTokenIssueRequest
+import dev.hho.android.data.apiclient.generated.models.DeviceTokenIssueResponse
+import dev.hho.android.data.apiclient.generated.models.DeviceTokenListResponse
+import dev.hho.android.data.apiclient.generated.models.LoginRequest
+import dev.hho.android.data.apiclient.generated.models.LoginResponse
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.RegisterRequest
+import dev.hho.android.data.apiclient.generated.models.RegisterResponse
+import dev.hho.android.data.apiclient.generated.models.SessionListResponse
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class AuthApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getCurrentUser(xHHOClientVersion: kotlin.String? = null) : LoginResponse {
+        val localVarResponse = getCurrentUserWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as LoginResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getCurrentUserWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<LoginResponse?> {
+        val localVariableConfig = getCurrentUserRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, LoginResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun getCurrentUserRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/auth/me",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun issueDeviceToken(deviceTokenIssueRequest: DeviceTokenIssueRequest, xHHOClientVersion: kotlin.String? = null) : DeviceTokenIssueResponse {
+        val localVarResponse = issueDeviceTokenWithHttpInfo(deviceTokenIssueRequest = deviceTokenIssueRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as DeviceTokenIssueResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun issueDeviceTokenWithHttpInfo(deviceTokenIssueRequest: DeviceTokenIssueRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<DeviceTokenIssueResponse?> {
+        val localVariableConfig = issueDeviceTokenRequestConfig(deviceTokenIssueRequest = deviceTokenIssueRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<DeviceTokenIssueRequest, DeviceTokenIssueResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun issueDeviceTokenRequestConfig(deviceTokenIssueRequest: DeviceTokenIssueRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<DeviceTokenIssueRequest> {
+        val localVariableBody = deviceTokenIssueRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/auth/device-tokens",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listDeviceTokens(xHHOClientVersion: kotlin.String? = null) : DeviceTokenListResponse {
+        val localVarResponse = listDeviceTokensWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as DeviceTokenListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listDeviceTokensWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<DeviceTokenListResponse?> {
+        val localVariableConfig = listDeviceTokensRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, DeviceTokenListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listDeviceTokensRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/auth/device-tokens",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listSessions(xHHOClientVersion: kotlin.String? = null) : SessionListResponse {
+        val localVarResponse = listSessionsWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as SessionListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listSessionsWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<SessionListResponse?> {
+        val localVariableConfig = listSessionsRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, SessionListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listSessionsRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/auth/sessions",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun login(loginRequest: LoginRequest, xHHOClientVersion: kotlin.String? = null) : LoginResponse {
+        val localVarResponse = loginWithHttpInfo(loginRequest = loginRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as LoginResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun loginWithHttpInfo(loginRequest: LoginRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<LoginResponse?> {
+        val localVariableConfig = loginRequestConfig(loginRequest = loginRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<LoginRequest, LoginResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun loginRequestConfig(loginRequest: LoginRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<LoginRequest> {
+        val localVariableBody = loginRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/auth/login",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = false,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun logout(xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = logoutWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun logoutWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = logoutRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun logoutRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/auth/logout",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun registerFirstRun(registerRequest: RegisterRequest, xHHOClientVersion: kotlin.String? = null) : RegisterResponse {
+        val localVarResponse = registerFirstRunWithHttpInfo(registerRequest = registerRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as RegisterResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun registerFirstRunWithHttpInfo(registerRequest: RegisterRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<RegisterResponse?> {
+        val localVariableConfig = registerFirstRunRequestConfig(registerRequest = registerRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<RegisterRequest, RegisterResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun registerFirstRunRequestConfig(registerRequest: RegisterRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<RegisterRequest> {
+        val localVariableBody = registerRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/auth/register",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = false,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun revokeDeviceToken(deviceTokenID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = revokeDeviceTokenWithHttpInfo(deviceTokenID = deviceTokenID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun revokeDeviceTokenWithHttpInfo(deviceTokenID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = revokeDeviceTokenRequestConfig(deviceTokenID = deviceTokenID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun revokeDeviceTokenRequestConfig(deviceTokenID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/auth/device-tokens/{deviceTokenID}".replace("{"+"deviceTokenID"+"}", encodeURIComponent(deviceTokenID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun revokeSession(sessionID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = revokeSessionWithHttpInfo(sessionID = sessionID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun revokeSessionWithHttpInfo(sessionID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = revokeSessionRequestConfig(sessionID = sessionID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun revokeSessionRequestConfig(sessionID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/auth/sessions/{sessionID}".replace("{"+"sessionID"+"}", encodeURIComponent(sessionID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/BackupApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/BackupApi.kt
new file mode 100644
index 0000000..cd9cc35
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/BackupApi.kt
@@ -0,0 +1,100 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class BackupApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getBackup(xHHOClientVersion: kotlin.String? = null) : java.io.File {
+        val localVarResponse = getBackupWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as java.io.File
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getBackupWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<java.io.File?> {
+        val localVariableConfig = getBackupRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, java.io.File>(
+            localVariableConfig
+        )
+    }
+
+    fun getBackupRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/backup",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/CustomFieldDefsApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/CustomFieldDefsApi.kt
new file mode 100644
index 0000000..bac59e8
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/CustomFieldDefsApi.kt
@@ -0,0 +1,245 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.CustomFieldDef
+import dev.hho.android.data.apiclient.generated.models.CustomFieldDefCreateRequest
+import dev.hho.android.data.apiclient.generated.models.CustomFieldDefListResponse
+import dev.hho.android.data.apiclient.generated.models.CustomFieldDefUpdateRequest
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class CustomFieldDefsApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun createCustomFieldDef(customFieldDefCreateRequest: CustomFieldDefCreateRequest, xHHOClientVersion: kotlin.String? = null) : CustomFieldDef {
+        val localVarResponse = createCustomFieldDefWithHttpInfo(customFieldDefCreateRequest = customFieldDefCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as CustomFieldDef
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun createCustomFieldDefWithHttpInfo(customFieldDefCreateRequest: CustomFieldDefCreateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<CustomFieldDef?> {
+        val localVariableConfig = createCustomFieldDefRequestConfig(customFieldDefCreateRequest = customFieldDefCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<CustomFieldDefCreateRequest, CustomFieldDef>(
+            localVariableConfig
+        )
+    }
+
+    fun createCustomFieldDefRequestConfig(customFieldDefCreateRequest: CustomFieldDefCreateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<CustomFieldDefCreateRequest> {
+        val localVariableBody = customFieldDefCreateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/custom-field-defs",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun deleteCustomFieldDef(fieldDefID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = deleteCustomFieldDefWithHttpInfo(fieldDefID = fieldDefID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun deleteCustomFieldDefWithHttpInfo(fieldDefID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = deleteCustomFieldDefRequestConfig(fieldDefID = fieldDefID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun deleteCustomFieldDefRequestConfig(fieldDefID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/custom-field-defs/{fieldDefID}".replace("{"+"fieldDefID"+"}", encodeURIComponent(fieldDefID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listCustomFieldDefs(xHHOClientVersion: kotlin.String? = null) : CustomFieldDefListResponse {
+        val localVarResponse = listCustomFieldDefsWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as CustomFieldDefListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listCustomFieldDefsWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<CustomFieldDefListResponse?> {
+        val localVariableConfig = listCustomFieldDefsRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, CustomFieldDefListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listCustomFieldDefsRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/custom-field-defs",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun updateCustomFieldDef(fieldDefID: kotlin.String, customFieldDefUpdateRequest: CustomFieldDefUpdateRequest, xHHOClientVersion: kotlin.String? = null) : CustomFieldDef {
+        val localVarResponse = updateCustomFieldDefWithHttpInfo(fieldDefID = fieldDefID, customFieldDefUpdateRequest = customFieldDefUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as CustomFieldDef
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun updateCustomFieldDefWithHttpInfo(fieldDefID: kotlin.String, customFieldDefUpdateRequest: CustomFieldDefUpdateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<CustomFieldDef?> {
+        val localVariableConfig = updateCustomFieldDefRequestConfig(fieldDefID = fieldDefID, customFieldDefUpdateRequest = customFieldDefUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<CustomFieldDefUpdateRequest, CustomFieldDef>(
+            localVariableConfig
+        )
+    }
+
+    fun updateCustomFieldDefRequestConfig(fieldDefID: kotlin.String, customFieldDefUpdateRequest: CustomFieldDefUpdateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<CustomFieldDefUpdateRequest> {
+        val localVariableBody = customFieldDefUpdateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.PUT,
+            path = "/custom-field-defs/{fieldDefID}".replace("{"+"fieldDefID"+"}", encodeURIComponent(fieldDefID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/ExportApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/ExportApi.kt
new file mode 100644
index 0000000..a4924c1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/ExportApi.kt
@@ -0,0 +1,158 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class ExportApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun exportBoM(locationId: kotlin.collections.List<kotlin.String>? = null, labelId: kotlin.collections.List<kotlin.String>? = null, itemId: kotlin.collections.List<kotlin.String>? = null, xHHOClientVersion: kotlin.String? = null) : java.io.File {
+        val localVarResponse = exportBoMWithHttpInfo(locationId = locationId, labelId = labelId, itemId = itemId, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as java.io.File
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun exportBoMWithHttpInfo(locationId: kotlin.collections.List<kotlin.String>?, labelId: kotlin.collections.List<kotlin.String>?, itemId: kotlin.collections.List<kotlin.String>?, xHHOClientVersion: kotlin.String?) : ApiResponse<java.io.File?> {
+        val localVariableConfig = exportBoMRequestConfig(locationId = locationId, labelId = labelId, itemId = itemId, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, java.io.File>(
+            localVariableConfig
+        )
+    }
+
+    fun exportBoMRequestConfig(locationId: kotlin.collections.List<kotlin.String>?, labelId: kotlin.collections.List<kotlin.String>?, itemId: kotlin.collections.List<kotlin.String>?, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf<kotlin.String, kotlin.collections.List<kotlin.String>>()
+            .apply {
+                if (locationId != null) {
+                    put("location_id", toMultiValue(locationId.toList(), "multi"))
+                }
+                if (labelId != null) {
+                    put("label_id", toMultiValue(labelId.toList(), "multi"))
+                }
+                if (itemId != null) {
+                    put("item_id", toMultiValue(itemId.toList(), "multi"))
+                }
+            }
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/export/bom",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun exportItemsCSV(xHHOClientVersion: kotlin.String? = null) : java.io.File {
+        val localVarResponse = exportItemsCSVWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as java.io.File
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun exportItemsCSVWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<java.io.File?> {
+        val localVariableConfig = exportItemsCSVRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, java.io.File>(
+            localVariableConfig
+        )
+    }
+
+    fun exportItemsCSVRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/export/items.csv",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/GroupsApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/GroupsApi.kt
new file mode 100644
index 0000000..f5895d8
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/GroupsApi.kt
@@ -0,0 +1,198 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.GroupMembersResponse
+import dev.hho.android.data.apiclient.generated.models.GroupVisibility
+import dev.hho.android.data.apiclient.generated.models.GroupVisibilityUpdateRequest
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class GroupsApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getGroupDetailVisibility(xHHOClientVersion: kotlin.String? = null) : GroupVisibility {
+        val localVarResponse = getGroupDetailVisibilityWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as GroupVisibility
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getGroupDetailVisibilityWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<GroupVisibility?> {
+        val localVariableConfig = getGroupDetailVisibilityRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, GroupVisibility>(
+            localVariableConfig
+        )
+    }
+
+    fun getGroupDetailVisibilityRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/groups/detail-visibility",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listGroupMembers(xHHOClientVersion: kotlin.String? = null) : GroupMembersResponse {
+        val localVarResponse = listGroupMembersWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as GroupMembersResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listGroupMembersWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<GroupMembersResponse?> {
+        val localVariableConfig = listGroupMembersRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, GroupMembersResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listGroupMembersRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/groups/members",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun updateGroupDetailVisibility(groupVisibilityUpdateRequest: GroupVisibilityUpdateRequest, xHHOClientVersion: kotlin.String? = null) : GroupVisibility {
+        val localVarResponse = updateGroupDetailVisibilityWithHttpInfo(groupVisibilityUpdateRequest = groupVisibilityUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as GroupVisibility
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun updateGroupDetailVisibilityWithHttpInfo(groupVisibilityUpdateRequest: GroupVisibilityUpdateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<GroupVisibility?> {
+        val localVariableConfig = updateGroupDetailVisibilityRequestConfig(groupVisibilityUpdateRequest = groupVisibilityUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<GroupVisibilityUpdateRequest, GroupVisibility>(
+            localVariableConfig
+        )
+    }
+
+    fun updateGroupDetailVisibilityRequestConfig(groupVisibilityUpdateRequest: GroupVisibilityUpdateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<GroupVisibilityUpdateRequest> {
+        val localVariableBody = groupVisibilityUpdateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.PUT,
+            path = "/groups/detail-visibility",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/ImportApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/ImportApi.kt
new file mode 100644
index 0000000..c81bd30
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/ImportApi.kt
@@ -0,0 +1,198 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.ImportCommitRejectedResponse
+import dev.hho.android.data.apiclient.generated.models.ImportCommitResponse
+import dev.hho.android.data.apiclient.generated.models.ImportPreviewResponse
+import dev.hho.android.data.apiclient.generated.models.ImportUploadResponse
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class ImportApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getImportPreview(importID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : ImportPreviewResponse {
+        val localVarResponse = getImportPreviewWithHttpInfo(importID = importID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as ImportPreviewResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getImportPreviewWithHttpInfo(importID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<ImportPreviewResponse?> {
+        val localVariableConfig = getImportPreviewRequestConfig(importID = importID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, ImportPreviewResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun getImportPreviewRequestConfig(importID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/import/{importID}/preview".replace("{"+"importID"+"}", encodeURIComponent(importID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun importNativeUpload(body: java.io.File, xHHOClientVersion: kotlin.String? = null) : ImportUploadResponse {
+        val localVarResponse = importNativeUploadWithHttpInfo(body = body, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as ImportUploadResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun importNativeUploadWithHttpInfo(body: java.io.File, xHHOClientVersion: kotlin.String?) : ApiResponse<ImportUploadResponse?> {
+        val localVariableConfig = importNativeUploadRequestConfig(body = body, xHHOClientVersion = xHHOClientVersion)
+
+        return request<java.io.File, ImportUploadResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun importNativeUploadRequestConfig(body: java.io.File, xHHOClientVersion: kotlin.String?) : RequestConfig<java.io.File> {
+        val localVariableBody = body
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/import/native/upload",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun postImportCommit(importID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : ImportCommitResponse {
+        val localVarResponse = postImportCommitWithHttpInfo(importID = importID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as ImportCommitResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun postImportCommitWithHttpInfo(importID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<ImportCommitResponse?> {
+        val localVariableConfig = postImportCommitRequestConfig(importID = importID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, ImportCommitResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun postImportCommitRequestConfig(importID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/import/{importID}/commit".replace("{"+"importID"+"}", encodeURIComponent(importID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/InvitesApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/InvitesApi.kt
new file mode 100644
index 0000000..1f51037
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/InvitesApi.kt
@@ -0,0 +1,244 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.InviteCreateResponse
+import dev.hho.android.data.apiclient.generated.models.InviteListResponse
+import dev.hho.android.data.apiclient.generated.models.InviteRedeemRequest
+import dev.hho.android.data.apiclient.generated.models.InviteRedeemResponse
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class InvitesApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun createInvite(xHHOClientVersion: kotlin.String? = null) : InviteCreateResponse {
+        val localVarResponse = createInviteWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as InviteCreateResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun createInviteWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<InviteCreateResponse?> {
+        val localVariableConfig = createInviteRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, InviteCreateResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun createInviteRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/invites",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listInvites(xHHOClientVersion: kotlin.String? = null) : InviteListResponse {
+        val localVarResponse = listInvitesWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as InviteListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listInvitesWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<InviteListResponse?> {
+        val localVariableConfig = listInvitesRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, InviteListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listInvitesRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/invites",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun redeemInvite(inviteRedeemRequest: InviteRedeemRequest, xHHOClientVersion: kotlin.String? = null) : InviteRedeemResponse {
+        val localVarResponse = redeemInviteWithHttpInfo(inviteRedeemRequest = inviteRedeemRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as InviteRedeemResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun redeemInviteWithHttpInfo(inviteRedeemRequest: InviteRedeemRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<InviteRedeemResponse?> {
+        val localVariableConfig = redeemInviteRequestConfig(inviteRedeemRequest = inviteRedeemRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<InviteRedeemRequest, InviteRedeemResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun redeemInviteRequestConfig(inviteRedeemRequest: InviteRedeemRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<InviteRedeemRequest> {
+        val localVariableBody = inviteRedeemRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/invites/redeem",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = false,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun revokeInvite(inviteID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = revokeInviteWithHttpInfo(inviteID = inviteID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun revokeInviteWithHttpInfo(inviteID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = revokeInviteRequestConfig(inviteID = inviteID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun revokeInviteRequestConfig(inviteID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/invites/{inviteID}".replace("{"+"inviteID"+"}", encodeURIComponent(inviteID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/ItemsApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/ItemsApi.kt
new file mode 100644
index 0000000..fa53e78
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/ItemsApi.kt
@@ -0,0 +1,1782 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.Attachment
+import dev.hho.android.data.apiclient.generated.models.AttachmentListResponse
+import dev.hho.android.data.apiclient.generated.models.Identification
+import dev.hho.android.data.apiclient.generated.models.IdentificationCreateRequest
+import dev.hho.android.data.apiclient.generated.models.IdentificationListResponse
+import dev.hho.android.data.apiclient.generated.models.IdentificationUpdateRequest
+import dev.hho.android.data.apiclient.generated.models.Item
+import dev.hho.android.data.apiclient.generated.models.ItemCustomField
+import dev.hho.android.data.apiclient.generated.models.ItemCustomFieldCreateRequest
+import dev.hho.android.data.apiclient.generated.models.ItemCustomFieldListResponse
+import dev.hho.android.data.apiclient.generated.models.ItemCustomFieldUpdateRequest
+import dev.hho.android.data.apiclient.generated.models.ItemListResponse
+import dev.hho.android.data.apiclient.generated.models.ItemUpdateRequest
+import dev.hho.android.data.apiclient.generated.models.LabelListResponse
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.PurchaseBlock
+import dev.hho.android.data.apiclient.generated.models.PurchaseCreateRequest
+import dev.hho.android.data.apiclient.generated.models.PurchaseUpdateRequest
+import dev.hho.android.data.apiclient.generated.models.SaleBlock
+import dev.hho.android.data.apiclient.generated.models.SaleCreateRequest
+import dev.hho.android.data.apiclient.generated.models.SaleUpdateRequest
+import dev.hho.android.data.apiclient.generated.models.StockAdjustment
+import dev.hho.android.data.apiclient.generated.models.StockAdjustmentCreateRequest
+import dev.hho.android.data.apiclient.generated.models.StockAdjustmentListResponse
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+import dev.hho.android.data.apiclient.generated.models.WarrantyBlock
+import dev.hho.android.data.apiclient.generated.models.WarrantyCreateRequest
+import dev.hho.android.data.apiclient.generated.models.WarrantyUpdateRequest
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class ItemsApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun attachItemLabel(itemID: kotlin.String, labelID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = attachItemLabelWithHttpInfo(itemID = itemID, labelID = labelID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun attachItemLabelWithHttpInfo(itemID: kotlin.String, labelID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = attachItemLabelRequestConfig(itemID = itemID, labelID = labelID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun attachItemLabelRequestConfig(itemID: kotlin.String, labelID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.PUT,
+            path = "/items/{itemID}/labels/{labelID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"labelID"+"}", encodeURIComponent(labelID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun createItem(item: Item, xHHOClientVersion: kotlin.String? = null) : Item {
+        val localVarResponse = createItemWithHttpInfo(item = item, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Item
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun createItemWithHttpInfo(item: Item, xHHOClientVersion: kotlin.String?) : ApiResponse<Item?> {
+        val localVariableConfig = createItemRequestConfig(item = item, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Item, Item>(
+            localVariableConfig
+        )
+    }
+
+    fun createItemRequestConfig(item: Item, xHHOClientVersion: kotlin.String?) : RequestConfig<Item> {
+        val localVariableBody = item
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/items",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun createItemCustomField(itemID: kotlin.String, itemCustomFieldCreateRequest: ItemCustomFieldCreateRequest, xHHOClientVersion: kotlin.String? = null) : ItemCustomField {
+        val localVarResponse = createItemCustomFieldWithHttpInfo(itemID = itemID, itemCustomFieldCreateRequest = itemCustomFieldCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as ItemCustomField
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun createItemCustomFieldWithHttpInfo(itemID: kotlin.String, itemCustomFieldCreateRequest: ItemCustomFieldCreateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<ItemCustomField?> {
+        val localVariableConfig = createItemCustomFieldRequestConfig(itemID = itemID, itemCustomFieldCreateRequest = itemCustomFieldCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<ItemCustomFieldCreateRequest, ItemCustomField>(
+            localVariableConfig
+        )
+    }
+
+    fun createItemCustomFieldRequestConfig(itemID: kotlin.String, itemCustomFieldCreateRequest: ItemCustomFieldCreateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<ItemCustomFieldCreateRequest> {
+        val localVariableBody = itemCustomFieldCreateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/items/{itemID}/custom-fields".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun createItemIdentification(itemID: kotlin.String, identificationCreateRequest: IdentificationCreateRequest, xHHOClientVersion: kotlin.String? = null) : Identification {
+        val localVarResponse = createItemIdentificationWithHttpInfo(itemID = itemID, identificationCreateRequest = identificationCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Identification
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun createItemIdentificationWithHttpInfo(itemID: kotlin.String, identificationCreateRequest: IdentificationCreateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<Identification?> {
+        val localVariableConfig = createItemIdentificationRequestConfig(itemID = itemID, identificationCreateRequest = identificationCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<IdentificationCreateRequest, Identification>(
+            localVariableConfig
+        )
+    }
+
+    fun createItemIdentificationRequestConfig(itemID: kotlin.String, identificationCreateRequest: IdentificationCreateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<IdentificationCreateRequest> {
+        val localVariableBody = identificationCreateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/items/{itemID}/identifications".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun createItemPurchase(itemID: kotlin.String, purchaseCreateRequest: PurchaseCreateRequest, xHHOClientVersion: kotlin.String? = null) : PurchaseBlock {
+        val localVarResponse = createItemPurchaseWithHttpInfo(itemID = itemID, purchaseCreateRequest = purchaseCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as PurchaseBlock
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun createItemPurchaseWithHttpInfo(itemID: kotlin.String, purchaseCreateRequest: PurchaseCreateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<PurchaseBlock?> {
+        val localVariableConfig = createItemPurchaseRequestConfig(itemID = itemID, purchaseCreateRequest = purchaseCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<PurchaseCreateRequest, PurchaseBlock>(
+            localVariableConfig
+        )
+    }
+
+    fun createItemPurchaseRequestConfig(itemID: kotlin.String, purchaseCreateRequest: PurchaseCreateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<PurchaseCreateRequest> {
+        val localVariableBody = purchaseCreateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/items/{itemID}/purchase".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun createItemSale(itemID: kotlin.String, saleCreateRequest: SaleCreateRequest, xHHOClientVersion: kotlin.String? = null) : SaleBlock {
+        val localVarResponse = createItemSaleWithHttpInfo(itemID = itemID, saleCreateRequest = saleCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as SaleBlock
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun createItemSaleWithHttpInfo(itemID: kotlin.String, saleCreateRequest: SaleCreateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<SaleBlock?> {
+        val localVariableConfig = createItemSaleRequestConfig(itemID = itemID, saleCreateRequest = saleCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<SaleCreateRequest, SaleBlock>(
+            localVariableConfig
+        )
+    }
+
+    fun createItemSaleRequestConfig(itemID: kotlin.String, saleCreateRequest: SaleCreateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<SaleCreateRequest> {
+        val localVariableBody = saleCreateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/items/{itemID}/sale".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun createItemStockAdjustment(itemID: kotlin.String, stockAdjustmentCreateRequest: StockAdjustmentCreateRequest, xHHOClientVersion: kotlin.String? = null) : StockAdjustment {
+        val localVarResponse = createItemStockAdjustmentWithHttpInfo(itemID = itemID, stockAdjustmentCreateRequest = stockAdjustmentCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as StockAdjustment
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun createItemStockAdjustmentWithHttpInfo(itemID: kotlin.String, stockAdjustmentCreateRequest: StockAdjustmentCreateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<StockAdjustment?> {
+        val localVariableConfig = createItemStockAdjustmentRequestConfig(itemID = itemID, stockAdjustmentCreateRequest = stockAdjustmentCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<StockAdjustmentCreateRequest, StockAdjustment>(
+            localVariableConfig
+        )
+    }
+
+    fun createItemStockAdjustmentRequestConfig(itemID: kotlin.String, stockAdjustmentCreateRequest: StockAdjustmentCreateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<StockAdjustmentCreateRequest> {
+        val localVariableBody = stockAdjustmentCreateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/items/{itemID}/stock-adjustments".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun createItemWarranty(itemID: kotlin.String, warrantyCreateRequest: WarrantyCreateRequest, xHHOClientVersion: kotlin.String? = null) : WarrantyBlock {
+        val localVarResponse = createItemWarrantyWithHttpInfo(itemID = itemID, warrantyCreateRequest = warrantyCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as WarrantyBlock
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun createItemWarrantyWithHttpInfo(itemID: kotlin.String, warrantyCreateRequest: WarrantyCreateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<WarrantyBlock?> {
+        val localVariableConfig = createItemWarrantyRequestConfig(itemID = itemID, warrantyCreateRequest = warrantyCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<WarrantyCreateRequest, WarrantyBlock>(
+            localVariableConfig
+        )
+    }
+
+    fun createItemWarrantyRequestConfig(itemID: kotlin.String, warrantyCreateRequest: WarrantyCreateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<WarrantyCreateRequest> {
+        val localVariableBody = warrantyCreateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/items/{itemID}/warranty".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun deleteItem(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = deleteItemWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun deleteItemWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = deleteItemRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun deleteItemRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/items/{itemID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun deleteItemAttachment(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = deleteItemAttachmentWithHttpInfo(itemID = itemID, attachmentID = attachmentID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun deleteItemAttachmentWithHttpInfo(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = deleteItemAttachmentRequestConfig(itemID = itemID, attachmentID = attachmentID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun deleteItemAttachmentRequestConfig(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/items/{itemID}/attachments/{attachmentID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"attachmentID"+"}", encodeURIComponent(attachmentID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun deleteItemCustomField(itemID: kotlin.String, customFieldID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = deleteItemCustomFieldWithHttpInfo(itemID = itemID, customFieldID = customFieldID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun deleteItemCustomFieldWithHttpInfo(itemID: kotlin.String, customFieldID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = deleteItemCustomFieldRequestConfig(itemID = itemID, customFieldID = customFieldID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun deleteItemCustomFieldRequestConfig(itemID: kotlin.String, customFieldID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/items/{itemID}/custom-fields/{customFieldID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"customFieldID"+"}", encodeURIComponent(customFieldID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun deleteItemIdentification(itemID: kotlin.String, identificationID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = deleteItemIdentificationWithHttpInfo(itemID = itemID, identificationID = identificationID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun deleteItemIdentificationWithHttpInfo(itemID: kotlin.String, identificationID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = deleteItemIdentificationRequestConfig(itemID = itemID, identificationID = identificationID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun deleteItemIdentificationRequestConfig(itemID: kotlin.String, identificationID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/items/{itemID}/identifications/{identificationID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"identificationID"+"}", encodeURIComponent(identificationID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun deleteItemPurchase(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = deleteItemPurchaseWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun deleteItemPurchaseWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = deleteItemPurchaseRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun deleteItemPurchaseRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/items/{itemID}/purchase".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun deleteItemSale(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = deleteItemSaleWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun deleteItemSaleWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = deleteItemSaleRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun deleteItemSaleRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/items/{itemID}/sale".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun deleteItemWarranty(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = deleteItemWarrantyWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun deleteItemWarrantyWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = deleteItemWarrantyRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun deleteItemWarrantyRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/items/{itemID}/warranty".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun detachItemLabel(itemID: kotlin.String, labelID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = detachItemLabelWithHttpInfo(itemID = itemID, labelID = labelID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun detachItemLabelWithHttpInfo(itemID: kotlin.String, labelID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = detachItemLabelRequestConfig(itemID = itemID, labelID = labelID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun detachItemLabelRequestConfig(itemID: kotlin.String, labelID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/items/{itemID}/labels/{labelID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"labelID"+"}", encodeURIComponent(labelID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun downloadItemAttachment(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : java.io.File {
+        val localVarResponse = downloadItemAttachmentWithHttpInfo(itemID = itemID, attachmentID = attachmentID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as java.io.File
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun downloadItemAttachmentWithHttpInfo(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<java.io.File?> {
+        val localVariableConfig = downloadItemAttachmentRequestConfig(itemID = itemID, attachmentID = attachmentID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, java.io.File>(
+            localVariableConfig
+        )
+    }
+
+    fun downloadItemAttachmentRequestConfig(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/octet-stream, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/attachments/{attachmentID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"attachmentID"+"}", encodeURIComponent(attachmentID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun downloadItemAttachmentThumbnail(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : java.io.File {
+        val localVarResponse = downloadItemAttachmentThumbnailWithHttpInfo(itemID = itemID, attachmentID = attachmentID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as java.io.File
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun downloadItemAttachmentThumbnailWithHttpInfo(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<java.io.File?> {
+        val localVariableConfig = downloadItemAttachmentThumbnailRequestConfig(itemID = itemID, attachmentID = attachmentID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, java.io.File>(
+            localVariableConfig
+        )
+    }
+
+    fun downloadItemAttachmentThumbnailRequestConfig(itemID: kotlin.String, attachmentID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/attachments/{attachmentID}/thumbnail".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"attachmentID"+"}", encodeURIComponent(attachmentID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getItem(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Item {
+        val localVarResponse = getItemWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Item
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getItemWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Item?> {
+        val localVariableConfig = getItemRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Item>(
+            localVariableConfig
+        )
+    }
+
+    fun getItemRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getItemPurchase(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : PurchaseBlock {
+        val localVarResponse = getItemPurchaseWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as PurchaseBlock
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getItemPurchaseWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<PurchaseBlock?> {
+        val localVariableConfig = getItemPurchaseRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, PurchaseBlock>(
+            localVariableConfig
+        )
+    }
+
+    fun getItemPurchaseRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/purchase".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getItemSale(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : SaleBlock {
+        val localVarResponse = getItemSaleWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as SaleBlock
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getItemSaleWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<SaleBlock?> {
+        val localVariableConfig = getItemSaleRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, SaleBlock>(
+            localVariableConfig
+        )
+    }
+
+    fun getItemSaleRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/sale".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getItemWarranty(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : WarrantyBlock {
+        val localVarResponse = getItemWarrantyWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as WarrantyBlock
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getItemWarrantyWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<WarrantyBlock?> {
+        val localVariableConfig = getItemWarrantyRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, WarrantyBlock>(
+            localVariableConfig
+        )
+    }
+
+    fun getItemWarrantyRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/warranty".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listItemAttachments(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : AttachmentListResponse {
+        val localVarResponse = listItemAttachmentsWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as AttachmentListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listItemAttachmentsWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<AttachmentListResponse?> {
+        val localVariableConfig = listItemAttachmentsRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, AttachmentListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listItemAttachmentsRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/attachments".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listItemCustomFields(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : ItemCustomFieldListResponse {
+        val localVarResponse = listItemCustomFieldsWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as ItemCustomFieldListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listItemCustomFieldsWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<ItemCustomFieldListResponse?> {
+        val localVariableConfig = listItemCustomFieldsRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, ItemCustomFieldListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listItemCustomFieldsRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/custom-fields".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listItemIdentifications(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : IdentificationListResponse {
+        val localVarResponse = listItemIdentificationsWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as IdentificationListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listItemIdentificationsWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<IdentificationListResponse?> {
+        val localVariableConfig = listItemIdentificationsRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, IdentificationListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listItemIdentificationsRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/identifications".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listItemLabels(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : LabelListResponse {
+        val localVarResponse = listItemLabelsWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as LabelListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listItemLabelsWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<LabelListResponse?> {
+        val localVariableConfig = listItemLabelsRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, LabelListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listItemLabelsRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/labels".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listItemStockAdjustments(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : StockAdjustmentListResponse {
+        val localVarResponse = listItemStockAdjustmentsWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as StockAdjustmentListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listItemStockAdjustmentsWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<StockAdjustmentListResponse?> {
+        val localVariableConfig = listItemStockAdjustmentsRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, StockAdjustmentListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listItemStockAdjustmentsRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/stock-adjustments".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+     enum class WarrantyStatusListItems(val value: kotlin.String) {
+         @SerialName(value = "none") None("none"),
+         @SerialName(value = "any") Any("any"),
+         @SerialName(value = "active") Active("active"),
+         @SerialName(value = "expired") Expired("expired"),
+         @SerialName(value = "lifetime") Lifetime("lifetime");
+
+        override fun toString(): kotlin.String = "$value"
+     }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listItems(q: kotlin.String? = null, locationId: kotlin.String? = null, descendants: kotlin.Boolean? = false, labelId: kotlin.collections.List<kotlin.String>? = null, customField: kotlin.collections.List<kotlin.String>? = null, warrantyStatus: WarrantyStatusListItems? = null, createdFrom: kotlin.Long? = null, createdTo: kotlin.Long? = null, updatedFrom: kotlin.Long? = null, updatedTo: kotlin.Long? = null, sort: kotlin.String? = null, limit: kotlin.Int? = 50, offset: kotlin.Int? = 0, xHHOClientVersion: kotlin.String? = null) : ItemListResponse {
+        val localVarResponse = listItemsWithHttpInfo(q = q, locationId = locationId, descendants = descendants, labelId = labelId, customField = customField, warrantyStatus = warrantyStatus, createdFrom = createdFrom, createdTo = createdTo, updatedFrom = updatedFrom, updatedTo = updatedTo, sort = sort, limit = limit, offset = offset, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as ItemListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listItemsWithHttpInfo(q: kotlin.String?, locationId: kotlin.String?, descendants: kotlin.Boolean?, labelId: kotlin.collections.List<kotlin.String>?, customField: kotlin.collections.List<kotlin.String>?, warrantyStatus: WarrantyStatusListItems?, createdFrom: kotlin.Long?, createdTo: kotlin.Long?, updatedFrom: kotlin.Long?, updatedTo: kotlin.Long?, sort: kotlin.String?, limit: kotlin.Int?, offset: kotlin.Int?, xHHOClientVersion: kotlin.String?) : ApiResponse<ItemListResponse?> {
+        val localVariableConfig = listItemsRequestConfig(q = q, locationId = locationId, descendants = descendants, labelId = labelId, customField = customField, warrantyStatus = warrantyStatus, createdFrom = createdFrom, createdTo = createdTo, updatedFrom = updatedFrom, updatedTo = updatedTo, sort = sort, limit = limit, offset = offset, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, ItemListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listItemsRequestConfig(q: kotlin.String?, locationId: kotlin.String?, descendants: kotlin.Boolean?, labelId: kotlin.collections.List<kotlin.String>?, customField: kotlin.collections.List<kotlin.String>?, warrantyStatus: WarrantyStatusListItems?, createdFrom: kotlin.Long?, createdTo: kotlin.Long?, updatedFrom: kotlin.Long?, updatedTo: kotlin.Long?, sort: kotlin.String?, limit: kotlin.Int?, offset: kotlin.Int?, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf<kotlin.String, kotlin.collections.List<kotlin.String>>()
+            .apply {
+                if (q != null) {
+                    put("q", listOf(q.toString()))
+                }
+                if (locationId != null) {
+                    put("location_id", listOf(locationId.toString()))
+                }
+                if (descendants != null) {
+                    put("descendants", listOf(descendants.toString()))
+                }
+                if (labelId != null) {
+                    put("label_id", toMultiValue(labelId.toList(), "multi"))
+                }
+                if (customField != null) {
+                    put("custom_field", toMultiValue(customField.toList(), "multi"))
+                }
+                if (warrantyStatus != null) {
+                    put("warranty_status", listOf(warrantyStatus.value))
+                }
+                if (createdFrom != null) {
+                    put("created_from", listOf(createdFrom.toString()))
+                }
+                if (createdTo != null) {
+                    put("created_to", listOf(createdTo.toString()))
+                }
+                if (updatedFrom != null) {
+                    put("updated_from", listOf(updatedFrom.toString()))
+                }
+                if (updatedTo != null) {
+                    put("updated_to", listOf(updatedTo.toString()))
+                }
+                if (sort != null) {
+                    put("sort", listOf(sort.toString()))
+                }
+                if (limit != null) {
+                    put("limit", listOf(limit.toString()))
+                }
+                if (offset != null) {
+                    put("offset", listOf(offset.toString()))
+                }
+            }
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun updateItem(itemID: kotlin.String, itemUpdateRequest: ItemUpdateRequest, xHHOClientVersion: kotlin.String? = null) : Item {
+        val localVarResponse = updateItemWithHttpInfo(itemID = itemID, itemUpdateRequest = itemUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Item
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun updateItemWithHttpInfo(itemID: kotlin.String, itemUpdateRequest: ItemUpdateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<Item?> {
+        val localVariableConfig = updateItemRequestConfig(itemID = itemID, itemUpdateRequest = itemUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<ItemUpdateRequest, Item>(
+            localVariableConfig
+        )
+    }
+
+    fun updateItemRequestConfig(itemID: kotlin.String, itemUpdateRequest: ItemUpdateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<ItemUpdateRequest> {
+        val localVariableBody = itemUpdateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.PUT,
+            path = "/items/{itemID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun updateItemCustomField(itemID: kotlin.String, customFieldID: kotlin.String, itemCustomFieldUpdateRequest: ItemCustomFieldUpdateRequest, xHHOClientVersion: kotlin.String? = null) : ItemCustomField {
+        val localVarResponse = updateItemCustomFieldWithHttpInfo(itemID = itemID, customFieldID = customFieldID, itemCustomFieldUpdateRequest = itemCustomFieldUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as ItemCustomField
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun updateItemCustomFieldWithHttpInfo(itemID: kotlin.String, customFieldID: kotlin.String, itemCustomFieldUpdateRequest: ItemCustomFieldUpdateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<ItemCustomField?> {
+        val localVariableConfig = updateItemCustomFieldRequestConfig(itemID = itemID, customFieldID = customFieldID, itemCustomFieldUpdateRequest = itemCustomFieldUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<ItemCustomFieldUpdateRequest, ItemCustomField>(
+            localVariableConfig
+        )
+    }
+
+    fun updateItemCustomFieldRequestConfig(itemID: kotlin.String, customFieldID: kotlin.String, itemCustomFieldUpdateRequest: ItemCustomFieldUpdateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<ItemCustomFieldUpdateRequest> {
+        val localVariableBody = itemCustomFieldUpdateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.PUT,
+            path = "/items/{itemID}/custom-fields/{customFieldID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"customFieldID"+"}", encodeURIComponent(customFieldID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun updateItemIdentification(itemID: kotlin.String, identificationID: kotlin.String, identificationUpdateRequest: IdentificationUpdateRequest, xHHOClientVersion: kotlin.String? = null) : Identification {
+        val localVarResponse = updateItemIdentificationWithHttpInfo(itemID = itemID, identificationID = identificationID, identificationUpdateRequest = identificationUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Identification
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun updateItemIdentificationWithHttpInfo(itemID: kotlin.String, identificationID: kotlin.String, identificationUpdateRequest: IdentificationUpdateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<Identification?> {
+        val localVariableConfig = updateItemIdentificationRequestConfig(itemID = itemID, identificationID = identificationID, identificationUpdateRequest = identificationUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<IdentificationUpdateRequest, Identification>(
+            localVariableConfig
+        )
+    }
+
+    fun updateItemIdentificationRequestConfig(itemID: kotlin.String, identificationID: kotlin.String, identificationUpdateRequest: IdentificationUpdateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<IdentificationUpdateRequest> {
+        val localVariableBody = identificationUpdateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.PUT,
+            path = "/items/{itemID}/identifications/{identificationID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"identificationID"+"}", encodeURIComponent(identificationID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun updateItemPurchase(itemID: kotlin.String, purchaseUpdateRequest: PurchaseUpdateRequest, xHHOClientVersion: kotlin.String? = null) : PurchaseBlock {
+        val localVarResponse = updateItemPurchaseWithHttpInfo(itemID = itemID, purchaseUpdateRequest = purchaseUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as PurchaseBlock
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun updateItemPurchaseWithHttpInfo(itemID: kotlin.String, purchaseUpdateRequest: PurchaseUpdateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<PurchaseBlock?> {
+        val localVariableConfig = updateItemPurchaseRequestConfig(itemID = itemID, purchaseUpdateRequest = purchaseUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<PurchaseUpdateRequest, PurchaseBlock>(
+            localVariableConfig
+        )
+    }
+
+    fun updateItemPurchaseRequestConfig(itemID: kotlin.String, purchaseUpdateRequest: PurchaseUpdateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<PurchaseUpdateRequest> {
+        val localVariableBody = purchaseUpdateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.PUT,
+            path = "/items/{itemID}/purchase".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun updateItemSale(itemID: kotlin.String, saleUpdateRequest: SaleUpdateRequest, xHHOClientVersion: kotlin.String? = null) : SaleBlock {
+        val localVarResponse = updateItemSaleWithHttpInfo(itemID = itemID, saleUpdateRequest = saleUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as SaleBlock
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun updateItemSaleWithHttpInfo(itemID: kotlin.String, saleUpdateRequest: SaleUpdateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<SaleBlock?> {
+        val localVariableConfig = updateItemSaleRequestConfig(itemID = itemID, saleUpdateRequest = saleUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<SaleUpdateRequest, SaleBlock>(
+            localVariableConfig
+        )
+    }
+
+    fun updateItemSaleRequestConfig(itemID: kotlin.String, saleUpdateRequest: SaleUpdateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<SaleUpdateRequest> {
+        val localVariableBody = saleUpdateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.PUT,
+            path = "/items/{itemID}/sale".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun updateItemWarranty(itemID: kotlin.String, warrantyUpdateRequest: WarrantyUpdateRequest, xHHOClientVersion: kotlin.String? = null) : WarrantyBlock {
+        val localVarResponse = updateItemWarrantyWithHttpInfo(itemID = itemID, warrantyUpdateRequest = warrantyUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as WarrantyBlock
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun updateItemWarrantyWithHttpInfo(itemID: kotlin.String, warrantyUpdateRequest: WarrantyUpdateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<WarrantyBlock?> {
+        val localVariableConfig = updateItemWarrantyRequestConfig(itemID = itemID, warrantyUpdateRequest = warrantyUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<WarrantyUpdateRequest, WarrantyBlock>(
+            localVariableConfig
+        )
+    }
+
+    fun updateItemWarrantyRequestConfig(itemID: kotlin.String, warrantyUpdateRequest: WarrantyUpdateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<WarrantyUpdateRequest> {
+        val localVariableBody = warrantyUpdateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.PUT,
+            path = "/items/{itemID}/warranty".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+     enum class CategoryUploadItemAttachment(val value: kotlin.String) {
+         @SerialName(value = "image") Image("image"),
+         @SerialName(value = "manual") Manual("manual"),
+         @SerialName(value = "warranty") Warranty("warranty"),
+         @SerialName(value = "receipt") Receipt("receipt"),
+         @SerialName(value = "general") General("general");
+
+        override fun toString(): kotlin.String = "$value"
+     }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun uploadItemAttachment(itemID: kotlin.String, category: CategoryUploadItemAttachment, file: java.io.File, xHHOClientVersion: kotlin.String? = null) : Attachment {
+        val localVarResponse = uploadItemAttachmentWithHttpInfo(itemID = itemID, category = category, file = file, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Attachment
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun uploadItemAttachmentWithHttpInfo(itemID: kotlin.String, category: CategoryUploadItemAttachment, file: java.io.File, xHHOClientVersion: kotlin.String?) : ApiResponse<Attachment?> {
+        val localVariableConfig = uploadItemAttachmentRequestConfig(itemID = itemID, category = category, file = file, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Map<String, PartConfig<*>>, Attachment>(
+            localVariableConfig
+        )
+    }
+
+    fun uploadItemAttachmentRequestConfig(itemID: kotlin.String, category: CategoryUploadItemAttachment, file: java.io.File, xHHOClientVersion: kotlin.String?) : RequestConfig<Map<String, PartConfig<*>>> {
+        val localVariableBody = mapOf(
+            "category" to PartConfig(body = category.value, headers = mutableMapOf()),
+            "file" to PartConfig(body = file, headers = mutableMapOf("Content-Type" to "*/*")),)
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf("Content-Type" to "multipart/form-data")
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/items/{itemID}/attachments".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/LabelsApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/LabelsApi.kt
new file mode 100644
index 0000000..8351a3e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/LabelsApi.kt
@@ -0,0 +1,382 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.Label
+import dev.hho.android.data.apiclient.generated.models.LabelCreateRequest
+import dev.hho.android.data.apiclient.generated.models.LabelListResponse
+import dev.hho.android.data.apiclient.generated.models.LabelUpdateRequest
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class LabelsApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun attachItemLabel(itemID: kotlin.String, labelID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = attachItemLabelWithHttpInfo(itemID = itemID, labelID = labelID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun attachItemLabelWithHttpInfo(itemID: kotlin.String, labelID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = attachItemLabelRequestConfig(itemID = itemID, labelID = labelID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun attachItemLabelRequestConfig(itemID: kotlin.String, labelID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.PUT,
+            path = "/items/{itemID}/labels/{labelID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"labelID"+"}", encodeURIComponent(labelID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun createLabel(labelCreateRequest: LabelCreateRequest, xHHOClientVersion: kotlin.String? = null) : Label {
+        val localVarResponse = createLabelWithHttpInfo(labelCreateRequest = labelCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Label
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun createLabelWithHttpInfo(labelCreateRequest: LabelCreateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<Label?> {
+        val localVariableConfig = createLabelRequestConfig(labelCreateRequest = labelCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<LabelCreateRequest, Label>(
+            localVariableConfig
+        )
+    }
+
+    fun createLabelRequestConfig(labelCreateRequest: LabelCreateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<LabelCreateRequest> {
+        val localVariableBody = labelCreateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/labels",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun deleteLabel(labelID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = deleteLabelWithHttpInfo(labelID = labelID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun deleteLabelWithHttpInfo(labelID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = deleteLabelRequestConfig(labelID = labelID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun deleteLabelRequestConfig(labelID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/labels/{labelID}".replace("{"+"labelID"+"}", encodeURIComponent(labelID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun detachItemLabel(itemID: kotlin.String, labelID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = detachItemLabelWithHttpInfo(itemID = itemID, labelID = labelID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun detachItemLabelWithHttpInfo(itemID: kotlin.String, labelID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = detachItemLabelRequestConfig(itemID = itemID, labelID = labelID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun detachItemLabelRequestConfig(itemID: kotlin.String, labelID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/items/{itemID}/labels/{labelID}".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())).replace("{"+"labelID"+"}", encodeURIComponent(labelID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listItemLabels(itemID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : LabelListResponse {
+        val localVarResponse = listItemLabelsWithHttpInfo(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as LabelListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listItemLabelsWithHttpInfo(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<LabelListResponse?> {
+        val localVariableConfig = listItemLabelsRequestConfig(itemID = itemID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, LabelListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listItemLabelsRequestConfig(itemID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/items/{itemID}/labels".replace("{"+"itemID"+"}", encodeURIComponent(itemID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listLabels(xHHOClientVersion: kotlin.String? = null) : LabelListResponse {
+        val localVarResponse = listLabelsWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as LabelListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listLabelsWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<LabelListResponse?> {
+        val localVariableConfig = listLabelsRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, LabelListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listLabelsRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/labels",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun updateLabel(labelID: kotlin.String, labelUpdateRequest: LabelUpdateRequest, xHHOClientVersion: kotlin.String? = null) : Label {
+        val localVarResponse = updateLabelWithHttpInfo(labelID = labelID, labelUpdateRequest = labelUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Label
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun updateLabelWithHttpInfo(labelID: kotlin.String, labelUpdateRequest: LabelUpdateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<Label?> {
+        val localVariableConfig = updateLabelRequestConfig(labelID = labelID, labelUpdateRequest = labelUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<LabelUpdateRequest, Label>(
+            localVariableConfig
+        )
+    }
+
+    fun updateLabelRequestConfig(labelID: kotlin.String, labelUpdateRequest: LabelUpdateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<LabelUpdateRequest> {
+        val localVariableBody = labelUpdateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.PUT,
+            path = "/labels/{labelID}".replace("{"+"labelID"+"}", encodeURIComponent(labelID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/LabelsQrApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/LabelsQrApi.kt
new file mode 100644
index 0000000..a4d2dfb
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/LabelsQrApi.kt
@@ -0,0 +1,147 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.LabelsQRBatchRequest
+import dev.hho.android.data.apiclient.generated.models.LabelsQRBatchResponse
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class LabelsQrApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun createLabelsQRBatch(labelsQRBatchRequest: LabelsQRBatchRequest, xHHOClientVersion: kotlin.String? = null) : LabelsQRBatchResponse {
+        val localVarResponse = createLabelsQRBatchWithHttpInfo(labelsQRBatchRequest = labelsQRBatchRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as LabelsQRBatchResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun createLabelsQRBatchWithHttpInfo(labelsQRBatchRequest: LabelsQRBatchRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<LabelsQRBatchResponse?> {
+        val localVariableConfig = createLabelsQRBatchRequestConfig(labelsQRBatchRequest = labelsQRBatchRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<LabelsQRBatchRequest, LabelsQRBatchResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun createLabelsQRBatchRequestConfig(labelsQRBatchRequest: LabelsQRBatchRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<LabelsQRBatchRequest> {
+        val localVariableBody = labelsQRBatchRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/labels/qr/batch",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun resolveItemToken(token: kotlin.String) : Unit {
+        val localVarResponse = resolveItemTokenWithHttpInfo(token = token)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun resolveItemTokenWithHttpInfo(token: kotlin.String) : ApiResponse<Unit?> {
+        val localVariableConfig = resolveItemTokenRequestConfig(token = token)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun resolveItemTokenRequestConfig(token: kotlin.String) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/i/{token}".replace("{"+"token"+"}", encodeURIComponent(token.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = false,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/LocationsApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/LocationsApi.kt
new file mode 100644
index 0000000..17c26e9
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/LocationsApi.kt
@@ -0,0 +1,346 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.Location
+import dev.hho.android.data.apiclient.generated.models.LocationCreateRequest
+import dev.hho.android.data.apiclient.generated.models.LocationListResponse
+import dev.hho.android.data.apiclient.generated.models.LocationNotEmptyProblem
+import dev.hho.android.data.apiclient.generated.models.LocationTreeResponse
+import dev.hho.android.data.apiclient.generated.models.LocationUpdateRequest
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class LocationsApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun createLocation(locationCreateRequest: LocationCreateRequest, xHHOClientVersion: kotlin.String? = null) : Location {
+        val localVarResponse = createLocationWithHttpInfo(locationCreateRequest = locationCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Location
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun createLocationWithHttpInfo(locationCreateRequest: LocationCreateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<Location?> {
+        val localVariableConfig = createLocationRequestConfig(locationCreateRequest = locationCreateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<LocationCreateRequest, Location>(
+            localVariableConfig
+        )
+    }
+
+    fun createLocationRequestConfig(locationCreateRequest: LocationCreateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<LocationCreateRequest> {
+        val localVariableBody = locationCreateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/locations",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun deleteLocation(locationID: kotlin.String, reassignTo: kotlin.String? = null, xHHOClientVersion: kotlin.String? = null) : Unit {
+        val localVarResponse = deleteLocationWithHttpInfo(locationID = locationID, reassignTo = reassignTo, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> Unit
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Throws(IllegalStateException::class, IOException::class)
+    fun deleteLocationWithHttpInfo(locationID: kotlin.String, reassignTo: kotlin.String?, xHHOClientVersion: kotlin.String?) : ApiResponse<Unit?> {
+        val localVariableConfig = deleteLocationRequestConfig(locationID = locationID, reassignTo = reassignTo, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Unit>(
+            localVariableConfig
+        )
+    }
+
+    fun deleteLocationRequestConfig(locationID: kotlin.String, reassignTo: kotlin.String?, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf<kotlin.String, kotlin.collections.List<kotlin.String>>()
+            .apply {
+                if (reassignTo != null) {
+                    put("reassign_to", listOf(reassignTo.toString()))
+                }
+            }
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.DELETE,
+            path = "/locations/{locationID}".replace("{"+"locationID"+"}", encodeURIComponent(locationID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getLocation(locationID: kotlin.String, xHHOClientVersion: kotlin.String? = null) : Location {
+        val localVarResponse = getLocationWithHttpInfo(locationID = locationID, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Location
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getLocationWithHttpInfo(locationID: kotlin.String, xHHOClientVersion: kotlin.String?) : ApiResponse<Location?> {
+        val localVariableConfig = getLocationRequestConfig(locationID = locationID, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, Location>(
+            localVariableConfig
+        )
+    }
+
+    fun getLocationRequestConfig(locationID: kotlin.String, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/locations/{locationID}".replace("{"+"locationID"+"}", encodeURIComponent(locationID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getLocationTree(xHHOClientVersion: kotlin.String? = null) : LocationTreeResponse {
+        val localVarResponse = getLocationTreeWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as LocationTreeResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getLocationTreeWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<LocationTreeResponse?> {
+        val localVariableConfig = getLocationTreeRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, LocationTreeResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun getLocationTreeRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/locations/tree",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listLocations(xHHOClientVersion: kotlin.String? = null) : LocationListResponse {
+        val localVarResponse = listLocationsWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as LocationListResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listLocationsWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<LocationListResponse?> {
+        val localVariableConfig = listLocationsRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, LocationListResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listLocationsRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/locations",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun updateLocation(locationID: kotlin.String, locationUpdateRequest: LocationUpdateRequest, xHHOClientVersion: kotlin.String? = null) : Location {
+        val localVarResponse = updateLocationWithHttpInfo(locationID = locationID, locationUpdateRequest = locationUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as Location
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun updateLocationWithHttpInfo(locationID: kotlin.String, locationUpdateRequest: LocationUpdateRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<Location?> {
+        val localVariableConfig = updateLocationRequestConfig(locationID = locationID, locationUpdateRequest = locationUpdateRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<LocationUpdateRequest, Location>(
+            localVariableConfig
+        )
+    }
+
+    fun updateLocationRequestConfig(locationID: kotlin.String, locationUpdateRequest: LocationUpdateRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<LocationUpdateRequest> {
+        val localVariableBody = locationUpdateRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.PUT,
+            path = "/locations/{locationID}".replace("{"+"locationID"+"}", encodeURIComponent(locationID.toString())),
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/MetaApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/MetaApi.kt
new file mode 100644
index 0000000..684befb
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/MetaApi.kt
@@ -0,0 +1,100 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class MetaApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getOpenAPISpec(xHHOClientVersion: kotlin.String? = null) : kotlin.String {
+        val localVarResponse = getOpenAPISpecWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as kotlin.String
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getOpenAPISpecWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<kotlin.String?> {
+        val localVariableConfig = getOpenAPISpecRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, kotlin.String>(
+            localVariableConfig
+        )
+    }
+
+    fun getOpenAPISpecRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/openapi.yaml",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = false,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/ReportsApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/ReportsApi.kt
new file mode 100644
index 0000000..979c038
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/ReportsApi.kt
@@ -0,0 +1,306 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.ReportItemCountByLocationResponse
+import dev.hho.android.data.apiclient.generated.models.ReportPurchasesResponse
+import dev.hho.android.data.apiclient.generated.models.ReportValuationResponse
+import dev.hho.android.data.apiclient.generated.models.ReportWarrantyExpiringResponse
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class ReportsApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+     enum class FormatGetReportItemCountByLocation(val value: kotlin.String) {
+         @SerialName(value = "json") Json("json"),
+         @SerialName(value = "csv") Csv("csv");
+
+        override fun toString(): kotlin.String = "$value"
+     }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getReportItemCountByLocation(format: FormatGetReportItemCountByLocation? = FormatGetReportItemCountByLocation.Json, xHHOClientVersion: kotlin.String? = null) : ReportItemCountByLocationResponse {
+        val localVarResponse = getReportItemCountByLocationWithHttpInfo(format = format, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as ReportItemCountByLocationResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getReportItemCountByLocationWithHttpInfo(format: FormatGetReportItemCountByLocation?, xHHOClientVersion: kotlin.String?) : ApiResponse<ReportItemCountByLocationResponse?> {
+        val localVariableConfig = getReportItemCountByLocationRequestConfig(format = format, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, ReportItemCountByLocationResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun getReportItemCountByLocationRequestConfig(format: FormatGetReportItemCountByLocation?, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf<kotlin.String, kotlin.collections.List<kotlin.String>>()
+            .apply {
+                if (format != null) {
+                    put("format", listOf(format.value))
+                }
+            }
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/reports/item-count-by-location",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+     enum class FormatGetReportPurchases(val value: kotlin.String) {
+         @SerialName(value = "json") Json("json"),
+         @SerialName(value = "csv") Csv("csv");
+
+        override fun toString(): kotlin.String = "$value"
+     }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getReportPurchases(from: kotlin.String, to: kotlin.String, format: FormatGetReportPurchases? = FormatGetReportPurchases.Json, xHHOClientVersion: kotlin.String? = null) : ReportPurchasesResponse {
+        val localVarResponse = getReportPurchasesWithHttpInfo(from = from, to = to, format = format, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as ReportPurchasesResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getReportPurchasesWithHttpInfo(from: kotlin.String, to: kotlin.String, format: FormatGetReportPurchases?, xHHOClientVersion: kotlin.String?) : ApiResponse<ReportPurchasesResponse?> {
+        val localVariableConfig = getReportPurchasesRequestConfig(from = from, to = to, format = format, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, ReportPurchasesResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun getReportPurchasesRequestConfig(from: kotlin.String, to: kotlin.String, format: FormatGetReportPurchases?, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf<kotlin.String, kotlin.collections.List<kotlin.String>>()
+            .apply {
+                if (format != null) {
+                    put("format", listOf(format.value))
+                }
+                put("from", listOf(from.toString()))
+                put("to", listOf(to.toString()))
+            }
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/reports/purchases",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+     enum class GroupByGetReportValuation(val value: kotlin.String) {
+         @SerialName(value = "location") Location("location"),
+         @SerialName(value = "label") Label("label");
+
+        override fun toString(): kotlin.String = "$value"
+     }
+
+     enum class FormatGetReportValuation(val value: kotlin.String) {
+         @SerialName(value = "json") Json("json"),
+         @SerialName(value = "csv") Csv("csv");
+
+        override fun toString(): kotlin.String = "$value"
+     }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getReportValuation(groupBy: GroupByGetReportValuation, format: FormatGetReportValuation? = FormatGetReportValuation.Json, xHHOClientVersion: kotlin.String? = null) : ReportValuationResponse {
+        val localVarResponse = getReportValuationWithHttpInfo(groupBy = groupBy, format = format, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as ReportValuationResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getReportValuationWithHttpInfo(groupBy: GroupByGetReportValuation, format: FormatGetReportValuation?, xHHOClientVersion: kotlin.String?) : ApiResponse<ReportValuationResponse?> {
+        val localVariableConfig = getReportValuationRequestConfig(groupBy = groupBy, format = format, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, ReportValuationResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun getReportValuationRequestConfig(groupBy: GroupByGetReportValuation, format: FormatGetReportValuation?, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf<kotlin.String, kotlin.collections.List<kotlin.String>>()
+            .apply {
+                if (format != null) {
+                    put("format", listOf(format.value))
+                }
+                put("group_by", listOf(groupBy.value))
+            }
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/reports/valuation",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+     enum class FormatGetReportWarrantyExpiring(val value: kotlin.String) {
+         @SerialName(value = "json") Json("json"),
+         @SerialName(value = "csv") Csv("csv");
+
+        override fun toString(): kotlin.String = "$value"
+     }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getReportWarrantyExpiring(format: FormatGetReportWarrantyExpiring? = FormatGetReportWarrantyExpiring.Json, withinDays: kotlin.Int? = 30, xHHOClientVersion: kotlin.String? = null) : ReportWarrantyExpiringResponse {
+        val localVarResponse = getReportWarrantyExpiringWithHttpInfo(format = format, withinDays = withinDays, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as ReportWarrantyExpiringResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getReportWarrantyExpiringWithHttpInfo(format: FormatGetReportWarrantyExpiring?, withinDays: kotlin.Int?, xHHOClientVersion: kotlin.String?) : ApiResponse<ReportWarrantyExpiringResponse?> {
+        val localVariableConfig = getReportWarrantyExpiringRequestConfig(format = format, withinDays = withinDays, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, ReportWarrantyExpiringResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun getReportWarrantyExpiringRequestConfig(format: FormatGetReportWarrantyExpiring?, withinDays: kotlin.Int?, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf<kotlin.String, kotlin.collections.List<kotlin.String>>()
+            .apply {
+                if (format != null) {
+                    put("format", listOf(format.value))
+                }
+                if (withinDays != null) {
+                    put("within_days", listOf(withinDays.toString()))
+                }
+            }
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/reports/warranty-expiring",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/StatusApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/StatusApi.kt
new file mode 100644
index 0000000..1bae151
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/StatusApi.kt
@@ -0,0 +1,101 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.StatusResponse
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class StatusApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun getStatus(xHHOClientVersion: kotlin.String? = null) : StatusResponse {
+        val localVarResponse = getStatusWithHttpInfo(xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as StatusResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun getStatusWithHttpInfo(xHHOClientVersion: kotlin.String?) : ApiResponse<StatusResponse?> {
+        val localVariableConfig = getStatusRequestConfig(xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, StatusResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun getStatusRequestConfig(xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/status",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = false,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/SyncApi.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/SyncApi.kt
new file mode 100644
index 0000000..1bd7692
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/apis/SyncApi.kt
@@ -0,0 +1,209 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.apis
+
+import java.io.IOException
+import okhttp3.Call
+import okhttp3.HttpUrl
+
+import dev.hho.android.data.apiclient.generated.models.Problem
+import dev.hho.android.data.apiclient.generated.models.SyncConflictLogResponse
+import dev.hho.android.data.apiclient.generated.models.SyncPullRequest
+import dev.hho.android.data.apiclient.generated.models.SyncPullResponse
+import dev.hho.android.data.apiclient.generated.models.SyncPushRequest
+import dev.hho.android.data.apiclient.generated.models.SyncPushResponse
+import dev.hho.android.data.apiclient.generated.models.UpgradeRequiredProblem
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiClient
+import dev.hho.android.data.apiclient.generated.infrastructure.ApiResponse
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientException
+import dev.hho.android.data.apiclient.generated.infrastructure.ClientError
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerException
+import dev.hho.android.data.apiclient.generated.infrastructure.ServerError
+import dev.hho.android.data.apiclient.generated.infrastructure.MultiValueMap
+import dev.hho.android.data.apiclient.generated.infrastructure.PartConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestConfig
+import dev.hho.android.data.apiclient.generated.infrastructure.RequestMethod
+import dev.hho.android.data.apiclient.generated.infrastructure.ResponseType
+import dev.hho.android.data.apiclient.generated.infrastructure.Success
+import dev.hho.android.data.apiclient.generated.infrastructure.toMultiValue
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+
+open class SyncApi(basePath: kotlin.String = defaultBasePath, client: Call.Factory = ApiClient.defaultClient) : ApiClient(basePath, client) {
+    companion object {
+        @JvmStatic
+        val defaultBasePath: String by lazy {
+            System.getProperties().getProperty(ApiClient.BASE_URL_KEY, "/api/v1")
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun listSyncConflicts(limit: kotlin.Int? = 50, after: kotlin.String? = null, xHHOClientVersion: kotlin.String? = null) : SyncConflictLogResponse {
+        val localVarResponse = listSyncConflictsWithHttpInfo(limit = limit, after = after, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as SyncConflictLogResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun listSyncConflictsWithHttpInfo(limit: kotlin.Int?, after: kotlin.String?, xHHOClientVersion: kotlin.String?) : ApiResponse<SyncConflictLogResponse?> {
+        val localVariableConfig = listSyncConflictsRequestConfig(limit = limit, after = after, xHHOClientVersion = xHHOClientVersion)
+
+        return request<Unit, SyncConflictLogResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun listSyncConflictsRequestConfig(limit: kotlin.Int?, after: kotlin.String?, xHHOClientVersion: kotlin.String?) : RequestConfig<Unit> {
+        val localVariableBody = null
+        val localVariableQuery: MultiValueMap = mutableMapOf<kotlin.String, kotlin.collections.List<kotlin.String>>()
+            .apply {
+                if (limit != null) {
+                    put("limit", listOf(limit.toString()))
+                }
+                if (after != null) {
+                    put("after", listOf(after.toString()))
+                }
+            }
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.GET,
+            path = "/sync/conflicts",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun syncPull(syncPullRequest: SyncPullRequest, xHHOClientVersion: kotlin.String? = null) : SyncPullResponse {
+        val localVarResponse = syncPullWithHttpInfo(syncPullRequest = syncPullRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as SyncPullResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun syncPullWithHttpInfo(syncPullRequest: SyncPullRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<SyncPullResponse?> {
+        val localVariableConfig = syncPullRequestConfig(syncPullRequest = syncPullRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<SyncPullRequest, SyncPullResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun syncPullRequestConfig(syncPullRequest: SyncPullRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<SyncPullRequest> {
+        val localVariableBody = syncPullRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/sync/pull",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class, UnsupportedOperationException::class, ClientException::class, ServerException::class)
+    fun syncPush(syncPushRequest: SyncPushRequest, xHHOClientVersion: kotlin.String? = null) : SyncPushResponse {
+        val localVarResponse = syncPushWithHttpInfo(syncPushRequest = syncPushRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return when (localVarResponse.responseType) {
+            ResponseType.Success -> (localVarResponse as Success<*>).data as SyncPushResponse
+            ResponseType.Informational -> throw UnsupportedOperationException("Client does not support Informational responses.")
+            ResponseType.Redirection -> throw UnsupportedOperationException("Client does not support Redirection responses.")
+            ResponseType.ClientError -> {
+                val localVarError = localVarResponse as ClientError<*>
+                throw ClientException("Client error : ${localVarError.statusCode} ${localVarError.message.orEmpty()}", localVarError.statusCode, localVarResponse)
+            }
+            ResponseType.ServerError -> {
+                val localVarError = localVarResponse as ServerError<*>
+                throw ServerException("Server error : ${localVarError.statusCode} ${localVarError.message.orEmpty()} ${localVarError.body}", localVarError.statusCode, localVarResponse)
+            }
+        }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    @Throws(IllegalStateException::class, IOException::class)
+    fun syncPushWithHttpInfo(syncPushRequest: SyncPushRequest, xHHOClientVersion: kotlin.String?) : ApiResponse<SyncPushResponse?> {
+        val localVariableConfig = syncPushRequestConfig(syncPushRequest = syncPushRequest, xHHOClientVersion = xHHOClientVersion)
+
+        return request<SyncPushRequest, SyncPushResponse>(
+            localVariableConfig
+        )
+    }
+
+    fun syncPushRequestConfig(syncPushRequest: SyncPushRequest, xHHOClientVersion: kotlin.String?) : RequestConfig<SyncPushRequest> {
+        val localVariableBody = syncPushRequest
+        val localVariableQuery: MultiValueMap = mutableMapOf()
+        val localVariableHeaders: MutableMap<String, String> = mutableMapOf()
+        localVariableHeaders["Content-Type"] = "application/json"
+        localVariableHeaders["Accept"] = "application/json, application/problem+json"
+        xHHOClientVersion?.apply { localVariableHeaders["X-HHO-Client-Version"] = this.toString() }
+
+        return RequestConfig(
+            method = RequestMethod.POST,
+            path = "/sync/push",
+            query = localVariableQuery,
+            headers = localVariableHeaders,
+            requiresAuthentication = true,
+            body = localVariableBody
+        )
+    }
+
+    private fun encodeURIComponent(uriComponent: kotlin.String): kotlin.String =
+        HttpUrl.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/ApiAbstractions.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/ApiAbstractions.kt
new file mode 100644
index 0000000..4a32dcb
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/ApiAbstractions.kt
@@ -0,0 +1,23 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+typealias MultiValueMap = MutableMap<String,List<String>>
+
+fun collectionDelimiter(collectionFormat: String): String = when(collectionFormat) {
+    "csv" -> ","
+    "tsv" -> "\t"
+    "pipe" -> "|"
+    "space" -> " "
+    else -> ""
+}
+
+val defaultMultiValueConverter: (item: Any?) -> String = { item -> "$item" }
+
+fun <T : Any?> toMultiValue(items: Array<T>, collectionFormat: String, map: (item: T) -> String = defaultMultiValueConverter): List<String>
+        = toMultiValue(items.asIterable(), collectionFormat, map)
+
+fun <T : Any?> toMultiValue(items: Iterable<T>, collectionFormat: String, map: (item: T) -> String = defaultMultiValueConverter): List<String> {
+    return when(collectionFormat) {
+        "multi" -> items.map(map)
+        else -> listOf(items.joinToString(separator = collectionDelimiter(collectionFormat), transform = map))
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/ApiClient.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/ApiClient.kt
new file mode 100644
index 0000000..e2fcd66
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/ApiClient.kt
@@ -0,0 +1,411 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import okhttp3.OkHttpClient
+import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.asRequestBody
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.FormBody
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import okhttp3.ResponseBody
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.Request
+import okhttp3.Headers
+import okhttp3.Headers.Builder
+import okhttp3.Headers.Companion.toHeaders
+import okhttp3.MultipartBody
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.Response
+import java.io.BufferedWriter
+import java.io.File
+import java.io.FileWriter
+import java.io.IOException
+import java.net.URLConnection
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.LocalTime
+import java.time.OffsetDateTime
+import java.time.OffsetTime
+import java.util.Locale
+import java.util.regex.Pattern
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+
+val EMPTY_REQUEST: RequestBody = ByteArray(0).toRequestBody()
+
+open class ApiClient(val baseUrl: String, val client: Call.Factory = defaultClient) {
+    companion object {
+        protected const val CONTENT_TYPE: String = "Content-Type"
+        @Deprecated(
+          message = "Please use the capitalized constant `CONTENT_TYPE` instead.",
+          replaceWith = ReplaceWith("CONTENT_TYPE")
+        )
+        protected const val ContentType: String = CONTENT_TYPE
+
+        protected const val ACCEPT: String = "Accept"
+        @Deprecated(
+          message = "Please use the capitalized constant `ACCEPT` instead.",
+          replaceWith = ReplaceWith("ACCEPT")
+        )
+        protected const val Accept: String = ACCEPT
+
+        protected const val AUTHORIZATION: String = "Authorization"
+        @Deprecated(
+          message = "Please use the capitalized constant `AUTHORIZATION` instead.",
+          replaceWith = ReplaceWith("AUTHORIZATION")
+        )
+        protected const val Authorization: String = AUTHORIZATION
+
+        protected const val JSON_MEDIA_TYPE: String = "application/json"
+        @Deprecated(
+          message = "Please use the capitalized constant `JSON_MEDIA_TYPE` instead.",
+          replaceWith = ReplaceWith("JSON_MEDIA_TYPE")
+        )
+        protected const val JsonMediaType: String = JSON_MEDIA_TYPE
+
+        protected const val FORM_DATA_MEDIA_TYPE: String = "multipart/form-data"
+        @Deprecated(
+          message = "Please use the capitalized constant `FORM_DATA_MEDIA_TYPE` instead.",
+          replaceWith = ReplaceWith("FORM_DATA_MEDIA_TYPE")
+        )
+        protected const val FormDataMediaType: String = FORM_DATA_MEDIA_TYPE
+
+        protected const val FORM_URL_ENC_MEDIA_TYPE: String = "application/x-www-form-urlencoded"
+        @Deprecated(
+          message = "Please use the capitalized constant `FORM_URL_ENC_MEDIA_TYPE` instead.",
+          replaceWith = ReplaceWith("FORM_URL_ENC_MEDIA_TYPE")
+        )
+        protected const val FormUrlEncMediaType: String = FORM_URL_ENC_MEDIA_TYPE
+
+        protected const val XML_MEDIA_TYPE: String = "application/xml"
+        @Deprecated(
+          message = "Please use the capitalized constant `XML_MEDIA_TYPE` instead.",
+          replaceWith = ReplaceWith("XML_MEDIA_TYPE")
+        )
+        protected const val XmlMediaType: String = XML_MEDIA_TYPE
+
+        protected const val OCTET_MEDIA_TYPE: String = "application/octet-stream"
+        @Deprecated(
+          message = "Please use the capitalized constant `OCTET_MEDIA_TYPE` instead.",
+          replaceWith = ReplaceWith("OCTET_MEDIA_TYPE")
+        )
+        protected const val OctetMediaType: String = OCTET_MEDIA_TYPE
+
+        protected const val TEXT_MEDIA_TYPE: String = "text/plain"
+        @Deprecated(
+          message = "Please use the capitalized constant `TEXT_MEDIA_TYPE` instead.",
+          replaceWith = ReplaceWith("TEXT_MEDIA_TYPE")
+        )
+        protected const val TextMediaType: String = TEXT_MEDIA_TYPE
+
+        const val BASE_URL_KEY: String = "dev.hho.android.data.apiclient.generated.baseUrl"
+        @Deprecated(
+          message = "Please use the capitalized constant `BASE_URL_KEY` instead.",
+          replaceWith = ReplaceWith("BASE_URL_KEY")
+        )
+        const val baseUrlKey: String = BASE_URL_KEY
+
+        val apiKey: MutableMap<String, String> = mutableMapOf()
+        val apiKeyPrefix: MutableMap<String, String> = mutableMapOf()
+        var username: String? = null
+        var password: String? = null
+        var accessToken: String? = null
+
+        @JvmStatic
+        val defaultClient: OkHttpClient by lazy {
+            builder.build()
+        }
+
+        @JvmStatic
+        val builder: OkHttpClient.Builder = OkHttpClient.Builder()
+    }
+
+    var userCredentialsProvider: () -> Pair<String?, String?> = { username to password }
+    var accessTokenProvider: () -> String? = { accessToken }
+
+    protected fun guessContentTypeFromByteArray(byteArray: ByteArray): String {
+        val contentType = try {
+            URLConnection.guessContentTypeFromStream(byteArray.inputStream())
+        } catch (_: IOException) {
+            "application/octet-stream"
+        }
+        return contentType
+    }
+
+    protected fun guessContentTypeFromFile(file: File): String {
+        val contentType = URLConnection.guessContentTypeFromName(file.name)
+        return contentType ?: "application/octet-stream"
+    }
+
+    protected fun buildPartHeaders(name: String, headers: Map<String, String>, filename: String? = null): Headers {
+        val disposition = if (filename != null) {
+            "form-data; name=\"$name\"; filename=\"$filename\""
+        } else {
+            "form-data; name=\"$name\""
+        }
+        return (headers.filterKeys { it != "Content-Type" } + ("Content-Disposition" to disposition)).toHeaders()
+    }
+
+    protected fun MultipartBody.Builder.addPartToMultiPart(name: String, headers: Map<String, String>, file: File) {
+        val fileMediaType = guessContentTypeFromFile(file).toMediaTypeOrNull()
+        addPart(
+            buildPartHeaders(name, headers, file.name),
+            file.asRequestBody(fileMediaType)
+        )
+    }
+
+    protected fun serializePartBody(obj: Any?, contentType: String?, serializer: ((Any?) -> String)?): String {
+        if (serializer != null) {
+            return serializer(obj)
+        }
+
+        return if (contentType?.contains("json") == true) {
+            parameterToString(obj)
+        } else {
+            parameterToString(obj)
+        }
+    }
+
+    protected fun MultipartBody.Builder.addPartToMultiPart(name: String, headers: Map<String, String>, obj: Any?, serializer: ((Any?) -> String)? = null) {
+        val partContentType = headers["Content-Type"]
+        val partMediaType = partContentType?.toMediaTypeOrNull()
+        val partBody = serializePartBody(obj, partContentType, serializer)
+        addPart(
+            buildPartHeaders(name, headers),
+            partBody.toRequestBody(partMediaType)
+        )
+    }
+
+    protected inline fun <reified T> requestBody(content: T, mediaType: String?): RequestBody =
+        when {
+            content is ByteArray -> content.toRequestBody((mediaType ?: guessContentTypeFromByteArray(content)).toMediaTypeOrNull())
+            content is File -> content.asRequestBody((mediaType ?: guessContentTypeFromFile(content)).toMediaTypeOrNull())
+            mediaType == FORM_DATA_MEDIA_TYPE ->
+                MultipartBody.Builder()
+                    .setType(MultipartBody.FORM)
+                    .apply {
+                        @Suppress("UNCHECKED_CAST")
+                        (content as Map<String, PartConfig<*>>).forEach { (name, part) ->
+                            when (part.body) {
+                                is File -> addPartToMultiPart(name, part.headers, part.body)
+                                is List<*> -> {
+                                    part.body.forEach {
+                                        if (it is File) {
+                                            addPartToMultiPart(name, part.headers, it)
+                                        } else {
+                                            addPartToMultiPart(name, part.headers, it, part.serializer)
+                                        }
+                                    }
+                               }
+                               else -> addPartToMultiPart(name, part.headers, part.body, part.serializer)
+                            }
+                        }
+                    }.build()
+            mediaType == FORM_URL_ENC_MEDIA_TYPE -> {
+                FormBody.Builder().apply {
+                    @Suppress("UNCHECKED_CAST")
+                    (content as Map<String, PartConfig<*>>).forEach { (name, part) ->
+                        add(name, parameterToString(part.body))
+                    }
+                }.build()
+            }
+            mediaType == null || mediaType.startsWith("application/") && mediaType.endsWith("json") ->
+                if (content == null) {
+                    EMPTY_REQUEST
+                } else {
+                    Serializer.kotlinxSerializationJson.encodeToString(content)
+                        .toRequestBody((mediaType ?: JSON_MEDIA_TYPE).toMediaTypeOrNull())
+                }
+            mediaType == XML_MEDIA_TYPE -> throw UnsupportedOperationException("xml not currently supported.")
+            mediaType == TEXT_MEDIA_TYPE -> {
+                val textualContent = when (content) {
+                    is Char, is CharSequence -> content.toString()
+                    is Number -> content.toString()
+                    is Boolean -> content.toString()
+                    else -> throw UnsupportedOperationException("requestBody currently only supports text body containing primitive types: characters, numbers, or booleans.")
+                }
+                textualContent.toRequestBody(mediaType.toMediaTypeOrNull())
+            }
+            else -> throw UnsupportedOperationException("requestBody currently only supports JSON body, text body, byte body and File body.")
+        }
+
+    protected inline fun <reified T: Any?> responseBody(response: Response, mediaType: String? = JSON_MEDIA_TYPE): T? {
+        val body = response.body ?: return null
+
+        if (T::class.java == Unit::class.java) {
+            return null
+        } else if (T::class.java == File::class.java) {
+            val contentDisposition = response.header("Content-Disposition")
+
+            val fileName = if (contentDisposition != null) {
+                val pattern = Pattern.compile("filename=['\"]?([^'\"\\s]+)['\"]?")
+                val matcher = pattern.matcher(contentDisposition)
+                if (matcher.find()) {
+                    matcher.group(1)
+                        ?.replace(".*[/\\\\]", "")
+                        ?.replace(";", "")
+                } else {
+                    null
+                }
+            } else {
+                null
+            }
+
+            var prefix: String?
+            val suffix: String?
+            if (fileName == null) {
+                prefix = "download"
+                suffix = ""
+            } else {
+                val pos = fileName.lastIndexOf(".")
+                if (pos == -1) {
+                    prefix = fileName
+                    suffix = null
+                } else {
+                    prefix = fileName.substring(0, pos)
+                    suffix = fileName.substring(pos)
+                }
+                if (prefix.length < 3) {
+                    prefix = "download"
+                }
+            }
+
+            val tempFile = java.nio.file.Files.createTempFile(prefix, suffix).toFile()
+            tempFile.deleteOnExit()
+            body.byteStream().use { inputStream ->
+                tempFile.outputStream().use { tempFileOutputStream ->
+                    inputStream.copyTo(tempFileOutputStream)
+                }
+            }
+            return tempFile as T
+        }
+
+        return when {
+            mediaType == null || (mediaType.startsWith("application/") && mediaType.endsWith("json")) -> {
+                val bodyContent = body.string()
+                if (bodyContent.isEmpty()) {
+                    return null
+                }
+                Serializer.kotlinxSerializationJson.decodeFromString<T>(bodyContent)
+            }
+            mediaType == OCTET_MEDIA_TYPE -> body.bytes() as? T
+            mediaType == TEXT_MEDIA_TYPE -> body.string() as? T
+            else ->  throw UnsupportedOperationException("responseBody currently only supports JSON body, text body and byte body.")
+        }
+    }
+
+    protected fun <T> updateAuthParams(requestConfig: RequestConfig<T>) {
+            if (apiKey["hho_session"] != null) {
+                if (apiKeyPrefix["hho_session"] != null) {
+                } else {
+                }
+            }
+        if (requestConfig.headers[AUTHORIZATION].isNullOrEmpty()) {
+            accessTokenProvider()?.let { token ->
+                requestConfig.headers[AUTHORIZATION] = "Bearer $token"
+            }
+        }
+    }
+
+    protected inline fun <reified I, reified T: Any?> request(requestConfig: RequestConfig<I>): ApiResponse<T?> {
+        val httpUrl = baseUrl.toHttpUrlOrNull() ?: throw IllegalStateException("baseUrl is invalid.")
+
+        updateAuthParams(requestConfig)
+
+        val url = httpUrl.newBuilder()
+            .addEncodedPathSegments(requestConfig.path.trimStart('/'))
+            .apply {
+                requestConfig.query.forEach { query ->
+                    query.value.forEach { queryValue ->
+                        addQueryParameter(query.key, queryValue)
+                    }
+                }
+            }.build()
+
+        if (requestConfig.body != null && requestConfig.headers[CONTENT_TYPE].isNullOrEmpty()) {
+            requestConfig.headers[CONTENT_TYPE] = JSON_MEDIA_TYPE
+        }
+        if (requestConfig.headers[ACCEPT].isNullOrEmpty()) {
+            requestConfig.headers[ACCEPT] = JSON_MEDIA_TYPE
+        }
+        val headers = requestConfig.headers
+
+        if (headers[ACCEPT].isNullOrEmpty()) {
+            throw kotlin.IllegalStateException("Missing ACCEPT header. This is required.")
+        }
+
+        val contentType = if (headers[CONTENT_TYPE] != null) {
+            (headers[CONTENT_TYPE] as String).substringBefore(";").lowercase(Locale.US)
+        } else {
+            null
+        }
+
+        val request = when (requestConfig.method) {
+            RequestMethod.DELETE -> Request.Builder().url(url).delete(requestBody(requestConfig.body, contentType))
+            RequestMethod.GET -> Request.Builder().url(url)
+            RequestMethod.HEAD -> Request.Builder().url(url).head()
+            RequestMethod.PATCH -> Request.Builder().url(url).patch(requestBody(requestConfig.body, contentType))
+            RequestMethod.PUT -> Request.Builder().url(url).put(requestBody(requestConfig.body, contentType))
+            RequestMethod.POST -> Request.Builder().url(url).post(requestBody(requestConfig.body, contentType))
+            RequestMethod.OPTIONS -> Request.Builder().url(url).method("OPTIONS", null)
+        }.apply {
+            val headersBuilder = Headers.Builder()
+            headers.forEach { header ->
+                headersBuilder.add(header.key, header.value)
+            }
+            this.headers(headersBuilder.build())
+        }.build()
+
+        val response = client.newCall(request).execute()
+
+        val accept = response.header(CONTENT_TYPE)?.substringBefore(";")?.lowercase(Locale.US)
+
+        @Suppress("UNNECESSARY_SAFE_CALL")
+        return response.use {
+            when {
+                it.isRedirect -> Redirection(
+                    it.code,
+                    it.headers.toMultimap()
+                )
+                it.isInformational -> Informational(
+                    it.message,
+                    it.code,
+                    it.headers.toMultimap()
+                )
+                it.isSuccessful -> Success(
+                    responseBody(it, accept),
+                    it.code,
+                    it.headers.toMultimap()
+                )
+                it.isClientError -> ClientError(
+                    it.message,
+                    it.body?.string(),
+                    it.code,
+                    it.headers.toMultimap()
+                )
+                else -> ServerError(
+                    it.message,
+                    it.body?.string(),
+                    it.code,
+                    it.headers.toMultimap()
+                )
+            }
+        }
+    }
+
+    protected fun parameterToString(value: Any?): String = when (value) {
+        null -> ""
+        is Array<*> -> toMultiValue(value, "csv").toString()
+        is Iterable<*> -> toMultiValue(value, "csv").toString()
+        is OffsetDateTime -> parseDateToQueryString<OffsetDateTime>(value)
+        is OffsetTime -> parseDateToQueryString<OffsetTime>(value)
+        is LocalDateTime -> parseDateToQueryString<LocalDateTime>(value)
+        is LocalDate -> parseDateToQueryString<LocalDate>(value)
+        is LocalTime -> parseDateToQueryString<LocalTime>(value)
+        else -> value.toString()
+    }
+
+    protected inline fun <reified T: Any> parseDateToQueryString(value : T): String {
+        return Serializer.kotlinxSerializationJson.encodeToString(value).replace("\"", "")
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/ApiResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/ApiResponse.kt
new file mode 100644
index 0000000..07b0ac9
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/ApiResponse.kt
@@ -0,0 +1,43 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+enum class ResponseType {
+    Success, Informational, Redirection, ClientError, ServerError
+}
+
+interface Response
+
+abstract class ApiResponse<T>(val responseType: ResponseType): Response {
+    abstract val statusCode: Int
+    abstract val headers: Map<String,List<String>>
+}
+
+class Success<T>(
+    val data: T,
+    override val statusCode: Int = -1,
+    override val headers: Map<String, List<String>> = mapOf()
+): ApiResponse<T>(ResponseType.Success)
+
+class Informational<T>(
+    val statusText: String,
+    override val statusCode: Int = -1,
+    override val headers: Map<String, List<String>> = mapOf()
+) : ApiResponse<T>(ResponseType.Informational)
+
+class Redirection<T>(
+    override val statusCode: Int = -1,
+    override val headers: Map<String, List<String>> = mapOf()
+) : ApiResponse<T>(ResponseType.Redirection)
+
+class ClientError<T>(
+    val message: String? = null,
+    val body: Any? = null,
+    override val statusCode: Int = -1,
+    override val headers: Map<String, List<String>> = mapOf()
+) : ApiResponse<T>(ResponseType.ClientError)
+
+class ServerError<T>(
+    val message: String? = null,
+    val body: Any? = null,
+    override val statusCode: Int = -1,
+    override val headers: Map<String, List<String>> = mapOf()
+): ApiResponse<T>(ResponseType.ServerError)
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/AtomicBooleanAdapter.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/AtomicBooleanAdapter.kt
new file mode 100644
index 0000000..8adf646
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/AtomicBooleanAdapter.kt
@@ -0,0 +1,19 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.util.concurrent.atomic.AtomicBoolean
+
+object AtomicBooleanAdapter : KSerializer<AtomicBoolean> {
+    override fun serialize(encoder: Encoder, value: AtomicBoolean) {
+        encoder.encodeBoolean(value.get())
+    }
+
+    override fun deserialize(decoder: Decoder): AtomicBoolean = AtomicBoolean(decoder.decodeBoolean())
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("AtomicBoolean", PrimitiveKind.BOOLEAN)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/AtomicIntegerAdapter.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/AtomicIntegerAdapter.kt
new file mode 100644
index 0000000..5a264ca
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/AtomicIntegerAdapter.kt
@@ -0,0 +1,19 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.util.concurrent.atomic.AtomicInteger
+
+object AtomicIntegerAdapter : KSerializer<AtomicInteger> {
+    override fun serialize(encoder: Encoder, value: AtomicInteger) {
+        encoder.encodeInt(value.get())
+    }
+
+    override fun deserialize(decoder: Decoder): AtomicInteger = AtomicInteger(decoder.decodeInt())
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("AtomicInteger", PrimitiveKind.INT)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/AtomicLongAdapter.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/AtomicLongAdapter.kt
new file mode 100644
index 0000000..e06a331
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/AtomicLongAdapter.kt
@@ -0,0 +1,19 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.util.concurrent.atomic.AtomicLong
+
+object AtomicLongAdapter : KSerializer<AtomicLong> {
+    override fun serialize(encoder: Encoder, value: AtomicLong) {
+        encoder.encodeLong(value.get())
+    }
+
+    override fun deserialize(decoder: Decoder): AtomicLong = AtomicLong(decoder.decodeLong())
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("AtomicLong", PrimitiveKind.LONG)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/BigDecimalAdapter.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/BigDecimalAdapter.kt
new file mode 100644
index 0000000..19e46d9
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/BigDecimalAdapter.kt
@@ -0,0 +1,15 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.math.BigDecimal
+
+object BigDecimalAdapter : KSerializer<BigDecimal> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("BigDecimal", PrimitiveKind.STRING)
+    override fun deserialize(decoder: Decoder): BigDecimal = BigDecimal(decoder.decodeString())
+    override fun serialize(encoder: Encoder, value: BigDecimal) = encoder.encodeString(value.toPlainString())
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/BigIntegerAdapter.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/BigIntegerAdapter.kt
new file mode 100644
index 0000000..57cb27a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/BigIntegerAdapter.kt
@@ -0,0 +1,20 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.math.BigInteger
+
+object BigIntegerAdapter : KSerializer<BigInteger> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("BigInteger", PrimitiveKind.STRING)
+    override fun deserialize(decoder: Decoder): BigInteger {
+        return BigInteger(decoder.decodeString())
+    }
+
+    override fun serialize(encoder: Encoder, value: BigInteger) {
+        encoder.encodeString(value.toString())
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/Errors.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/Errors.kt
new file mode 100644
index 0000000..506f888
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/Errors.kt
@@ -0,0 +1,18 @@
+@file:Suppress("unused")
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import java.lang.RuntimeException
+
+open class ClientException(message: kotlin.String? = null, val statusCode: Int = -1, val response: Response? = null) : RuntimeException(message) {
+
+    companion object {
+        private const val serialVersionUID: Long = 123L
+    }
+}
+
+open class ServerException(message: kotlin.String? = null, val statusCode: Int = -1, val response: Response? = null) : RuntimeException(message) {
+
+    companion object {
+        private const val serialVersionUID: Long = 456L
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/LocalDateAdapter.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/LocalDateAdapter.kt
new file mode 100644
index 0000000..2c75b6e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/LocalDateAdapter.kt
@@ -0,0 +1,22 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+
+object LocalDateAdapter : KSerializer<LocalDate> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("LocalDate", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: LocalDate) {
+        encoder.encodeString(DateTimeFormatter.ISO_LOCAL_DATE.format(value))
+    }
+
+    override fun deserialize(decoder: Decoder): LocalDate {
+        return LocalDate.parse(decoder.decodeString(), DateTimeFormatter.ISO_LOCAL_DATE)
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/LocalDateTimeAdapter.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/LocalDateTimeAdapter.kt
new file mode 100644
index 0000000..6e4f43a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/LocalDateTimeAdapter.kt
@@ -0,0 +1,22 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+
+object LocalDateTimeAdapter : KSerializer<LocalDateTime> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("LocalDateTime", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: LocalDateTime) {
+        encoder.encodeString(DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(value))
+    }
+
+    override fun deserialize(decoder: Decoder): LocalDateTime {
+        return LocalDateTime.parse(decoder.decodeString(), DateTimeFormatter.ISO_LOCAL_DATE_TIME)
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/OffsetDateTimeAdapter.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/OffsetDateTimeAdapter.kt
new file mode 100644
index 0000000..076702b
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/OffsetDateTimeAdapter.kt
@@ -0,0 +1,22 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.time.OffsetDateTime
+import java.time.format.DateTimeFormatter
+
+object OffsetDateTimeAdapter : KSerializer<OffsetDateTime> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("OffsetDateTime", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: OffsetDateTime) {
+        encoder.encodeString(DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(value))
+    }
+
+    override fun deserialize(decoder: Decoder): OffsetDateTime {
+        return OffsetDateTime.parse(decoder.decodeString(), DateTimeFormatter.ISO_OFFSET_DATE_TIME)
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/PartConfig.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/PartConfig.kt
new file mode 100644
index 0000000..afe11e1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/PartConfig.kt
@@ -0,0 +1,7 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+data class PartConfig<T>(
+    val headers: MutableMap<String, String> = mutableMapOf(),
+    val body: T? = null,
+    val serializer: ((Any?) -> String)? = null
+)
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/RequestConfig.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/RequestConfig.kt
new file mode 100644
index 0000000..3ed12fa
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/RequestConfig.kt
@@ -0,0 +1,11 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+data class RequestConfig<T>(
+    val method: RequestMethod,
+    val path: String,
+    val headers: MutableMap<String, String> = mutableMapOf(),
+    val params: MutableMap<String, Any> = mutableMapOf(),
+    val query: MutableMap<String, List<String>> = mutableMapOf(),
+    val requiresAuthentication: Boolean,
+    val body: T? = null
+)
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/RequestMethod.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/RequestMethod.kt
new file mode 100644
index 0000000..4856c3e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/RequestMethod.kt
@@ -0,0 +1,5 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+enum class RequestMethod {
+    GET, DELETE, HEAD, OPTIONS, PATCH, POST, PUT
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/ResponseExtensions.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/ResponseExtensions.kt
new file mode 100644
index 0000000..7911420
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/ResponseExtensions.kt
@@ -0,0 +1,12 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import okhttp3.Response
+
+val Response.isInformational : Boolean get() = this.code in 100..199
+
+@Suppress("EXTENSION_SHADOWED_BY_MEMBER")
+val Response.isRedirect : Boolean get() = this.code in 300..399
+
+val Response.isClientError : Boolean get() = this.code in 400..499
+
+val Response.isServerError : Boolean get() = this.code in 500..999
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/Serializer.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/Serializer.kt
new file mode 100644
index 0000000..c20795f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/Serializer.kt
@@ -0,0 +1,73 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import java.math.BigDecimal
+import java.math.BigInteger
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.OffsetDateTime
+import java.util.UUID
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonBuilder
+import kotlinx.serialization.modules.SerializersModule
+import kotlinx.serialization.modules.SerializersModuleBuilder
+import java.net.URI
+import java.net.URL
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicLong
+
+object Serializer {
+    private var isAdaptersInitialized = false
+
+    @JvmStatic
+    val kotlinxSerializationAdapters: SerializersModule by lazy {
+        isAdaptersInitialized = true
+        SerializersModule {
+            contextual(BigDecimal::class, BigDecimalAdapter)
+            contextual(BigInteger::class, BigIntegerAdapter)
+            contextual(LocalDate::class, LocalDateAdapter)
+            contextual(LocalDateTime::class, LocalDateTimeAdapter)
+            contextual(OffsetDateTime::class, OffsetDateTimeAdapter)
+            contextual(UUID::class, UUIDAdapter)
+            contextual(AtomicInteger::class, AtomicIntegerAdapter)
+            contextual(AtomicLong::class, AtomicLongAdapter)
+            contextual(AtomicBoolean::class, AtomicBooleanAdapter)
+            contextual(URI::class, URIAdapter)
+            contextual(URL::class, URLAdapter)
+            contextual(StringBuilder::class, StringBuilderAdapter)
+
+            apply(kotlinxSerializationAdaptersConfiguration)
+        }
+    }
+
+    var kotlinxSerializationAdaptersConfiguration: SerializersModuleBuilder.() -> Unit = {}
+        set(value) {
+            check(!isAdaptersInitialized) {
+                "Cannot configure kotlinxSerializationAdaptersConfiguration after kotlinxSerializationAdapters has been initialized."
+            }
+            field = value
+        }
+
+    private var isJsonInitialized = false
+
+    @JvmStatic
+    val kotlinxSerializationJson: Json by lazy {
+        isJsonInitialized = true
+        Json {
+            serializersModule = kotlinxSerializationAdapters
+            encodeDefaults = true
+            ignoreUnknownKeys = true
+            isLenient = true
+
+            apply(kotlinxSerializationJsonConfiguration)
+        }
+    }
+
+    var kotlinxSerializationJsonConfiguration: JsonBuilder.() -> Unit = {}
+        set(value) {
+            check(!isJsonInitialized) {
+                "Cannot configure kotlinxSerializationJsonConfiguration after kotlinxSerializationJson has been initialized."
+            }
+            field = value
+        }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/StringBuilderAdapter.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/StringBuilderAdapter.kt
new file mode 100644
index 0000000..ae5d66f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/StringBuilderAdapter.kt
@@ -0,0 +1,18 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+
+object StringBuilderAdapter : KSerializer<StringBuilder> {
+    override fun serialize(encoder: Encoder, value: StringBuilder) {
+        encoder.encodeString(value.toString())
+    }
+
+    override fun deserialize(decoder: Decoder): StringBuilder = StringBuilder(decoder.decodeString())
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("StringBuilder", PrimitiveKind.STRING)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/URIAdapter.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/URIAdapter.kt
new file mode 100644
index 0000000..4f7d7fd
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/URIAdapter.kt
@@ -0,0 +1,19 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.net.URI
+
+object URIAdapter : KSerializer<URI> {
+    override fun serialize(encoder: Encoder, value: URI) {
+        encoder.encodeString(value.toASCIIString())
+    }
+
+    override fun deserialize(decoder: Decoder): URI = URI(decoder.decodeString())
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("URI", PrimitiveKind.STRING)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/URLAdapter.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/URLAdapter.kt
new file mode 100644
index 0000000..8ff7e97
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/URLAdapter.kt
@@ -0,0 +1,19 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.net.URL
+
+object URLAdapter : KSerializer<URL> {
+    override fun serialize(encoder: Encoder, value: URL) {
+        encoder.encodeString(value.toExternalForm())
+    }
+
+    override fun deserialize(decoder: Decoder): URL = URL(decoder.decodeString())
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("URL", PrimitiveKind.STRING)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/UUIDAdapter.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/UUIDAdapter.kt
new file mode 100644
index 0000000..786a4e4
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/infrastructure/UUIDAdapter.kt
@@ -0,0 +1,21 @@
+package dev.hho.android.data.apiclient.generated.infrastructure
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.SerialDescriptor
+import java.util.UUID
+
+object UUIDAdapter : KSerializer<UUID> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("UUID", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: UUID) {
+        encoder.encodeString(value.toString())
+    }
+
+    override fun deserialize(decoder: Decoder): UUID {
+        return UUID.fromString(decoder.decodeString())
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Attachment.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Attachment.kt
new file mode 100644
index 0000000..2b37b36
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Attachment.kt
@@ -0,0 +1,70 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class Attachment (
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "item_id")
+    val itemId: kotlin.String,
+
+    @SerialName(value = "category")
+    val category: Attachment.Category,
+
+    @SerialName(value = "original_filename")
+    val originalFilename: kotlin.String,
+
+    @SerialName(value = "content_type")
+    val contentType: kotlin.String,
+
+    @SerialName(value = "size_bytes")
+    val sizeBytes: kotlin.Long,
+
+    @SerialName(value = "sha256")
+    val sha256: kotlin.String,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long,
+
+    @SerialName(value = "updated_at")
+    val updatedAt: kotlin.Long,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long,
+
+    @SerialName(value = "has_thumbnail")
+    val hasThumbnail: kotlin.Boolean
+
+) {
+    @Serializable
+    enum class Category(val value: kotlin.String) {
+        @SerialName(value = "image") Image("image"),
+        @SerialName(value = "manual") Manual("manual"),
+        @SerialName(value = "warranty") Warranty("warranty"),
+        @SerialName(value = "receipt") Receipt("receipt"),
+        @SerialName(value = "general") General("general");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/AttachmentListResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/AttachmentListResponse.kt
new file mode 100644
index 0000000..e8c6a65
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/AttachmentListResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.Attachment
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class AttachmentListResponse (
+
+    @SerialName(value = "attachments")
+    val attachments: kotlin.collections.List<Attachment>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/CustomFieldDef.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/CustomFieldDef.kt
new file mode 100644
index 0000000..65fa315
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/CustomFieldDef.kt
@@ -0,0 +1,57 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class CustomFieldDef (
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "field_type")
+    val fieldType: CustomFieldDef.FieldType,
+
+    @SerialName(value = "display_order")
+    val displayOrder: kotlin.Long,
+
+    @SerialName(value = "id")
+    val id: kotlin.String? = null,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long? = null,
+
+    @SerialName(value = "updated_at")
+    val updatedAt: kotlin.Long? = null,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long? = null
+
+) {
+    @Serializable
+    enum class FieldType(val value: kotlin.String) {
+        @SerialName(value = "text") Text("text"),
+        @SerialName(value = "number") Number("number"),
+        @SerialName(value = "boolean") Boolean("boolean"),
+        @SerialName(value = "date") Date("date");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/CustomFieldDefCreateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/CustomFieldDefCreateRequest.kt
new file mode 100644
index 0000000..f79d830
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/CustomFieldDefCreateRequest.kt
@@ -0,0 +1,45 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class CustomFieldDefCreateRequest (
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "field_type")
+    val fieldType: CustomFieldDefCreateRequest.FieldType,
+
+    @SerialName(value = "display_order")
+    val displayOrder: kotlin.Long
+
+) {
+    @Serializable
+    enum class FieldType(val value: kotlin.String) {
+        @SerialName(value = "text") Text("text"),
+        @SerialName(value = "number") Number("number"),
+        @SerialName(value = "boolean") Boolean("boolean"),
+        @SerialName(value = "date") Date("date");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/CustomFieldDefListResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/CustomFieldDefListResponse.kt
new file mode 100644
index 0000000..f2c8ce4
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/CustomFieldDefListResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.CustomFieldDef
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class CustomFieldDefListResponse (
+
+    @SerialName(value = "custom_field_defs")
+    val customFieldDefs: kotlin.collections.List<CustomFieldDef>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/CustomFieldDefUpdateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/CustomFieldDefUpdateRequest.kt
new file mode 100644
index 0000000..8158441
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/CustomFieldDefUpdateRequest.kt
@@ -0,0 +1,48 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class CustomFieldDefUpdateRequest (
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "field_type")
+    val fieldType: CustomFieldDefUpdateRequest.FieldType,
+
+    @SerialName(value = "display_order")
+    val displayOrder: kotlin.Long,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long
+
+) {
+    @Serializable
+    enum class FieldType(val value: kotlin.String) {
+        @SerialName(value = "text") Text("text"),
+        @SerialName(value = "number") Number("number"),
+        @SerialName(value = "boolean") Boolean("boolean"),
+        @SerialName(value = "date") Date("date");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/DeviceTokenIssueRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/DeviceTokenIssueRequest.kt
new file mode 100644
index 0000000..378c33b
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/DeviceTokenIssueRequest.kt
@@ -0,0 +1,32 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class DeviceTokenIssueRequest (
+
+    @SerialName(value = "device_label")
+    val deviceLabel: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/DeviceTokenIssueResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/DeviceTokenIssueResponse.kt
new file mode 100644
index 0000000..ff64009
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/DeviceTokenIssueResponse.kt
@@ -0,0 +1,38 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class DeviceTokenIssueResponse (
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "device_label")
+    val deviceLabel: kotlin.String,
+
+    @SerialName(value = "token")
+    val token: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/DeviceTokenListItem.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/DeviceTokenListItem.kt
new file mode 100644
index 0000000..dc85d0b
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/DeviceTokenListItem.kt
@@ -0,0 +1,44 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class DeviceTokenListItem (
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "device_label")
+    val deviceLabel: kotlin.String,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long,
+
+    @SerialName(value = "revoked")
+    val revoked: kotlin.Boolean,
+
+    @SerialName(value = "revoked_at")
+    val revokedAt: kotlin.Long? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/DeviceTokenListResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/DeviceTokenListResponse.kt
new file mode 100644
index 0000000..c9fbf1f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/DeviceTokenListResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.DeviceTokenListItem
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class DeviceTokenListResponse (
+
+    @SerialName(value = "device_tokens")
+    val deviceTokens: kotlin.collections.List<DeviceTokenListItem>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/GroupMember.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/GroupMember.kt
new file mode 100644
index 0000000..40a2c4e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/GroupMember.kt
@@ -0,0 +1,41 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class GroupMember (
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "username")
+    val username: kotlin.String,
+
+    @SerialName(value = "role")
+    val role: kotlin.String,
+
+    @SerialName(value = "joined_at")
+    val joinedAt: kotlin.Long
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/GroupMembersResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/GroupMembersResponse.kt
new file mode 100644
index 0000000..548e95f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/GroupMembersResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.GroupMember
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class GroupMembersResponse (
+
+    @SerialName(value = "members")
+    val members: kotlin.collections.List<GroupMember>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/GroupVisibility.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/GroupVisibility.kt
new file mode 100644
index 0000000..3906361
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/GroupVisibility.kt
@@ -0,0 +1,41 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class GroupVisibility (
+
+    @SerialName(value = "warranty_visible")
+    val warrantyVisible: kotlin.Boolean,
+
+    @SerialName(value = "sale_visible")
+    val saleVisible: kotlin.Boolean,
+
+    @SerialName(value = "purchase_visible")
+    val purchaseVisible: kotlin.Boolean,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/GroupVisibilityUpdateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/GroupVisibilityUpdateRequest.kt
new file mode 100644
index 0000000..2ee2410
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/GroupVisibilityUpdateRequest.kt
@@ -0,0 +1,41 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class GroupVisibilityUpdateRequest (
+
+    @SerialName(value = "warranty_visible")
+    val warrantyVisible: kotlin.Boolean,
+
+    @SerialName(value = "sale_visible")
+    val saleVisible: kotlin.Boolean,
+
+    @SerialName(value = "purchase_visible")
+    val purchaseVisible: kotlin.Boolean,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Identification.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Identification.kt
new file mode 100644
index 0000000..518c1b9
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Identification.kt
@@ -0,0 +1,57 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class Identification (
+    @SerialName(value = "kind")
+    val kind: Identification.Kind,
+
+    @SerialName(value = "value")
+    val `value`: kotlin.String,
+
+    @SerialName(value = "id")
+    val id: kotlin.String? = null,
+
+    @SerialName(value = "item_id")
+    val itemId: kotlin.String? = null,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long? = null,
+
+    @SerialName(value = "updated_at")
+    val updatedAt: kotlin.Long? = null,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long? = null
+
+) {
+    @Serializable
+    enum class Kind(val value: kotlin.String) {
+        @SerialName(value = "serial") Serial("serial"),
+        @SerialName(value = "model") Model("model"),
+        @SerialName(value = "asset_tag") AssetTag("asset_tag"),
+        @SerialName(value = "barcode") Barcode("barcode"),
+        @SerialName(value = "other") Other("other");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/IdentificationCreateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/IdentificationCreateRequest.kt
new file mode 100644
index 0000000..ead8f6a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/IdentificationCreateRequest.kt
@@ -0,0 +1,43 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class IdentificationCreateRequest (
+
+    @SerialName(value = "kind")
+    val kind: IdentificationCreateRequest.Kind,
+
+    @SerialName(value = "value")
+    val `value`: kotlin.String
+
+) {
+    @Serializable
+    enum class Kind(val value: kotlin.String) {
+        @SerialName(value = "serial") Serial("serial"),
+        @SerialName(value = "model") Model("model"),
+        @SerialName(value = "asset_tag") AssetTag("asset_tag"),
+        @SerialName(value = "barcode") Barcode("barcode"),
+        @SerialName(value = "other") Other("other");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/IdentificationListResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/IdentificationListResponse.kt
new file mode 100644
index 0000000..c494486
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/IdentificationListResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.Identification
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class IdentificationListResponse (
+
+    @SerialName(value = "identifications")
+    val identifications: kotlin.collections.List<Identification>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/IdentificationUpdateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/IdentificationUpdateRequest.kt
new file mode 100644
index 0000000..d2e70e1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/IdentificationUpdateRequest.kt
@@ -0,0 +1,46 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class IdentificationUpdateRequest (
+
+    @SerialName(value = "kind")
+    val kind: IdentificationUpdateRequest.Kind,
+
+    @SerialName(value = "value")
+    val `value`: kotlin.String,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long
+
+) {
+    @Serializable
+    enum class Kind(val value: kotlin.String) {
+        @SerialName(value = "serial") Serial("serial"),
+        @SerialName(value = "model") Model("model"),
+        @SerialName(value = "asset_tag") AssetTag("asset_tag"),
+        @SerialName(value = "barcode") Barcode("barcode"),
+        @SerialName(value = "other") Other("other");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportCommitCreatedItem.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportCommitCreatedItem.kt
new file mode 100644
index 0000000..aaad5be
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportCommitCreatedItem.kt
@@ -0,0 +1,35 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ImportCommitCreatedItem (
+
+    @SerialName(value = "line")
+    val line: kotlin.Int,
+
+    @SerialName(value = "item_id")
+    val itemId: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportCommitRejectedResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportCommitRejectedResponse.kt
new file mode 100644
index 0000000..414af53
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportCommitRejectedResponse.kt
@@ -0,0 +1,41 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.ImportPreviewRow
+import dev.hho.android.data.apiclient.generated.models.ImportPreviewSummary
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ImportCommitRejectedResponse (
+
+    @SerialName(value = "import_id")
+    val importId: kotlin.String,
+
+    @SerialName(value = "rows")
+    val rows: kotlin.collections.List<ImportPreviewRow>,
+
+    @SerialName(value = "summary")
+    val summary: ImportPreviewSummary
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportCommitResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportCommitResponse.kt
new file mode 100644
index 0000000..ff96fbc
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportCommitResponse.kt
@@ -0,0 +1,41 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.ImportCommitCreatedItem
+import dev.hho.android.data.apiclient.generated.models.ImportCommitSummary
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ImportCommitResponse (
+
+    @SerialName(value = "import_id")
+    val importId: kotlin.String,
+
+    @SerialName(value = "summary")
+    val summary: ImportCommitSummary,
+
+    @SerialName(value = "created_items")
+    val createdItems: kotlin.collections.List<ImportCommitCreatedItem>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportCommitSummary.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportCommitSummary.kt
new file mode 100644
index 0000000..b69dc67
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportCommitSummary.kt
@@ -0,0 +1,38 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ImportCommitSummary (
+
+    @SerialName(value = "created")
+    val created: kotlin.Int,
+
+    @SerialName(value = "updated")
+    val updated: kotlin.Int,
+
+    @SerialName(value = "unchanged")
+    val unchanged: kotlin.Int
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportPreviewResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportPreviewResponse.kt
new file mode 100644
index 0000000..30ea1aa
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportPreviewResponse.kt
@@ -0,0 +1,41 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.ImportPreviewRow
+import dev.hho.android.data.apiclient.generated.models.ImportPreviewSummary
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ImportPreviewResponse (
+
+    @SerialName(value = "import_id")
+    val importId: kotlin.String,
+
+    @SerialName(value = "rows")
+    val rows: kotlin.collections.List<ImportPreviewRow>,
+
+    @SerialName(value = "summary")
+    val summary: ImportPreviewSummary
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportPreviewRow.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportPreviewRow.kt
new file mode 100644
index 0000000..c766648
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportPreviewRow.kt
@@ -0,0 +1,68 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.ImportPreviewRowError
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ImportPreviewRow (
+    @SerialName(value = "line")
+    val line: kotlin.Int,
+
+    @SerialName(value = "action")
+    val action: ImportPreviewRow.Action,
+
+    @SerialName(value = "item_id")
+    val itemId: kotlin.String? = null,
+
+    @SerialName(value = "name")
+    val name: kotlin.String? = null,
+
+    @SerialName(value = "changes")
+    val changes: kotlin.collections.List<ImportPreviewRow.Changes>? = null,
+
+    @SerialName(value = "errors")
+    val errors: kotlin.collections.List<ImportPreviewRowError>? = null
+
+) {
+    @Serializable
+    enum class Action(val value: kotlin.String) {
+        @SerialName(value = "create") Create("create"),
+        @SerialName(value = "update") Update("update"),
+        @SerialName(value = "unchanged") Unchanged("unchanged"),
+        @SerialName(value = "error") Error("error");
+    }
+    @Serializable
+    enum class Changes(val value: kotlin.String) {
+        @SerialName(value = "name") Name("name"),
+        @SerialName(value = "description") Description("description"),
+        @SerialName(value = "quantity") Quantity("quantity"),
+        @SerialName(value = "location_id") LocationId("location_id"),
+        @SerialName(value = "labels") Labels("labels"),
+        @SerialName(value = "identifications") Identifications("identifications"),
+        @SerialName(value = "warranty") Warranty("warranty"),
+        @SerialName(value = "purchase") Purchase("purchase"),
+        @SerialName(value = "sale") Sale("sale"),
+        @SerialName(value = "custom_fields") CustomFields("custom_fields");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportPreviewRowError.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportPreviewRowError.kt
new file mode 100644
index 0000000..96e2165
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportPreviewRowError.kt
@@ -0,0 +1,37 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ImportPreviewRowError (
+    @SerialName(value = "line")
+    val line: kotlin.Int,
+
+    @SerialName(value = "message")
+    val message: kotlin.String,
+
+    @SerialName(value = "column")
+    val column: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportPreviewSummary.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportPreviewSummary.kt
new file mode 100644
index 0000000..0fe0480
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportPreviewSummary.kt
@@ -0,0 +1,41 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ImportPreviewSummary (
+
+    @SerialName(value = "create")
+    val create: kotlin.Int,
+
+    @SerialName(value = "update")
+    val update: kotlin.Int,
+
+    @SerialName(value = "unchanged")
+    val unchanged: kotlin.Int,
+
+    @SerialName(value = "error")
+    val error: kotlin.Int
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportUploadResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportUploadResponse.kt
new file mode 100644
index 0000000..df2bc8c
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ImportUploadResponse.kt
@@ -0,0 +1,31 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ImportUploadResponse (
+    @SerialName(value = "import_id")
+    val importId: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteCreateResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteCreateResponse.kt
new file mode 100644
index 0000000..4f0cef7
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteCreateResponse.kt
@@ -0,0 +1,38 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class InviteCreateResponse (
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "token")
+    val token: kotlin.String,
+
+    @SerialName(value = "expires_at")
+    val expiresAt: kotlin.Long
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteListItem.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteListItem.kt
new file mode 100644
index 0000000..8ae6e04
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteListItem.kt
@@ -0,0 +1,50 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class InviteListItem (
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "created_by_user_id")
+    val createdByUserId: kotlin.String,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long,
+
+    @SerialName(value = "expires_at")
+    val expiresAt: kotlin.Long,
+
+    @SerialName(value = "redeemed")
+    val redeemed: kotlin.Boolean,
+
+    @SerialName(value = "redeemed_at")
+    val redeemedAt: kotlin.Long? = null,
+
+    @SerialName(value = "redeemed_by_user_id")
+    val redeemedByUserId: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteListResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteListResponse.kt
new file mode 100644
index 0000000..6325d96
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteListResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.InviteListItem
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class InviteListResponse (
+
+    @SerialName(value = "invites")
+    val invites: kotlin.collections.List<InviteListItem>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteRedeemRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteRedeemRequest.kt
new file mode 100644
index 0000000..e3f5a5c
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteRedeemRequest.kt
@@ -0,0 +1,37 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class InviteRedeemRequest (
+    @SerialName(value = "token")
+    val token: kotlin.String,
+
+    @SerialName(value = "username")
+    val username: kotlin.String,
+
+    @SerialName(value = "password")
+    val password: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteRedeemResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteRedeemResponse.kt
new file mode 100644
index 0000000..e00c42f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/InviteRedeemResponse.kt
@@ -0,0 +1,38 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class InviteRedeemResponse (
+
+    @SerialName(value = "group_id")
+    val groupId: kotlin.String,
+
+    @SerialName(value = "user_id")
+    val userId: kotlin.String,
+
+    @SerialName(value = "username")
+    val username: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Item.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Item.kt
new file mode 100644
index 0000000..a034392
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Item.kt
@@ -0,0 +1,56 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class Item (
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "id")
+    val id: kotlin.String? = null,
+
+    @SerialName(value = "description")
+    val description: kotlin.String? = null,
+
+    @SerialName(value = "location_id")
+    val locationId: kotlin.String? = null,
+
+    @SerialName(value = "quantity")
+    val quantity: kotlin.Long? = null,
+
+    @SerialName(value = "short_code")
+    val shortCode: kotlin.String? = null,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long? = null,
+
+    @SerialName(value = "updated_at")
+    val updatedAt: kotlin.Long? = null,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemCustomField.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemCustomField.kt
new file mode 100644
index 0000000..01fbc16
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemCustomField.kt
@@ -0,0 +1,72 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ItemCustomField (
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "field_type")
+    val fieldType: ItemCustomField.FieldType,
+
+    @SerialName(value = "id")
+    val id: kotlin.String? = null,
+
+    @SerialName(value = "item_id")
+    val itemId: kotlin.String? = null,
+
+    @SerialName(value = "field_def_id")
+    val fieldDefId: kotlin.String? = null,
+
+    @SerialName(value = "text_value")
+    val textValue: kotlin.String? = null,
+
+    @Contextual @SerialName(value = "number_value")
+    val numberValue: java.math.BigDecimal? = null,
+
+    @SerialName(value = "bool_value")
+    val boolValue: kotlin.Boolean? = null,
+
+    @Contextual @SerialName(value = "date_value")
+    val dateValue: java.time.LocalDate? = null,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long? = null,
+
+    @SerialName(value = "updated_at")
+    val updatedAt: kotlin.Long? = null,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long? = null
+
+) {
+    @Serializable
+    enum class FieldType(val value: kotlin.String) {
+        @SerialName(value = "text") Text("text"),
+        @SerialName(value = "number") Number("number"),
+        @SerialName(value = "boolean") Boolean("boolean"),
+        @SerialName(value = "date") Date("date");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemCustomFieldCreateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemCustomFieldCreateRequest.kt
new file mode 100644
index 0000000..6929f28
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemCustomFieldCreateRequest.kt
@@ -0,0 +1,56 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ItemCustomFieldCreateRequest (
+    @SerialName(value = "field_def_id")
+    val fieldDefId: kotlin.String,
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "field_type")
+    val fieldType: ItemCustomFieldCreateRequest.FieldType,
+
+    @SerialName(value = "text_value")
+    val textValue: kotlin.String?,
+
+    @Contextual @SerialName(value = "number_value")
+    val numberValue: java.math.BigDecimal?,
+
+    @SerialName(value = "bool_value")
+    val boolValue: kotlin.Boolean?,
+
+    @Contextual @SerialName(value = "date_value")
+    val dateValue: java.time.LocalDate?
+
+) {
+    @Serializable
+    enum class FieldType(val value: kotlin.String) {
+        @SerialName(value = "text") Text("text"),
+        @SerialName(value = "number") Number("number"),
+        @SerialName(value = "boolean") Boolean("boolean"),
+        @SerialName(value = "date") Date("date");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemCustomFieldListResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemCustomFieldListResponse.kt
new file mode 100644
index 0000000..233c4a4
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemCustomFieldListResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.ItemCustomField
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ItemCustomFieldListResponse (
+
+    @SerialName(value = "custom_fields")
+    val customFields: kotlin.collections.List<ItemCustomField>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemCustomFieldUpdateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemCustomFieldUpdateRequest.kt
new file mode 100644
index 0000000..184312c
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemCustomFieldUpdateRequest.kt
@@ -0,0 +1,60 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ItemCustomFieldUpdateRequest (
+
+    @SerialName(value = "field_def_id")
+    val fieldDefId: kotlin.String,
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "field_type")
+    val fieldType: ItemCustomFieldUpdateRequest.FieldType,
+
+    @SerialName(value = "text_value")
+    val textValue: kotlin.String?,
+
+    @Contextual @SerialName(value = "number_value")
+    val numberValue: java.math.BigDecimal?,
+
+    @SerialName(value = "bool_value")
+    val boolValue: kotlin.Boolean?,
+
+    @Contextual @SerialName(value = "date_value")
+    val dateValue: java.time.LocalDate?,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long
+
+) {
+    @Serializable
+    enum class FieldType(val value: kotlin.String) {
+        @SerialName(value = "text") Text("text"),
+        @SerialName(value = "number") Number("number"),
+        @SerialName(value = "boolean") Boolean("boolean"),
+        @SerialName(value = "date") Date("date");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemLabelAssignment.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemLabelAssignment.kt
new file mode 100644
index 0000000..3382b6f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemLabelAssignment.kt
@@ -0,0 +1,35 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ItemLabelAssignment (
+
+    @SerialName(value = "item_id")
+    val itemId: kotlin.String,
+
+    @SerialName(value = "label_id")
+    val labelId: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemListResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemListResponse.kt
new file mode 100644
index 0000000..49982b3
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemListResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.Item
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ItemListResponse (
+
+    @SerialName(value = "items")
+    val items: kotlin.collections.List<Item>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemUpdateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemUpdateRequest.kt
new file mode 100644
index 0000000..d6aa4ac
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ItemUpdateRequest.kt
@@ -0,0 +1,44 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ItemUpdateRequest (
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long,
+
+    @SerialName(value = "description")
+    val description: kotlin.String? = null,
+
+    @SerialName(value = "location_id")
+    val locationId: kotlin.String? = null,
+
+    @SerialName(value = "quantity")
+    val quantity: kotlin.Long? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Label.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Label.kt
new file mode 100644
index 0000000..d5a540a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Label.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class Label (
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "color")
+    val color: kotlin.String,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long,
+
+    @SerialName(value = "updated_at")
+    val updatedAt: kotlin.Long,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelCreateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelCreateRequest.kt
new file mode 100644
index 0000000..92eb281
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelCreateRequest.kt
@@ -0,0 +1,35 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LabelCreateRequest (
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "color")
+    val color: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelListResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelListResponse.kt
new file mode 100644
index 0000000..88df4c2
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelListResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.Label
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LabelListResponse (
+
+    @SerialName(value = "labels")
+    val labels: kotlin.collections.List<Label>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelUpdateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelUpdateRequest.kt
new file mode 100644
index 0000000..6838f7e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelUpdateRequest.kt
@@ -0,0 +1,38 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LabelUpdateRequest (
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "color")
+    val color: kotlin.String,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelsQRBatchItem.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelsQRBatchItem.kt
new file mode 100644
index 0000000..fefff96
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelsQRBatchItem.kt
@@ -0,0 +1,41 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LabelsQRBatchItem (
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "short_code")
+    val shortCode: kotlin.String,
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "qr_svg")
+    val qrSvg: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelsQRBatchRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelsQRBatchRequest.kt
new file mode 100644
index 0000000..eabaacc
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelsQRBatchRequest.kt
@@ -0,0 +1,31 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LabelsQRBatchRequest (
+    @SerialName(value = "item_ids")
+    val itemIds: kotlin.collections.List<kotlin.String>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelsQRBatchResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelsQRBatchResponse.kt
new file mode 100644
index 0000000..936e73d
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LabelsQRBatchResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.LabelsQRBatchItem
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LabelsQRBatchResponse (
+
+    @SerialName(value = "items")
+    val items: kotlin.collections.List<LabelsQRBatchItem>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Location.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Location.kt
new file mode 100644
index 0000000..d6f124e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Location.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class Location (
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long,
+
+    @SerialName(value = "updated_at")
+    val updatedAt: kotlin.Long,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long,
+
+    @SerialName(value = "parent_id")
+    val parentId: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationCreateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationCreateRequest.kt
new file mode 100644
index 0000000..a4b6344
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationCreateRequest.kt
@@ -0,0 +1,35 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LocationCreateRequest (
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "parent_id")
+    val parentId: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationListResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationListResponse.kt
new file mode 100644
index 0000000..1d27d29
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationListResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.Location
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LocationListResponse (
+
+    @SerialName(value = "locations")
+    val locations: kotlin.collections.List<Location>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationNotEmptyProblem.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationNotEmptyProblem.kt
new file mode 100644
index 0000000..0247bb9
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationNotEmptyProblem.kt
@@ -0,0 +1,49 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LocationNotEmptyProblem (
+    @Contextual @SerialName(value = "type")
+    val type: java.net.URI,
+
+    @SerialName(value = "title")
+    val title: kotlin.String,
+
+    @SerialName(value = "status")
+    val status: kotlin.Int,
+
+    @SerialName(value = "child_count")
+    val childCount: kotlin.Long,
+
+    @SerialName(value = "item_count")
+    val itemCount: kotlin.Long,
+
+    @SerialName(value = "detail")
+    val detail: kotlin.String? = null,
+
+    @SerialName(value = "request_id")
+    val requestId: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationTreeNode.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationTreeNode.kt
new file mode 100644
index 0000000..19e934d
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationTreeNode.kt
@@ -0,0 +1,56 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LocationTreeNode (
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long,
+
+    @SerialName(value = "updated_at")
+    val updatedAt: kotlin.Long,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long,
+
+    @SerialName(value = "item_count")
+    val itemCount: kotlin.Long,
+
+    @SerialName(value = "total_item_count")
+    val totalItemCount: kotlin.Long,
+
+    @SerialName(value = "children")
+    val children: kotlin.collections.List<LocationTreeNode>,
+
+    @SerialName(value = "parent_id")
+    val parentId: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationTreeResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationTreeResponse.kt
new file mode 100644
index 0000000..7d5fd6a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationTreeResponse.kt
@@ -0,0 +1,33 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.LocationTreeNode
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LocationTreeResponse (
+    @SerialName(value = "tree")
+    val tree: kotlin.collections.List<LocationTreeNode>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationUpdateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationUpdateRequest.kt
new file mode 100644
index 0000000..e0b17eb
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LocationUpdateRequest.kt
@@ -0,0 +1,38 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LocationUpdateRequest (
+
+    @SerialName(value = "name")
+    val name: kotlin.String,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long,
+
+    @SerialName(value = "parent_id")
+    val parentId: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LoginRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LoginRequest.kt
new file mode 100644
index 0000000..791b0b0
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LoginRequest.kt
@@ -0,0 +1,35 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LoginRequest (
+
+    @SerialName(value = "username")
+    val username: kotlin.String,
+
+    @SerialName(value = "password")
+    val password: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LoginResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LoginResponse.kt
new file mode 100644
index 0000000..00a0b9b
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/LoginResponse.kt
@@ -0,0 +1,41 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class LoginResponse (
+
+    @SerialName(value = "group_id")
+    val groupId: kotlin.String,
+
+    @SerialName(value = "user_id")
+    val userId: kotlin.String,
+
+    @SerialName(value = "username")
+    val username: kotlin.String,
+
+    @SerialName(value = "role")
+    val role: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Problem.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Problem.kt
new file mode 100644
index 0000000..87c5a80
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/Problem.kt
@@ -0,0 +1,43 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class Problem (
+    @Contextual @SerialName(value = "type")
+    val type: java.net.URI,
+
+    @SerialName(value = "title")
+    val title: kotlin.String,
+
+    @SerialName(value = "status")
+    val status: kotlin.Int,
+
+    @SerialName(value = "detail")
+    val detail: kotlin.String? = null,
+
+    @SerialName(value = "request_id")
+    val requestId: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/PurchaseBlock.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/PurchaseBlock.kt
new file mode 100644
index 0000000..32f7d4d
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/PurchaseBlock.kt
@@ -0,0 +1,55 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class PurchaseBlock (
+    @SerialName(value = "purchase_price_minor")
+    val purchasePriceMinor: kotlin.Long,
+
+    @SerialName(value = "item_id")
+    val itemId: kotlin.String? = null,
+
+    @SerialName(value = "vendor")
+    val vendor: kotlin.String? = null,
+
+    @Contextual @SerialName(value = "purchased_on")
+    val purchasedOn: java.time.LocalDate? = null,
+
+    @SerialName(value = "order_reference")
+    val orderReference: kotlin.String? = null,
+
+    @SerialName(value = "notes")
+    val notes: kotlin.String? = null,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long? = null,
+
+    @SerialName(value = "updated_at")
+    val updatedAt: kotlin.Long? = null,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/PurchaseCreateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/PurchaseCreateRequest.kt
new file mode 100644
index 0000000..58fe46c
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/PurchaseCreateRequest.kt
@@ -0,0 +1,44 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class PurchaseCreateRequest (
+
+    @SerialName(value = "vendor")
+    val vendor: kotlin.String? = null,
+
+    @Contextual @SerialName(value = "purchased_on")
+    val purchasedOn: java.time.LocalDate? = null,
+
+    @SerialName(value = "purchase_price_minor")
+    val purchasePriceMinor: kotlin.Long? = null,
+
+    @SerialName(value = "order_reference")
+    val orderReference: kotlin.String? = null,
+
+    @SerialName(value = "notes")
+    val notes: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/PurchaseUpdateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/PurchaseUpdateRequest.kt
new file mode 100644
index 0000000..5b44181
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/PurchaseUpdateRequest.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class PurchaseUpdateRequest (
+
+    @SerialName(value = "version")
+    val version: kotlin.Long,
+
+    @SerialName(value = "vendor")
+    val vendor: kotlin.String? = null,
+
+    @Contextual @SerialName(value = "purchased_on")
+    val purchasedOn: java.time.LocalDate? = null,
+
+    @SerialName(value = "purchase_price_minor")
+    val purchasePriceMinor: kotlin.Long? = null,
+
+    @SerialName(value = "order_reference")
+    val orderReference: kotlin.String? = null,
+
+    @SerialName(value = "notes")
+    val notes: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/RegisterRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/RegisterRequest.kt
new file mode 100644
index 0000000..cd83777
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/RegisterRequest.kt
@@ -0,0 +1,35 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class RegisterRequest (
+
+    @SerialName(value = "username")
+    val username: kotlin.String,
+
+    @SerialName(value = "password")
+    val password: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/RegisterResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/RegisterResponse.kt
new file mode 100644
index 0000000..32cc83e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/RegisterResponse.kt
@@ -0,0 +1,38 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class RegisterResponse (
+
+    @SerialName(value = "group_id")
+    val groupId: kotlin.String,
+
+    @SerialName(value = "user_id")
+    val userId: kotlin.String,
+
+    @SerialName(value = "username")
+    val username: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportItemCountByLocationResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportItemCountByLocationResponse.kt
new file mode 100644
index 0000000..5256604
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportItemCountByLocationResponse.kt
@@ -0,0 +1,33 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.ReportLocationItemCountRow
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ReportItemCountByLocationResponse (
+    @SerialName(value = "rows")
+    val rows: kotlin.collections.List<ReportLocationItemCountRow>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportLocationItemCountRow.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportLocationItemCountRow.kt
new file mode 100644
index 0000000..009a59a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportLocationItemCountRow.kt
@@ -0,0 +1,38 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ReportLocationItemCountRow (
+
+    @SerialName(value = "location_id")
+    val locationId: kotlin.String,
+
+    @SerialName(value = "location_name")
+    val locationName: kotlin.String,
+
+    @SerialName(value = "item_count")
+    val itemCount: kotlin.Long
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportPurchaseRow.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportPurchaseRow.kt
new file mode 100644
index 0000000..d7e332d
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportPurchaseRow.kt
@@ -0,0 +1,44 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ReportPurchaseRow (
+
+    @SerialName(value = "item_id")
+    val itemId: kotlin.String,
+
+    @SerialName(value = "item_name")
+    val itemName: kotlin.String,
+
+    @SerialName(value = "purchased_on")
+    val purchasedOn: kotlin.String,
+
+    @SerialName(value = "vendor")
+    val vendor: kotlin.String,
+
+    @SerialName(value = "purchase_price_minor")
+    val purchasePriceMinor: kotlin.Long
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportPurchasesResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportPurchasesResponse.kt
new file mode 100644
index 0000000..c486f10
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportPurchasesResponse.kt
@@ -0,0 +1,33 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.ReportPurchaseRow
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ReportPurchasesResponse (
+    @SerialName(value = "rows")
+    val rows: kotlin.collections.List<ReportPurchaseRow>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportValuationResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportValuationResponse.kt
new file mode 100644
index 0000000..5c3b561
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportValuationResponse.kt
@@ -0,0 +1,33 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.ReportValuationRow
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ReportValuationResponse (
+    @SerialName(value = "rows")
+    val rows: kotlin.collections.List<ReportValuationRow>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportValuationRow.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportValuationRow.kt
new file mode 100644
index 0000000..ce30883
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportValuationRow.kt
@@ -0,0 +1,40 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ReportValuationRow (
+    @SerialName(value = "group_key")
+    val groupKey: kotlin.String,
+
+    @SerialName(value = "group_label")
+    val groupLabel: kotlin.String,
+
+    @SerialName(value = "item_count")
+    val itemCount: kotlin.Long,
+
+    @SerialName(value = "total_value_minor")
+    val totalValueMinor: kotlin.Long
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportWarrantyExpiringResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportWarrantyExpiringResponse.kt
new file mode 100644
index 0000000..ff651df
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportWarrantyExpiringResponse.kt
@@ -0,0 +1,33 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.ReportWarrantyExpiringRow
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ReportWarrantyExpiringResponse (
+    @SerialName(value = "rows")
+    val rows: kotlin.collections.List<ReportWarrantyExpiringRow>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportWarrantyExpiringRow.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportWarrantyExpiringRow.kt
new file mode 100644
index 0000000..5b6d06c
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/ReportWarrantyExpiringRow.kt
@@ -0,0 +1,41 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class ReportWarrantyExpiringRow (
+
+    @SerialName(value = "item_id")
+    val itemId: kotlin.String,
+
+    @SerialName(value = "item_name")
+    val itemName: kotlin.String,
+
+    @SerialName(value = "expires_on")
+    val expiresOn: kotlin.String,
+
+    @SerialName(value = "days_remaining")
+    val daysRemaining: kotlin.Int
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SaleBlock.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SaleBlock.kt
new file mode 100644
index 0000000..13a8513
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SaleBlock.kt
@@ -0,0 +1,52 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SaleBlock (
+    @SerialName(value = "sale_price_minor")
+    val salePriceMinor: kotlin.Long,
+
+    @SerialName(value = "item_id")
+    val itemId: kotlin.String? = null,
+
+    @SerialName(value = "buyer_name")
+    val buyerName: kotlin.String? = null,
+
+    @Contextual @SerialName(value = "sold_on")
+    val soldOn: java.time.LocalDate? = null,
+
+    @SerialName(value = "notes")
+    val notes: kotlin.String? = null,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long? = null,
+
+    @SerialName(value = "updated_at")
+    val updatedAt: kotlin.Long? = null,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SaleCreateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SaleCreateRequest.kt
new file mode 100644
index 0000000..5140132
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SaleCreateRequest.kt
@@ -0,0 +1,41 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SaleCreateRequest (
+
+    @SerialName(value = "buyer_name")
+    val buyerName: kotlin.String? = null,
+
+    @Contextual @SerialName(value = "sold_on")
+    val soldOn: java.time.LocalDate? = null,
+
+    @SerialName(value = "sale_price_minor")
+    val salePriceMinor: kotlin.Long? = null,
+
+    @SerialName(value = "notes")
+    val notes: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SaleUpdateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SaleUpdateRequest.kt
new file mode 100644
index 0000000..e2c2773
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SaleUpdateRequest.kt
@@ -0,0 +1,44 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SaleUpdateRequest (
+
+    @SerialName(value = "version")
+    val version: kotlin.Long,
+
+    @SerialName(value = "buyer_name")
+    val buyerName: kotlin.String? = null,
+
+    @Contextual @SerialName(value = "sold_on")
+    val soldOn: java.time.LocalDate? = null,
+
+    @SerialName(value = "sale_price_minor")
+    val salePriceMinor: kotlin.Long? = null,
+
+    @SerialName(value = "notes")
+    val notes: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SessionListItem.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SessionListItem.kt
new file mode 100644
index 0000000..6aca68c
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SessionListItem.kt
@@ -0,0 +1,50 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SessionListItem (
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "user_agent")
+    val userAgent: kotlin.String,
+
+    @SerialName(value = "created_from_ip")
+    val createdFromIp: kotlin.String,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long,
+
+    @SerialName(value = "expires_at")
+    val expiresAt: kotlin.Long,
+
+    @SerialName(value = "revoked")
+    val revoked: kotlin.Boolean,
+
+    @SerialName(value = "revoked_at")
+    val revokedAt: kotlin.Long? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SessionListResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SessionListResponse.kt
new file mode 100644
index 0000000..8a204c3
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SessionListResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.SessionListItem
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SessionListResponse (
+
+    @SerialName(value = "sessions")
+    val sessions: kotlin.collections.List<SessionListItem>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/StatusResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/StatusResponse.kt
new file mode 100644
index 0000000..a8a6612
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/StatusResponse.kt
@@ -0,0 +1,42 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class StatusResponse (
+
+    @SerialName(value = "status")
+    val status: StatusResponse.Status,
+
+    @SerialName(value = "version")
+    val version: kotlin.String,
+
+    @SerialName(value = "schema_version")
+    val schemaVersion: kotlin.Long
+
+) {
+    @Serializable
+    enum class Status(val value: kotlin.String) {
+        @SerialName(value = "ok") Ok("ok");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/StockAdjustment.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/StockAdjustment.kt
new file mode 100644
index 0000000..c91ee37
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/StockAdjustment.kt
@@ -0,0 +1,55 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class StockAdjustment (
+    @SerialName(value = "delta")
+    val delta: kotlin.Long,
+
+    @SerialName(value = "resulting_quantity")
+    val resultingQuantity: kotlin.Long,
+
+    @SerialName(value = "id")
+    val id: kotlin.String? = null,
+
+    @SerialName(value = "item_id")
+    val itemId: kotlin.String? = null,
+
+    @SerialName(value = "reason")
+    val reason: kotlin.String? = null,
+
+    @SerialName(value = "note")
+    val note: kotlin.String? = null,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long? = null,
+
+    @SerialName(value = "updated_at")
+    val updatedAt: kotlin.Long? = null,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/StockAdjustmentCreateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/StockAdjustmentCreateRequest.kt
new file mode 100644
index 0000000..3417886
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/StockAdjustmentCreateRequest.kt
@@ -0,0 +1,37 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class StockAdjustmentCreateRequest (
+    @SerialName(value = "delta")
+    val delta: kotlin.Long,
+
+    @SerialName(value = "reason")
+    val reason: kotlin.String,
+
+    @SerialName(value = "note")
+    val note: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/StockAdjustmentListResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/StockAdjustmentListResponse.kt
new file mode 100644
index 0000000..93a44b4
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/StockAdjustmentListResponse.kt
@@ -0,0 +1,34 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.StockAdjustment
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class StockAdjustmentListResponse (
+
+    @SerialName(value = "stock_adjustments")
+    val stockAdjustments: kotlin.collections.List<StockAdjustment>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncAppliedEntry.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncAppliedEntry.kt
new file mode 100644
index 0000000..eac4f66
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncAppliedEntry.kt
@@ -0,0 +1,40 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncAppliedEntry (
+    @SerialName(value = "mutation_id")
+    val mutationId: kotlin.String,
+
+    @SerialName(value = "entity_type")
+    val entityType: kotlin.String,
+
+    @SerialName(value = "entity_id")
+    val entityId: kotlin.String,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntry.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntry.kt
new file mode 100644
index 0000000..3d30492
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntry.kt
@@ -0,0 +1,57 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.Attachment
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryAttachment
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryItem
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryItemCustomField
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryItemIdentification
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryItemLabel
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryLabel
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryLocation
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryPurchasedFromBlock
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntrySoldToBlock
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryStockAdjustment
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntryWarrantyBlock
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.JsonClassDiscriminator
+
+@Serializable
+
+@OptIn(ExperimentalSerializationApi::class)
+@JsonClassDiscriminator(discriminator = "entity_type")
+sealed class SyncChangeEntry {
+
+    @SerialName(value = "entity_type")
+    abstract val entityType: SyncChangeEntry.EntityType
+    @SerialName(value = "id")
+    abstract val id: kotlin.String
+    @SerialName(value = "group_change_seq")
+    abstract val groupChangeSeq: kotlin.Long
+    @SerialName(value = "data")
+    abstract val `data`: Attachment
+    @Serializable
+    enum class EntityType(val value: kotlin.String) {
+        @SerialName(value = "attachment") Attachment("attachment");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryAttachment.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryAttachment.kt
new file mode 100644
index 0000000..fed4321
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryAttachment.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.Attachment
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncChangeEntryAttachment (
+
+    @SerialName(value = "entity_type")
+    val entityType: SyncChangeEntryAttachment.EntityType,
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "group_change_seq")
+    val groupChangeSeq: kotlin.Long,
+
+    @SerialName(value = "data")
+    val `data`: Attachment
+
+) {
+    @Serializable
+    enum class EntityType(val value: kotlin.String) {
+        @SerialName(value = "attachment") Attachment("attachment");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryItem.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryItem.kt
new file mode 100644
index 0000000..c4ec8f3
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryItem.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.Item
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncChangeEntryItem (
+
+    @SerialName(value = "entity_type")
+    val entityType: SyncChangeEntryItem.EntityType,
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "group_change_seq")
+    val groupChangeSeq: kotlin.Long,
+
+    @SerialName(value = "data")
+    val `data`: Item
+
+) {
+    @Serializable
+    enum class EntityType(val value: kotlin.String) {
+        @SerialName(value = "item") Item("item");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryItemCustomField.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryItemCustomField.kt
new file mode 100644
index 0000000..6360fde
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryItemCustomField.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.ItemCustomField
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncChangeEntryItemCustomField (
+
+    @SerialName(value = "entity_type")
+    val entityType: SyncChangeEntryItemCustomField.EntityType,
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "group_change_seq")
+    val groupChangeSeq: kotlin.Long,
+
+    @SerialName(value = "data")
+    val `data`: ItemCustomField
+
+) {
+    @Serializable
+    enum class EntityType(val value: kotlin.String) {
+        @SerialName(value = "item_custom_field") ItemCustomField("item_custom_field");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryItemIdentification.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryItemIdentification.kt
new file mode 100644
index 0000000..e37429c
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryItemIdentification.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.Identification
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncChangeEntryItemIdentification (
+
+    @SerialName(value = "entity_type")
+    val entityType: SyncChangeEntryItemIdentification.EntityType,
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "group_change_seq")
+    val groupChangeSeq: kotlin.Long,
+
+    @SerialName(value = "data")
+    val `data`: Identification
+
+) {
+    @Serializable
+    enum class EntityType(val value: kotlin.String) {
+        @SerialName(value = "item_identification") ItemIdentification("item_identification");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryItemLabel.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryItemLabel.kt
new file mode 100644
index 0000000..1ddf101
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryItemLabel.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.ItemLabelAssignment
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncChangeEntryItemLabel (
+
+    @SerialName(value = "entity_type")
+    val entityType: SyncChangeEntryItemLabel.EntityType,
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "group_change_seq")
+    val groupChangeSeq: kotlin.Long,
+
+    @SerialName(value = "data")
+    val `data`: ItemLabelAssignment
+
+) {
+    @Serializable
+    enum class EntityType(val value: kotlin.String) {
+        @SerialName(value = "item_label") ItemLabel("item_label");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryLabel.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryLabel.kt
new file mode 100644
index 0000000..0126638
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryLabel.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.Label
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncChangeEntryLabel (
+
+    @SerialName(value = "entity_type")
+    val entityType: SyncChangeEntryLabel.EntityType,
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "group_change_seq")
+    val groupChangeSeq: kotlin.Long,
+
+    @SerialName(value = "data")
+    val `data`: Label
+
+) {
+    @Serializable
+    enum class EntityType(val value: kotlin.String) {
+        @SerialName(value = "label") Label("label");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryLocation.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryLocation.kt
new file mode 100644
index 0000000..367ce8e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryLocation.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.Location
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncChangeEntryLocation (
+
+    @SerialName(value = "entity_type")
+    val entityType: SyncChangeEntryLocation.EntityType,
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "group_change_seq")
+    val groupChangeSeq: kotlin.Long,
+
+    @SerialName(value = "data")
+    val `data`: Location
+
+) {
+    @Serializable
+    enum class EntityType(val value: kotlin.String) {
+        @SerialName(value = "location") Location("location");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryPurchasedFromBlock.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryPurchasedFromBlock.kt
new file mode 100644
index 0000000..d016cbc
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryPurchasedFromBlock.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.PurchaseBlock
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncChangeEntryPurchasedFromBlock (
+
+    @SerialName(value = "entity_type")
+    val entityType: SyncChangeEntryPurchasedFromBlock.EntityType,
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "group_change_seq")
+    val groupChangeSeq: kotlin.Long,
+
+    @SerialName(value = "data")
+    val `data`: PurchaseBlock
+
+) {
+    @Serializable
+    enum class EntityType(val value: kotlin.String) {
+        @SerialName(value = "purchased_from_block") PurchasedFromBlock("purchased_from_block");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntrySoldToBlock.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntrySoldToBlock.kt
new file mode 100644
index 0000000..6a4fcab
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntrySoldToBlock.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.SaleBlock
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncChangeEntrySoldToBlock (
+
+    @SerialName(value = "entity_type")
+    val entityType: SyncChangeEntrySoldToBlock.EntityType,
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "group_change_seq")
+    val groupChangeSeq: kotlin.Long,
+
+    @SerialName(value = "data")
+    val `data`: SaleBlock
+
+) {
+    @Serializable
+    enum class EntityType(val value: kotlin.String) {
+        @SerialName(value = "sold_to_block") SoldToBlock("sold_to_block");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryStockAdjustment.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryStockAdjustment.kt
new file mode 100644
index 0000000..c8829b5
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryStockAdjustment.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.StockAdjustment
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncChangeEntryStockAdjustment (
+
+    @SerialName(value = "entity_type")
+    val entityType: SyncChangeEntryStockAdjustment.EntityType,
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "group_change_seq")
+    val groupChangeSeq: kotlin.Long,
+
+    @SerialName(value = "data")
+    val `data`: StockAdjustment
+
+) {
+    @Serializable
+    enum class EntityType(val value: kotlin.String) {
+        @SerialName(value = "stock_adjustment") StockAdjustment("stock_adjustment");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryWarrantyBlock.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryWarrantyBlock.kt
new file mode 100644
index 0000000..b9f2337
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncChangeEntryWarrantyBlock.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.WarrantyBlock
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncChangeEntryWarrantyBlock (
+
+    @SerialName(value = "entity_type")
+    val entityType: SyncChangeEntryWarrantyBlock.EntityType,
+
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "group_change_seq")
+    val groupChangeSeq: kotlin.Long,
+
+    @SerialName(value = "data")
+    val `data`: WarrantyBlock
+
+) {
+    @Serializable
+    enum class EntityType(val value: kotlin.String) {
+        @SerialName(value = "warranty_block") WarrantyBlock("warranty_block");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncConflictEntry.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncConflictEntry.kt
new file mode 100644
index 0000000..5a8668f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncConflictEntry.kt
@@ -0,0 +1,40 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncConflictEntry (
+    @SerialName(value = "mutation_id")
+    val mutationId: kotlin.String,
+
+    @SerialName(value = "entity_type")
+    val entityType: kotlin.String,
+
+    @SerialName(value = "entity_id")
+    val entityId: kotlin.String,
+
+    @SerialName(value = "field_name")
+    val fieldName: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncConflictLogEntry.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncConflictLogEntry.kt
new file mode 100644
index 0000000..98e4449
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncConflictLogEntry.kt
@@ -0,0 +1,52 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncConflictLogEntry (
+    @SerialName(value = "id")
+    val id: kotlin.String,
+
+    @SerialName(value = "mutation_id")
+    val mutationId: kotlin.String?,
+
+    @SerialName(value = "entity_type")
+    val entityType: kotlin.String,
+
+    @SerialName(value = "entity_id")
+    val entityId: kotlin.String,
+
+    @SerialName(value = "field_name")
+    val fieldName: kotlin.String,
+
+    @SerialName(value = "server_value")
+    val serverValue: kotlin.String?,
+
+    @SerialName(value = "losing_client_value")
+    val losingClientValue: kotlin.String?,
+
+    @SerialName(value = "detected_at")
+    val detectedAt: kotlin.Long
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncConflictLogResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncConflictLogResponse.kt
new file mode 100644
index 0000000..2bdc5f2
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncConflictLogResponse.kt
@@ -0,0 +1,36 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.SyncConflictLogEntry
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncConflictLogResponse (
+    @SerialName(value = "conflicts")
+    val conflicts: kotlin.collections.List<SyncConflictLogEntry>,
+
+    @SerialName(value = "next_cursor")
+    val nextCursor: kotlin.String?
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncCursorTooOld.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncCursorTooOld.kt
new file mode 100644
index 0000000..875acd0
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncCursorTooOld.kt
@@ -0,0 +1,36 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncCursorTooOld (
+
+    @SerialName(value = "cursor_too_old")
+    val cursorTooOld: SyncCursorTooOld.CursorTooOld
+
+) {
+    @Serializable
+    enum class CursorTooOld(val value: kotlin.Boolean) {
+        @SerialName(value = "true") True(true);
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncMutation.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncMutation.kt
new file mode 100644
index 0000000..189c214
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncMutation.kt
@@ -0,0 +1,51 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncMutation (
+    @SerialName(value = "mutation_id")
+    val mutationId: kotlin.String,
+
+    @SerialName(value = "entity_type")
+    val entityType: kotlin.String,
+
+    @SerialName(value = "entity_id")
+    val entityId: kotlin.String,
+
+    @SerialName(value = "base_version")
+    val baseVersion: kotlin.Long,
+
+    @Contextual @SerialName(value = "fields")
+    val fields: kotlin.Any,
+
+    @SerialName(value = "op")
+    val op: SyncMutation.Op? = null
+
+) {
+    @Serializable
+    enum class Op(val value: kotlin.String) {
+        @SerialName(value = "upsert") Upsert("upsert"),
+        @SerialName(value = "delete") Delete("delete");
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPullRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPullRequest.kt
new file mode 100644
index 0000000..9d33af1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPullRequest.kt
@@ -0,0 +1,37 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncPullRequest (
+    @SerialName(value = "device_id")
+    val deviceId: kotlin.String,
+
+    @SerialName(value = "since")
+    val since: kotlin.Long,
+
+    @SerialName(value = "limit")
+    val limit: kotlin.Int
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPullResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPullResponse.kt
new file mode 100644
index 0000000..7372b9e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPullResponse.kt
@@ -0,0 +1,52 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntry
+import dev.hho.android.data.apiclient.generated.models.SyncCursorTooOld
+import dev.hho.android.data.apiclient.generated.models.SyncPullResult
+import dev.hho.android.data.apiclient.generated.models.SyncTombstoneEntry
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncPullResponse (
+    @SerialName(value = "changes")
+    val changes: kotlin.collections.List<SyncChangeEntry>,
+
+    @SerialName(value = "tombstones")
+    val tombstones: kotlin.collections.List<SyncTombstoneEntry>,
+
+    @SerialName(value = "next_watermark")
+    val nextWatermark: kotlin.Long,
+
+    @SerialName(value = "has_more")
+    val hasMore: kotlin.Boolean,
+
+    @SerialName(value = "cursor_too_old")
+    val cursorTooOld: SyncPullResponse.CursorTooOld
+
+) {
+    @Serializable
+    enum class CursorTooOld(val value: kotlin.Boolean) {
+        @SerialName(value = "true") True(true);
+    }
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPullResult.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPullResult.kt
new file mode 100644
index 0000000..3c6dae1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPullResult.kt
@@ -0,0 +1,43 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.SyncChangeEntry
+import dev.hho.android.data.apiclient.generated.models.SyncTombstoneEntry
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncPullResult (
+    @SerialName(value = "changes")
+    val changes: kotlin.collections.List<SyncChangeEntry>,
+
+    @SerialName(value = "tombstones")
+    val tombstones: kotlin.collections.List<SyncTombstoneEntry>,
+
+    @SerialName(value = "next_watermark")
+    val nextWatermark: kotlin.Long,
+
+    @SerialName(value = "has_more")
+    val hasMore: kotlin.Boolean
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPushRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPushRequest.kt
new file mode 100644
index 0000000..63975f9
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPushRequest.kt
@@ -0,0 +1,36 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.SyncMutation
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncPushRequest (
+    @SerialName(value = "device_id")
+    val deviceId: kotlin.String,
+
+    @SerialName(value = "mutations")
+    val mutations: kotlin.collections.List<SyncMutation>
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPushResponse.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPushResponse.kt
new file mode 100644
index 0000000..7a89ede
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncPushResponse.kt
@@ -0,0 +1,45 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import dev.hho.android.data.apiclient.generated.models.SyncAppliedEntry
+import dev.hho.android.data.apiclient.generated.models.SyncConflictEntry
+import dev.hho.android.data.apiclient.generated.models.SyncSkippedEntry
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncPushResponse (
+
+    @SerialName(value = "applied")
+    val applied: kotlin.collections.List<SyncAppliedEntry>,
+
+    @SerialName(value = "skipped")
+    val skipped: kotlin.collections.List<SyncSkippedEntry>,
+
+    @SerialName(value = "conflicts")
+    val conflicts: kotlin.collections.List<SyncConflictEntry>,
+
+    @SerialName(value = "new_watermark")
+    val newWatermark: kotlin.Long
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncSkippedEntry.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncSkippedEntry.kt
new file mode 100644
index 0000000..cca0b99
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncSkippedEntry.kt
@@ -0,0 +1,31 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncSkippedEntry (
+    @SerialName(value = "mutation_id")
+    val mutationId: kotlin.String
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncTombstoneEntry.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncTombstoneEntry.kt
new file mode 100644
index 0000000..9337a60
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/SyncTombstoneEntry.kt
@@ -0,0 +1,38 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class SyncTombstoneEntry (
+
+    @SerialName(value = "entity_type")
+    val entityType: kotlin.String? = null,
+
+    @SerialName(value = "id")
+    val id: kotlin.String? = null,
+
+    @SerialName(value = "deleted_at")
+    val deletedAt: kotlin.Long? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/UpgradeRequiredProblem.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/UpgradeRequiredProblem.kt
new file mode 100644
index 0000000..5536311
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/UpgradeRequiredProblem.kt
@@ -0,0 +1,46 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class UpgradeRequiredProblem (
+    @Contextual @SerialName(value = "type")
+    val type: java.net.URI,
+
+    @SerialName(value = "title")
+    val title: kotlin.String,
+
+    @SerialName(value = "status")
+    val status: kotlin.Int,
+
+    @SerialName(value = "minimum_version")
+    val minimumVersion: kotlin.String,
+
+    @SerialName(value = "detail")
+    val detail: kotlin.String? = null,
+
+    @SerialName(value = "request_id")
+    val requestId: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/WarrantyBlock.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/WarrantyBlock.kt
new file mode 100644
index 0000000..c007f8a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/WarrantyBlock.kt
@@ -0,0 +1,59 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class WarrantyBlock (
+
+    @SerialName(value = "is_lifetime")
+    val isLifetime: kotlin.Boolean,
+
+    @SerialName(value = "item_id")
+    val itemId: kotlin.String? = null,
+
+    @SerialName(value = "holder")
+    val holder: kotlin.String? = null,
+
+    @SerialName(value = "provider")
+    val provider: kotlin.String? = null,
+
+    @Contextual @SerialName(value = "starts_on")
+    val startsOn: java.time.LocalDate? = null,
+
+    @Contextual @SerialName(value = "expires_on")
+    val expiresOn: java.time.LocalDate? = null,
+
+    @SerialName(value = "notes")
+    val notes: kotlin.String? = null,
+
+    @SerialName(value = "created_at")
+    val createdAt: kotlin.Long? = null,
+
+    @SerialName(value = "updated_at")
+    val updatedAt: kotlin.Long? = null,
+
+    @SerialName(value = "version")
+    val version: kotlin.Long? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/WarrantyCreateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/WarrantyCreateRequest.kt
new file mode 100644
index 0000000..c440d74
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/WarrantyCreateRequest.kt
@@ -0,0 +1,47 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class WarrantyCreateRequest (
+
+    @SerialName(value = "holder")
+    val holder: kotlin.String? = null,
+
+    @SerialName(value = "provider")
+    val provider: kotlin.String? = null,
+
+    @Contextual @SerialName(value = "starts_on")
+    val startsOn: java.time.LocalDate? = null,
+
+    @Contextual @SerialName(value = "expires_on")
+    val expiresOn: java.time.LocalDate? = null,
+
+    @SerialName(value = "is_lifetime")
+    val isLifetime: kotlin.Boolean? = null,
+
+    @SerialName(value = "notes")
+    val notes: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/WarrantyUpdateRequest.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/WarrantyUpdateRequest.kt
new file mode 100644
index 0000000..93de33f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/generated/models/WarrantyUpdateRequest.kt
@@ -0,0 +1,50 @@
+@file:Suppress(
+    "ArrayInDataClass",
+    "DuplicatedCode",
+    "EnumEntryName",
+    "RemoveRedundantQualifierName",
+    "RemoveRedundantCallsOfConversionMethods",
+    "REDUNDANT_CALL_OF_CONVERSION_METHOD",
+    "RedundantUnitReturnType",
+    "RemoveEmptyClassBody",
+    "UnnecessaryVariable",
+    "UnusedImport",
+    "UnnecessaryVariable",
+    "unused"
+)
+
+package dev.hho.android.data.apiclient.generated.models
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Contextual
+
+@Serializable
+
+data class WarrantyUpdateRequest (
+
+    @SerialName(value = "version")
+    val version: kotlin.Long,
+
+    @SerialName(value = "holder")
+    val holder: kotlin.String? = null,
+
+    @SerialName(value = "provider")
+    val provider: kotlin.String? = null,
+
+    @Contextual @SerialName(value = "starts_on")
+    val startsOn: java.time.LocalDate? = null,
+
+    @Contextual @SerialName(value = "expires_on")
+    val expiresOn: java.time.LocalDate? = null,
+
+    @SerialName(value = "is_lifetime")
+    val isLifetime: kotlin.Boolean? = null,
+
+    @SerialName(value = "notes")
+    val notes: kotlin.String? = null
+
+) {
+
+}
+
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/package-info.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/package-info.kt
new file mode 100644
index 0000000..1a94bbe
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/apiclient/package-info.kt
@@ -0,0 +1 @@
+package dev.hho.android.data.apiclient
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/attachments/AttachmentCache.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/attachments/AttachmentCache.kt
new file mode 100644
index 0000000..27b5381
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/attachments/AttachmentCache.kt
@@ -0,0 +1,165 @@
+package dev.hho.android.data.attachments
+
+import android.content.Context
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.room.AttachmentDao
+import dev.hho.android.data.room.AttachmentEntity
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.io.IOException
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
+import java.security.MessageDigest
+import java.util.concurrent.ConcurrentHashMap
+import javax.inject.Inject
+import javax.inject.Singleton
+
+const val ATTACHMENT_CACHE_MAX_BYTES: Long = 200L * 1024 * 1024
+
+class AttachmentNotCachedException(attachmentId: String) :
+    Exception("No attachment metadata for id $attachmentId — nothing to resolve its item/hash from")
+
+class AttachmentIntegrityException(attachmentId: String, reason: String) :
+    Exception("Attachment $attachmentId failed integrity verification: $reason")
+
+@Singleton
+class AttachmentCache
+    internal constructor(
+        private val cacheDir: File,
+        private val apiClient: HhoApiClient,
+        private val attachmentDao: AttachmentDao,
+        private val maxCacheBytes: Long,
+    ) {
+        @Inject
+        constructor(
+            @ApplicationContext context: Context,
+            apiClient: HhoApiClient,
+            attachmentDao: AttachmentDao,
+        ) : this(
+            cacheDir = File(context.cacheDir, "attachments"),
+            apiClient = apiClient,
+            attachmentDao = attachmentDao,
+            maxCacheBytes = ATTACHMENT_CACHE_MAX_BYTES,
+        )
+
+        private val tmpDir: File = File(cacheDir, ".tmp")
+
+        private val locks = ConcurrentHashMap<String, Mutex>()
+
+        private val evictionMutex = Mutex()
+
+        init {
+            cacheDir.mkdirs()
+            tmpDir.mkdirs()
+            tmpDir.listFiles()?.forEach { it.delete() }
+        }
+
+        suspend fun file(attachmentId: String): Result<File> =
+            withContext(Dispatchers.IO) {
+                cachedFile(attachmentId)?.let { return@withContext Result.success(it) }
+
+                val mutex = locks.computeIfAbsent(attachmentId) { Mutex() }
+                mutex.withLock {
+                    cachedFile(attachmentId)?.let { return@withLock Result.success(it) }
+                    fetchAndStore(attachmentId)
+                }
+            }
+
+        private fun cachedFile(attachmentId: String): File? {
+            val existing = File(cacheDir, attachmentId)
+            if (!existing.isFile) return null
+            existing.setLastModified(System.currentTimeMillis())
+            return existing
+        }
+
+        private suspend fun fetchAndStore(attachmentId: String): Result<File> {
+            val metadata =
+                attachmentDao.getById(attachmentId)
+                    ?: return Result.failure(AttachmentNotCachedException(attachmentId))
+
+            val downloaded =
+                apiClient.downloadAttachment(metadata.itemId, attachmentId).getOrElse {
+                    return Result.failure(it)
+                }
+
+            return try {
+                verifyIntegrity(downloaded, metadata)
+                if (downloaded.length() > maxCacheBytes) {
+                    Result.success(downloaded)
+                } else {
+                    Result.success(moveIntoCache(attachmentId, downloaded))
+                }
+            } catch (e: AttachmentIntegrityException) {
+                downloaded.delete()
+                Result.failure(e)
+            } catch (e: IOException) {
+                downloaded.delete()
+                Result.failure(e)
+            }
+        }
+
+        private fun verifyIntegrity(
+            file: File,
+            metadata: AttachmentEntity,
+        ) {
+            val actualSize = file.length()
+            if (actualSize != metadata.sizeBytes) {
+                throw AttachmentIntegrityException(
+                    metadata.id,
+                    "expected ${metadata.sizeBytes} bytes, got $actualSize",
+                )
+            }
+            val actualSha256 = file.sha256Hex()
+            if (!actualSha256.equals(metadata.sha256, ignoreCase = true)) {
+                throw AttachmentIntegrityException(metadata.id, "sha256 mismatch")
+            }
+        }
+
+        private suspend fun moveIntoCache(
+            attachmentId: String,
+            source: File,
+        ): File {
+            val staged = File.createTempFile("$attachmentId-", ".part", tmpDir)
+            source.copyTo(staged, overwrite = true)
+            source.delete()
+            val target = File(cacheDir, attachmentId)
+            Files.move(
+                staged.toPath(),
+                target.toPath(),
+                StandardCopyOption.ATOMIC_MOVE,
+                StandardCopyOption.REPLACE_EXISTING,
+            )
+            evictionMutex.withLock { evictIfNeeded() }
+            return target
+        }
+
+        private fun evictIfNeeded() {
+            val files = cacheDir.listFiles { candidate -> candidate.isFile } ?: return
+            var total = files.sumOf { it.length() }
+            if (total <= maxCacheBytes) return
+            for (candidate in files.sortedBy { it.lastModified() }) {
+                if (total <= maxCacheBytes) break
+                val size = candidate.length()
+                if (candidate.delete()) total -= size
+            }
+        }
+    }
+
+private const val HASH_BUFFER_SIZE = 8192
+
+private fun File.sha256Hex(): String {
+    val digest = MessageDigest.getInstance("SHA-256")
+    inputStream().use { input ->
+        val buffer = ByteArray(HASH_BUFFER_SIZE)
+        while (true) {
+            val read = input.read(buffer)
+            if (read == -1) break
+            digest.update(buffer, 0, read)
+        }
+    }
+    return digest.digest().joinToString(separator = "") { "%02x".format(it) }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/auth/AesGcmDeviceTokenCipher.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/AesGcmDeviceTokenCipher.kt
new file mode 100644
index 0000000..15879c0
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/AesGcmDeviceTokenCipher.kt
@@ -0,0 +1,39 @@
+package dev.hho.android.data.auth
+
+import java.security.GeneralSecurityException
+import javax.crypto.Cipher
+import javax.crypto.SecretKey
+import javax.crypto.spec.GCMParameterSpec
+
+private const val TRANSFORMATION = "AES/GCM/NoPadding"
+private const val GCM_IV_LENGTH_BYTES = 12
+private const val GCM_TAG_LENGTH_BITS = 128
+
+class AesGcmDeviceTokenCipher(private val secretKey: () -> SecretKey) : DeviceTokenCipher {
+
+    override fun encrypt(
+        plaintext: ByteArray,
+        associatedData: ByteArray,
+    ): ByteArray {
+        val cipher = Cipher.getInstance(TRANSFORMATION)
+        cipher.init(Cipher.ENCRYPT_MODE, secretKey())
+        cipher.updateAAD(associatedData)
+        val ciphertext = cipher.doFinal(plaintext)
+        return cipher.iv + ciphertext
+    }
+
+    override fun decrypt(
+        payload: ByteArray,
+        associatedData: ByteArray,
+    ): ByteArray {
+        if (payload.size <= GCM_IV_LENGTH_BYTES) {
+            throw GeneralSecurityException("Payload too short to contain a GCM IV and ciphertext")
+        }
+        val iv = payload.copyOfRange(0, GCM_IV_LENGTH_BYTES)
+        val ciphertext = payload.copyOfRange(GCM_IV_LENGTH_BYTES, payload.size)
+        val cipher = Cipher.getInstance(TRANSFORMATION)
+        cipher.init(Cipher.DECRYPT_MODE, secretKey(), GCMParameterSpec(GCM_TAG_LENGTH_BITS, iv))
+        cipher.updateAAD(associatedData)
+        return cipher.doFinal(ciphertext)
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/auth/AndroidKeystoreDeviceTokenCipher.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/AndroidKeystoreDeviceTokenCipher.kt
new file mode 100644
index 0000000..a344b4b
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/AndroidKeystoreDeviceTokenCipher.kt
@@ -0,0 +1,45 @@
+package dev.hho.android.data.auth
+
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyProperties
+import java.security.KeyStore
+import javax.crypto.KeyGenerator
+import javax.crypto.SecretKey
+import javax.inject.Inject
+import javax.inject.Singleton
+
+private const val ANDROID_KEYSTORE_PROVIDER = "AndroidKeyStore"
+private const val KEY_ALIAS = "dev.hho.android.device_token_key"
+private const val KEY_SIZE_BITS = 256
+
+@Singleton
+class AndroidKeystoreDeviceTokenCipher
+    @Inject
+    constructor() : DeviceTokenCipher {
+        private val delegate = AesGcmDeviceTokenCipher(secretKey = ::getOrCreateSecretKey)
+
+        override fun encrypt(
+            plaintext: ByteArray,
+            associatedData: ByteArray,
+        ): ByteArray = delegate.encrypt(plaintext, associatedData)
+
+        override fun decrypt(
+            payload: ByteArray,
+            associatedData: ByteArray,
+        ): ByteArray = delegate.decrypt(payload, associatedData)
+
+        private fun getOrCreateSecretKey(): SecretKey {
+            val keyStore = KeyStore.getInstance(ANDROID_KEYSTORE_PROVIDER).apply { load(null) }
+            (keyStore.getKey(KEY_ALIAS, null) as? SecretKey)?.let { return it }
+
+            val keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, ANDROID_KEYSTORE_PROVIDER)
+            val spec =
+                KeyGenParameterSpec.Builder(KEY_ALIAS, KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
+                    .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
+                    .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+                    .setKeySize(KEY_SIZE_BITS)
+                    .build()
+            keyGenerator.init(spec)
+            return keyGenerator.generateKey()
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/auth/AuthRepositoryImpl.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/AuthRepositoryImpl.kt
new file mode 100644
index 0000000..e5e46c1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/AuthRepositoryImpl.kt
@@ -0,0 +1,77 @@
+package dev.hho.android.data.auth
+
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.network.BaseUrlResolution
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.network.NoInstanceUrlConfiguredException
+import dev.hho.android.domain.AuthRepository
+import dev.hho.android.domain.AuthState
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.update
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class AuthRepositoryImpl
+    @Inject
+    constructor(
+        private val hhoApiClient: HhoApiClient,
+        private val deviceTokenStore: DeviceTokenStore,
+        private val instanceBaseUrlResolver: InstanceBaseUrlResolver,
+        private val deviceLabelProvider: DeviceLabelProvider,
+    ) : AuthRepository {
+        private val tokenChangeSignal = MutableStateFlow(0)
+
+        override val authState: Flow<AuthState> =
+            combine(
+                instanceBaseUrlResolver.resolutionFlow()
+                    .map { (it as? BaseUrlResolution.Configured)?.baseUrl?.toString() }
+                    .distinctUntilChanged(),
+                tokenChangeSignal,
+            ) { configuredInstanceUrl, _ -> configuredInstanceUrl }
+                .map { configuredInstanceUrl -> computeAuthState(configuredInstanceUrl) }
+
+        private suspend fun computeAuthState(configuredInstanceUrl: String?): AuthState =
+            if (deviceTokenStore.load().tokenFor(configuredInstanceUrl) != null) {
+                AuthState.LoggedIn
+            } else {
+                AuthState.LoggedOut
+            }
+
+        override suspend fun login(
+            username: String,
+            password: String,
+        ): Result<Unit> {
+            val loginOutcome = hhoApiClient.login(username, password).getOrElse { return Result.failure(it) }
+
+            return hhoApiClient
+                .issueDeviceToken(deviceLabelProvider.currentLabel(), loginOutcome.sessionCookie)
+                .fold(
+                    onSuccess = { issued ->
+                        val configured = instanceBaseUrlResolver.resolve() as? BaseUrlResolution.Configured
+                        if (configured == null) {
+                            deviceTokenStore.clear()
+                            tokenChangeSignal.update { it + 1 }
+                            return Result.failure(NoInstanceUrlConfiguredException())
+                        }
+                        deviceTokenStore.save(StoredToken(token = issued.token, instanceUrl = configured.baseUrl.toString()))
+                        tokenChangeSignal.update { it + 1 }
+                        Result.success(Unit)
+                    },
+                    onFailure = { error ->
+                        deviceTokenStore.clear()
+                        tokenChangeSignal.update { it + 1 }
+                        Result.failure(error)
+                    },
+                )
+        }
+
+        override suspend fun logout() {
+            deviceTokenStore.clear()
+            tokenChangeSignal.update { it + 1 }
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceIdProvider.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceIdProvider.kt
new file mode 100644
index 0000000..3a60722
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceIdProvider.kt
@@ -0,0 +1,32 @@
+package dev.hho.android.data.auth
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import dev.hho.android.data.settings.SettingsKeys
+import java.util.UUID
+import javax.inject.Inject
+import javax.inject.Singleton
+
+interface DeviceIdProvider {
+    suspend fun deviceId(): String
+}
+
+@Singleton
+class DataStoreDeviceIdProvider
+    @Inject
+    constructor(
+        private val dataStore: DataStore<Preferences>,
+    ) : DeviceIdProvider {
+        override suspend fun deviceId(): String {
+            val prefs =
+                dataStore.edit { mutablePrefs ->
+                    if (mutablePrefs[SettingsKeys.DEVICE_ID] == null) {
+                        mutablePrefs[SettingsKeys.DEVICE_ID] = UUID.randomUUID().toString()
+                    }
+                }
+            return requireNotNull(prefs[SettingsKeys.DEVICE_ID]) {
+                "DataStoreDeviceIdProvider: DEVICE_ID missing immediately after being written."
+            }
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceLabelProvider.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceLabelProvider.kt
new file mode 100644
index 0000000..c95b3ac
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceLabelProvider.kt
@@ -0,0 +1,19 @@
+package dev.hho.android.data.auth
+
+import android.os.Build
+import javax.inject.Inject
+import javax.inject.Singleton
+
+fun interface DeviceLabelProvider {
+    fun currentLabel(): String
+}
+
+@Singleton
+class DefaultDeviceLabelProvider
+    @Inject
+    constructor() : DeviceLabelProvider {
+        override fun currentLabel(): String =
+            listOfNotNull(Build.MANUFACTURER?.trim()?.ifBlank { null }, Build.MODEL?.trim()?.ifBlank { null })
+                .joinToString(" ")
+                .ifBlank { "Android device" }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceTokenCipher.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceTokenCipher.kt
new file mode 100644
index 0000000..bec24a6
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceTokenCipher.kt
@@ -0,0 +1,13 @@
+package dev.hho.android.data.auth
+
+interface DeviceTokenCipher {
+    fun encrypt(
+        plaintext: ByteArray,
+        associatedData: ByteArray,
+    ): ByteArray
+
+    fun decrypt(
+        payload: ByteArray,
+        associatedData: ByteArray,
+    ): ByteArray
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceTokenProvider.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceTokenProvider.kt
new file mode 100644
index 0000000..67f4038
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceTokenProvider.kt
@@ -0,0 +1,9 @@
+package dev.hho.android.data.auth
+
+import okhttp3.HttpUrl
+
+interface DeviceTokenProvider {
+    suspend fun tokenFor(requestUrl: HttpUrl): String?
+
+    suspend fun invalidate(requestUrl: HttpUrl, rejectedToken: String)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceTokenStore.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceTokenStore.kt
new file mode 100644
index 0000000..285f00c
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/DeviceTokenStore.kt
@@ -0,0 +1,34 @@
+package dev.hho.android.data.auth
+
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+
+interface DeviceTokenStore {
+    suspend fun load(): StoredToken?
+
+    suspend fun save(token: StoredToken)
+
+    suspend fun clear()
+}
+
+data class StoredToken(val token: String, val instanceUrl: String)
+
+internal fun StoredToken?.tokenFor(configuredInstanceUrl: String?): String? =
+    this?.takeIf { configuredInstanceUrl != null && it.instanceUrl == configuredInstanceUrl }?.token
+
+internal fun StoredToken?.tokenForRequest(requestUrl: HttpUrl): String? =
+    this?.takeIf { matchesBoundInstance(requestUrl, it.instanceUrl) }?.token
+
+internal fun matchesBoundInstance(
+    requestUrl: HttpUrl,
+    boundInstanceUrl: String,
+): Boolean {
+    val bound = boundInstanceUrl.toHttpUrlOrNull() ?: return false
+    if (bound.scheme != requestUrl.scheme) return false
+    if (bound.host != requestUrl.host) return false
+    if (bound.port != requestUrl.port) return false
+    val boundSegments = bound.pathSegments.filterNot { it.isEmpty() }
+    val requestSegments = requestUrl.pathSegments.filterNot { it.isEmpty() }
+    if (requestSegments.size < boundSegments.size) return false
+    return requestSegments.subList(0, boundSegments.size) == boundSegments
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/auth/InstanceScopedDeviceTokenProvider.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/InstanceScopedDeviceTokenProvider.kt
new file mode 100644
index 0000000..acaadc3
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/InstanceScopedDeviceTokenProvider.kt
@@ -0,0 +1,24 @@
+package dev.hho.android.data.auth
+
+import okhttp3.HttpUrl
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class InstanceScopedDeviceTokenProvider
+    @Inject
+    constructor(
+        private val dataStore: DeviceTokenStore,
+    ) : DeviceTokenProvider {
+        override suspend fun tokenFor(requestUrl: HttpUrl): String? = dataStore.load().tokenForRequest(requestUrl)
+
+        override suspend fun invalidate(
+            requestUrl: HttpUrl,
+            rejectedToken: String,
+        ) {
+            val current = dataStore.load()
+            if (current.tokenForRequest(requestUrl) == rejectedToken) {
+                dataStore.clear()
+            }
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/auth/KeystoreDeviceTokenStore.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/KeystoreDeviceTokenStore.kt
new file mode 100644
index 0000000..c05f76e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/auth/KeystoreDeviceTokenStore.kt
@@ -0,0 +1,55 @@
+package dev.hho.android.data.auth
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import dev.hho.android.di.DeviceTokenDataStore
+import kotlinx.coroutines.flow.first
+import java.util.Base64
+import javax.inject.Inject
+import javax.inject.Singleton
+
+private val DEVICE_TOKEN_CIPHERTEXT_KEY = stringPreferencesKey("device_token_ciphertext_b64")
+private val DEVICE_TOKEN_INSTANCE_URL_KEY = stringPreferencesKey("device_token_instance_url")
+
+@Singleton
+class KeystoreDeviceTokenStore
+    @Inject
+    constructor(
+        @DeviceTokenDataStore private val dataStore: DataStore<Preferences>,
+        private val cipher: DeviceTokenCipher,
+    ) : DeviceTokenStore {
+        override suspend fun load(): StoredToken? {
+            val prefs = dataStore.data.first()
+            val ciphertextB64 = prefs[DEVICE_TOKEN_CIPHERTEXT_KEY] ?: return null
+            val instanceUrl = prefs[DEVICE_TOKEN_INSTANCE_URL_KEY] ?: return null
+            val plaintext =
+                runCatching {
+                    cipher.decrypt(
+                        payload = Base64.getDecoder().decode(ciphertextB64),
+                        associatedData = instanceUrl.toByteArray(Charsets.UTF_8),
+                    )
+                }.getOrNull() ?: return null
+            return StoredToken(token = String(plaintext, Charsets.UTF_8), instanceUrl = instanceUrl)
+        }
+
+        override suspend fun save(token: StoredToken) {
+            val ciphertext =
+                cipher.encrypt(
+                    plaintext = token.token.toByteArray(Charsets.UTF_8),
+                    associatedData = token.instanceUrl.toByteArray(Charsets.UTF_8),
+                )
+            dataStore.edit { prefs ->
+                prefs[DEVICE_TOKEN_CIPHERTEXT_KEY] = Base64.getEncoder().encodeToString(ciphertext)
+                prefs[DEVICE_TOKEN_INSTANCE_URL_KEY] = token.instanceUrl
+            }
+        }
+
+        override suspend fun clear() {
+            dataStore.edit { prefs ->
+                prefs.remove(DEVICE_TOKEN_CIPHERTEXT_KEY)
+                prefs.remove(DEVICE_TOKEN_INSTANCE_URL_KEY)
+            }
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/ids/UuidV7.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/ids/UuidV7.kt
new file mode 100644
index 0000000..188bb98
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/ids/UuidV7.kt
@@ -0,0 +1,42 @@
+package dev.hho.android.data.ids
+
+import java.security.SecureRandom
+import java.util.Random
+import java.util.UUID
+
+public class UuidV7Generator(
+    private val clock: () -> Long = System::currentTimeMillis,
+    private val random: Random = SecureRandom(),
+) {
+    private var lastMillis: Long = -1L
+    private var counter: Int = 0
+
+    public fun generate(): String = next().toString()
+
+    @Synchronized
+    public fun next(): UUID {
+        val now = clock().coerceIn(0L, MAX_MILLIS)
+        if (now > lastMillis) {
+            lastMillis = now
+            counter = random.nextInt(SEED_BOUND)
+        } else if (counter < COUNTER_MAX) {
+            counter++
+        } else {
+            check(lastMillis < MAX_MILLIS) { "UUIDv7 48-bit timestamp exhausted" }
+            lastMillis++
+            counter = random.nextInt(SEED_BOUND)
+        }
+        val msb = (lastMillis shl 16) or (VERSION_7 shl 12) or counter.toLong()
+        val lsb = (random.nextLong() and RAND_B_MASK) or VARIANT_BITS
+        return UUID(msb, lsb)
+    }
+
+    private companion object {
+        const val MAX_MILLIS = 0xFFFF_FFFF_FFFFL
+        const val COUNTER_MAX = 0xFFF
+        const val SEED_BOUND = 0x800
+        const val VERSION_7 = 0x7L
+        const val RAND_B_MASK = 0x3FFF_FFFF_FFFF_FFFFL
+        const val VARIANT_BITS = Long.MIN_VALUE
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/items/ItemSearch.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/items/ItemSearch.kt
new file mode 100644
index 0000000..d685044
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/items/ItemSearch.kt
@@ -0,0 +1,31 @@
+package dev.hho.android.data.items
+
+import dev.hho.android.data.room.ItemDao
+import dev.hho.android.data.room.ItemEntity
+import kotlinx.coroutines.flow.Flow
+import javax.inject.Inject
+
+class ItemSearch
+    @Inject
+    constructor(
+        private val itemDao: ItemDao,
+    ) {
+        fun results(query: String): Flow<List<ItemEntity>> {
+            val trimmed = query.trim()
+            return if (trimmed.isEmpty()) {
+                itemDao.observeAll()
+            } else {
+                itemDao.search(likePatternFor(trimmed))
+            }
+        }
+
+        suspend fun findByIdentifierValue(value: String): List<ItemEntity> = itemDao.findByIdentifierValue(value)
+    }
+
+internal fun likePatternFor(query: String): String {
+    val escaped = query
+        .replace("\\", "\\\\")
+        .replace("%", "\\%")
+        .replace("_", "\\_")
+    return "%$escaped%"
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/network/AuthHeaderInterceptor.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/network/AuthHeaderInterceptor.kt
new file mode 100644
index 0000000..cbb69fb
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/network/AuthHeaderInterceptor.kt
@@ -0,0 +1,33 @@
+package dev.hho.android.data.network
+
+import dev.hho.android.data.auth.DeviceTokenProvider
+import kotlinx.coroutines.runBlocking
+import okhttp3.Interceptor
+import okhttp3.Response
+import javax.inject.Inject
+
+class AuthHeaderInterceptor
+    @Inject
+    constructor(
+        private val tokenProvider: DeviceTokenProvider,
+    ) : Interceptor {
+        override fun intercept(chain: Interceptor.Chain): Response {
+            val request = chain.request()
+            val token = runBlocking { tokenProvider.tokenFor(request.url) }
+
+            val authenticatedRequest =
+                if (token.isNullOrBlank()) {
+                    request
+                } else {
+                    request.newBuilder().header("Authorization", "Bearer $token").build()
+                }
+
+            val response = chain.proceed(authenticatedRequest)
+
+            if (!token.isNullOrBlank() && response.code == 401) {
+                runBlocking { tokenProvider.invalidate(request.url, token) }
+            }
+
+            return response
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/network/BaseUrlInterceptor.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/network/BaseUrlInterceptor.kt
new file mode 100644
index 0000000..a97a068
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/network/BaseUrlInterceptor.kt
@@ -0,0 +1,39 @@
+package dev.hho.android.data.network
+
+import kotlinx.coroutines.runBlocking
+import okhttp3.Interceptor
+import okhttp3.Response
+import java.io.IOException
+import javax.inject.Inject
+
+class BaseUrlInterceptor
+    @Inject
+    constructor(
+        private val baseUrlResolver: InstanceBaseUrlResolver,
+    ) : Interceptor {
+        override fun intercept(chain: Interceptor.Chain): Response {
+            val configured =
+                (runBlocking { baseUrlResolver.resolve() } as? BaseUrlResolution.Configured)
+                    ?: throw NoInstanceUrlConfiguredException()
+
+            val request = chain.request()
+            val basePathSegments = configured.baseUrl.pathSegments.filterNot { it.isEmpty() }
+            val requestPathSegments = request.url.pathSegments.filterNot { it.isEmpty() }
+
+            val urlBuilder =
+                request.url.newBuilder()
+                    .scheme(configured.baseUrl.scheme)
+                    .host(configured.baseUrl.host)
+                    .port(configured.baseUrl.port)
+                    .encodedPath("/")
+
+            for (segment in basePathSegments + requestPathSegments) {
+                urlBuilder.addPathSegment(segment)
+            }
+
+            return chain.proceed(request.newBuilder().url(urlBuilder.build()).build())
+        }
+    }
+
+class NoInstanceUrlConfiguredException :
+    IOException("No instance URL is configured yet — connect to an instance first")
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/network/ClientVersionInterceptor.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/network/ClientVersionInterceptor.kt
new file mode 100644
index 0000000..a1b848d
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/network/ClientVersionInterceptor.kt
@@ -0,0 +1,19 @@
+package dev.hho.android.data.network
+
+import dev.hho.android.BuildConfig
+import okhttp3.Interceptor
+import okhttp3.Response
+import javax.inject.Inject
+
+class ClientVersionInterceptor
+    @Inject
+    constructor() : Interceptor {
+        override fun intercept(chain: Interceptor.Chain): Response {
+            val request = chain.request().newBuilder().header(HEADER_NAME, BuildConfig.HHO_CLIENT_VERSION).build()
+            return chain.proceed(request)
+        }
+
+        companion object {
+            const val HEADER_NAME = "X-HHO-Client-Version"
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/network/InstanceBaseUrlResolver.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/network/InstanceBaseUrlResolver.kt
new file mode 100644
index 0000000..7ef4d98
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/network/InstanceBaseUrlResolver.kt
@@ -0,0 +1,37 @@
+package dev.hho.android.data.network
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import dev.hho.android.data.settings.SettingsKeys
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import javax.inject.Inject
+
+class InstanceBaseUrlResolver
+    @Inject
+    constructor(
+        private val settingsDataStore: DataStore<Preferences>,
+    ) {
+        suspend fun resolve(): BaseUrlResolution = resolutionFlow().first()
+
+        fun resolutionFlow(): Flow<BaseUrlResolution> =
+            settingsDataStore.data
+                .map { it[SettingsKeys.INSTANCE_BASE_URL] }
+                .map { stored ->
+                    val parsed = stored?.toHttpUrlOrNull()
+                    if (parsed != null) {
+                        BaseUrlResolution.Configured(parsed)
+                    } else {
+                        BaseUrlResolution.NotConfigured
+                    }
+                }
+    }
+
+sealed interface BaseUrlResolution {
+    data class Configured(val baseUrl: HttpUrl) : BaseUrlResolution
+
+    data object NotConfigured : BaseUrlResolution
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/network/InstanceUrlNormalizer.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/network/InstanceUrlNormalizer.kt
new file mode 100644
index 0000000..a3b231f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/network/InstanceUrlNormalizer.kt
@@ -0,0 +1,46 @@
+package dev.hho.android.data.network
+
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+
+object InstanceUrlNormalizer {
+    fun normalize(raw: String): InstanceUrlNormalization {
+        val trimmed = raw.trim()
+        if (trimmed.isEmpty()) {
+            return InstanceUrlNormalization.Invalid("Enter an instance URL.")
+        }
+        val hasExplicitScheme =
+            trimmed.startsWith("http://", ignoreCase = true) || trimmed.startsWith("https://", ignoreCase = true)
+        if (!hasExplicitScheme) {
+            return InstanceUrlNormalization.Invalid(
+                "Include the scheme, e.g. https://hho.example.com or http://192.168.1.10:7745.",
+            )
+        }
+        val parsed =
+            trimmed.toHttpUrlOrNull()
+                ?: return InstanceUrlNormalization.Invalid("That doesn't look like a valid URL.")
+        if (parsed.username.isNotEmpty() || parsed.password.isNotEmpty()) {
+            return InstanceUrlNormalization.Invalid("Remove the username/password from the URL.")
+        }
+        if (parsed.query != null) {
+            return InstanceUrlNormalization.Invalid("Remove the query string (?...) from the URL.")
+        }
+        if (parsed.fragment != null) {
+            return InstanceUrlNormalization.Invalid("Remove the # fragment from the URL.")
+        }
+
+        val pathSegments = parsed.pathSegments.filterNot { it.isEmpty() }
+        val normalized =
+            parsed.newBuilder()
+                .encodedPath("/")
+                .apply { pathSegments.forEach { addPathSegment(it) } }
+                .build()
+        return InstanceUrlNormalization.Valid(normalized)
+    }
+}
+
+sealed interface InstanceUrlNormalization {
+    data class Valid(val url: HttpUrl) : InstanceUrlNormalization
+
+    data class Invalid(val reason: String) : InstanceUrlNormalization
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/outbox/OptimisticApplier.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/outbox/OptimisticApplier.kt
new file mode 100644
index 0000000..5318a0e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/outbox/OptimisticApplier.kt
@@ -0,0 +1,157 @@
+package dev.hho.android.data.outbox
+
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemIdentificationEntity
+import dev.hho.android.data.room.ItemLabelEntity
+import dev.hho.android.data.room.OutboxMutationEntity
+import dev.hho.android.data.room.PurchasedFromBlockEntity
+import dev.hho.android.data.room.StockAdjustmentEntity
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.longOrNull
+import java.time.LocalDate
+
+internal class UnsupportedMutationException(message: String) : IllegalArgumentException(message)
+
+internal data class LocalMutation(
+    val entityType: String,
+    val entityId: String,
+    val op: String,
+    val baseVersion: Long,
+    val fields: JsonObject,
+) {
+    internal companion object {
+        fun from(row: OutboxMutationEntity): LocalMutation =
+            LocalMutation(
+                entityType = row.entityType,
+                entityId = row.entityId,
+                op = row.op,
+                baseVersion = row.baseVersion,
+                fields = Json.parseToJsonElement(row.fieldsJson).jsonObject,
+            )
+    }
+}
+
+internal object OptimisticApplier {
+    suspend fun apply(db: HhoDatabase, m: LocalMutation, pendingSeq: Long? = null): Boolean =
+        when (m.entityType) {
+            "item" -> applyItem(db, m)
+            "stock_adjustment" -> applyStockAdjustment(db, m, pendingSeq)
+            "item_label" -> applyItemLabel(db, m)
+            "item_identification" -> applyIdentification(db, m)
+            "purchased_from_block" -> applyPurchase(db, m)
+            else -> throw UnsupportedMutationException("unsupported entity_type ${m.entityType}")
+        }
+
+    private fun requireUpsert(m: LocalMutation) {
+        if (m.op != "upsert") throw UnsupportedMutationException("${m.entityType}: op ${m.op} unsupported")
+    }
+
+    private suspend fun applyItem(db: HhoDatabase, m: LocalMutation): Boolean {
+        requireUpsert(m)
+        if ("quantity" in m.fields) throw UnsupportedMutationException("item.quantity changes only via stock_adjustment (A177)")
+        val dao = db.itemDao()
+        val existing = dao.getById(m.entityId)
+        if (m.baseVersion != 0L && existing == null) return false
+        val base = existing ?: ItemEntity(
+            id = m.entityId, groupChangeSeq = 0, name = "", description = null, locationId = null,
+            quantity = 0, shortCode = null, createdAt = null, updatedAt = null, version = 0,
+        )
+        dao.upsert(
+            base.copy(
+                name = m.fields.string("name", base.name) ?: base.name,
+                description = m.fields.string("description", base.description),
+                locationId = m.fields.string("location_id", base.locationId),
+            ),
+        )
+        return true
+    }
+
+    private suspend fun applyStockAdjustment(db: HhoDatabase, m: LocalMutation, pendingSeq: Long?): Boolean {
+        requireUpsert(m)
+        val itemId = m.fields.string("item_id", null) ?: throw UnsupportedMutationException("stock_adjustment needs item_id")
+        val delta = m.fields["delta"]?.let { (it as? JsonPrimitive)?.longOrNull }
+            ?: throw UnsupportedMutationException("stock_adjustment needs integer delta")
+        val item = db.itemDao().getById(itemId)
+        val earlier = OutboxOverlay.pendingDeltaFor(db, itemId, beforeSeq = pendingSeq)
+        db.stockAdjustmentDao().upsert(
+            StockAdjustmentEntity(
+                id = m.entityId, groupChangeSeq = 0, itemId = itemId, delta = delta,
+                resultingQuantity = (item?.quantity ?: 0) + earlier + delta,
+                reason = m.fields.string("reason", null), note = m.fields.string("note", null),
+                createdAt = null, updatedAt = null, version = 0,
+            ),
+        )
+        return true
+    }
+
+    private suspend fun applyItemLabel(db: HhoDatabase, m: LocalMutation): Boolean {
+        val dao = db.itemLabelDao()
+        return when (m.op) {
+            "delete" -> {
+                dao.deleteById(m.entityId)
+                true
+            }
+            "upsert" -> {
+                val itemId = m.fields.string("item_id", null) ?: throw UnsupportedMutationException("item_label needs item_id")
+                val labelId = m.fields.string("label_id", null) ?: throw UnsupportedMutationException("item_label needs label_id")
+                dao.upsert(ItemLabelEntity(id = m.entityId, groupChangeSeq = 0, itemId = itemId, labelId = labelId))
+                true
+            }
+            else -> throw UnsupportedMutationException("item_label: op ${m.op} unsupported")
+        }
+    }
+
+    private suspend fun applyIdentification(db: HhoDatabase, m: LocalMutation): Boolean {
+        requireUpsert(m)
+        if (m.baseVersion != 0L) throw UnsupportedMutationException("item_identification is create-only in Phase 4")
+        db.itemIdentificationDao().upsert(
+            ItemIdentificationEntity(
+                id = m.entityId, groupChangeSeq = 0,
+                itemId = m.fields.string("item_id", null),
+                kind = m.fields.string("kind", "") ?: "",
+                value = m.fields.string("value", "") ?: "",
+                createdAt = null, updatedAt = null, version = 0,
+            ),
+        )
+        return true
+    }
+
+    private suspend fun applyPurchase(db: HhoDatabase, m: LocalMutation): Boolean {
+        requireUpsert(m)
+        val dao = db.purchasedFromBlockDao()
+        val itemId = m.fields.string("item_id", null) ?: throw UnsupportedMutationException("purchased_from_block needs item_id")
+        val existing = dao.getByItemId(itemId)?.takeIf { it.id == m.entityId }
+        if (m.baseVersion != 0L && existing == null) return false
+        val base = existing ?: PurchasedFromBlockEntity(
+            id = m.entityId, groupChangeSeq = 0, itemId = itemId, purchasePriceMinor = 0, vendor = null,
+            purchasedOn = null, orderReference = null, notes = null, createdAt = null, updatedAt = null, version = 0,
+        )
+        dao.upsert(
+            base.copy(
+                itemId = itemId,
+                purchasePriceMinor = m.fields["purchase_price_minor"]?.let { (it as? JsonPrimitive)?.longOrNull }
+                    ?: base.purchasePriceMinor,
+                vendor = m.fields.string("vendor", base.vendor),
+                purchasedOn = if ("purchased_on" in m.fields) {
+                    m.fields.string("purchased_on", null)?.takeIf { it.isNotEmpty() }?.let(LocalDate::parse)
+                } else {
+                    base.purchasedOn
+                },
+                orderReference = m.fields.string("order_reference", base.orderReference),
+                notes = m.fields.string("notes", base.notes),
+            ),
+        )
+        return true
+    }
+
+    private fun JsonObject.string(key: String, default: String?): String? {
+        val v = this[key] ?: return default
+        return if (v is JsonNull) null else (v as? JsonPrimitive)?.contentOrNull
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/outbox/OutboxOverlay.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/outbox/OutboxOverlay.kt
new file mode 100644
index 0000000..509140e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/outbox/OutboxOverlay.kt
@@ -0,0 +1,60 @@
+package dev.hho.android.data.outbox
+
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.OutboxMutationEntity
+import dev.hho.android.data.room.OutboxState
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.longOrNull
+
+internal object OutboxOverlay {
+
+    private val LIVE = setOf(OutboxState.PENDING, OutboxState.IN_FLIGHT, OutboxState.HELD)
+
+    suspend fun reapplyPending(db: HhoDatabase): Int {
+        var written = 0
+        for (row in liveRows(db)) {
+            val mutation = try {
+                LocalMutation.from(row)
+            } catch (e: Exception) {
+                OutboxRepository(db).quarantine(row.mutationId, OutboxRepository.unreadableMessage(e))
+                continue
+            }
+            val applied = try {
+                OptimisticApplier.apply(db, mutation, pendingSeq = row.seq)
+            } catch (_: UnsupportedMutationException) {
+                false
+            }
+            if (applied) written++
+        }
+        return written
+    }
+
+    suspend fun derivedQuantity(db: HhoDatabase, itemId: String): Long? {
+        val item = db.itemDao().getById(itemId) ?: return null
+        return (item.quantity ?: 0) + pendingDeltaFor(db, itemId, beforeSeq = null)
+    }
+
+    fun observeDerivedQuantity(db: HhoDatabase, itemId: String): Flow<Long?> =
+        db.invalidationTracker
+            .createFlow("item", "outbox_mutation", emitInitialState = true)
+            .map { derivedQuantity(db, itemId) }
+
+    suspend fun pendingDeltaFor(db: HhoDatabase, itemId: String, beforeSeq: Long?): Long =
+        liveRows(db)
+            .filter { it.entityType == "stock_adjustment" && (beforeSeq == null || it.seq < beforeSeq) }
+            .mapNotNull { decodeOrNull(it)?.fields }
+            .filter { (it["item_id"] as? JsonPrimitive)?.content == itemId }
+            .sumOf { (it["delta"] as? JsonPrimitive)?.longOrNull ?: 0L }
+
+    private fun decodeOrNull(row: OutboxMutationEntity): LocalMutation? =
+        try {
+            LocalMutation.from(row)
+        } catch (_: Exception) {
+            null
+        }
+
+    private suspend fun liveRows(db: HhoDatabase): List<OutboxMutationEntity> =
+        db.outboxDao().getAllOrdered().filter { it.state in LIVE }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/outbox/OutboxRepository.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/outbox/OutboxRepository.kt
new file mode 100644
index 0000000..51dfe33
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/outbox/OutboxRepository.kt
@@ -0,0 +1,160 @@
+package dev.hho.android.data.outbox
+
+import androidx.room.withTransaction
+import dev.hho.android.data.apiclient.PushMutation
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.OutboxMutationEntity
+import dev.hho.android.data.room.OutboxState
+import kotlinx.coroutines.flow.Flow
+import kotlinx.serialization.json.JsonObject
+
+internal data class EnqueueResult(
+    val mutationId: String,
+    val seq: Long,
+    val state: String,
+    val coalesced: Boolean,
+)
+
+internal fun OutboxMutationEntity.toPushMutation(): PushMutation =
+    PushMutation(
+        mutationId = mutationId,
+        entityType = entityType,
+        entityId = entityId,
+        baseVersion = baseVersion,
+        fields = LocalMutation.from(this).fields,
+        op = op,
+    )
+
+internal class OutboxRepository(
+    private val db: HhoDatabase,
+    private val ids: UuidV7Generator = UuidV7Generator(),
+    private val clock: () -> Long = System::currentTimeMillis,
+) {
+    private val dao get() = db.outboxDao()
+
+    suspend fun enqueue(m: LocalMutation): EnqueueResult = db.withTransaction {
+        var live = dao.getLiveForEntity(m.entityType, m.entityId)
+        if (coalescible(m.entityType) && m.op == UPSERT) {
+            val target = live.lastOrNull()?.takeIf {
+                it.op == UPSERT && it.lastAttemptAt == null &&
+                    (it.state == OutboxState.PENDING || it.state == OutboxState.HELD)
+            }
+            if (target != null) {
+                val targetFields = try {
+                    LocalMutation.from(target).fields
+                } catch (e: Exception) {
+                    quarantine(target.mutationId, unreadableMessage(e))
+                    live = dao.getLiveForEntity(m.entityType, m.entityId)
+                    null
+                }
+                if (targetFields != null) {
+                    dao.updateFields(target.seq, JsonObject(targetFields + m.fields).toString())
+                    return@withTransaction EnqueueResult(target.mutationId, target.seq, target.state, true)
+                }
+            }
+        }
+        val blocked = live.any { it.state == OutboxState.IN_FLIGHT || it.state == OutboxState.HELD || it.lastAttemptAt != null }
+        val state = if (blocked) OutboxState.HELD else OutboxState.PENDING
+        val mutationId = ids.generate()
+        val seq = dao.insert(
+            OutboxMutationEntity(
+                mutationId = mutationId,
+                entityType = m.entityType,
+                entityId = m.entityId,
+                op = m.op,
+                baseVersion = m.baseVersion,
+                fieldsJson = m.fields.toString(),
+                state = state,
+                createdAt = clock(),
+            ),
+        )
+        EnqueueResult(mutationId, seq, state, false)
+    }
+
+    suspend fun nextBatch(limit: Int = BATCH_SIZE): List<OutboxMutationEntity> {
+        val live = dao.getLive()
+        val seen = live.filter { it.state == OutboxState.IN_FLIGHT }.mapTo(HashSet()) { it.entityType to it.entityId }
+        return live.asSequence()
+            .filter { it.state == OutboxState.PENDING }
+            .filter { seen.add(it.entityType to it.entityId) }
+            .take(limit)
+            .toList()
+    }
+
+    suspend fun markInFlight(mutationIds: List<String>) {
+        if (mutationIds.isEmpty()) return
+        db.withTransaction { dao.markInFlight(mutationIds, clock()) }
+    }
+
+    suspend fun resetInFlightToPending(): Int = db.withTransaction { dao.resetInFlightToPending() }
+
+    suspend fun ack(mutationId: String, version: Long) {
+        db.withTransaction {
+            val row = dao.getByMutationId(mutationId) ?: return@withTransaction
+            dao.deleteBySeq(row.seq)
+            releaseFollowers(row.entityType, row.entityId, version)
+        }
+    }
+
+    suspend fun ackSkipped(mutationId: String) {
+        db.withTransaction { dao.getByMutationId(mutationId)?.let { dao.deleteBySeq(it.seq) } }
+    }
+
+    suspend fun releaseHeld(mirrorVersion: suspend (entityType: String, entityId: String) -> Long?) {
+        db.withTransaction {
+            dao.getByState(OutboxState.HELD).map { it.entityType to it.entityId }.distinct().forEach { (t, id) ->
+                mirrorVersion(t, id)?.let { releaseFollowers(t, id, it) }
+            }
+        }
+    }
+
+    suspend fun quarantine(mutationId: String, error: String) {
+        db.withTransaction {
+            val row = dao.getByMutationId(mutationId) ?: return@withTransaction
+            dao.markFailed(mutationId, error)
+            releaseFollowers(row.entityType, row.entityId, null)
+        }
+    }
+
+    suspend fun recordAttempt(mutationId: String, error: String?) {
+        db.withTransaction { dao.recordAttempt(mutationId, error, clock()) }
+    }
+
+    fun observePendingCount(): Flow<Int> = dao.observeCount(LIVE_STATES)
+
+    private suspend fun releaseFollowers(type: String, id: String, base: Long?) {
+        val allLive = dao.getLiveForEntity(type, id)
+        if (allLive.any { it.state != OutboxState.HELD }) return
+        val live = allLive.filter { row ->
+            try {
+                LocalMutation.from(row)
+                true
+            } catch (e: Exception) {
+                dao.markFailed(row.mutationId, unreadableMessage(e))
+                false
+            }
+        }
+        val first = live.firstOrNull() ?: return
+        if (coalescible(type) && first.op == UPSERT) {
+            val rest = live.drop(1).filter { it.op == UPSERT }
+            if (rest.isNotEmpty()) {
+                val merged = rest.fold(LocalMutation.from(first).fields) { acc, r -> JsonObject(acc + LocalMutation.from(r).fields) }
+                rest.forEach { dao.deleteBySeq(it.seq) }
+                dao.updateFields(first.seq, merged.toString())
+            }
+        }
+        dao.updateStateAndBase(first.seq, OutboxState.PENDING, base ?: first.baseVersion)
+    }
+
+    private fun coalescible(type: String) = type !in NEVER_COALESCE
+
+    internal companion object {
+        const val BATCH_SIZE = 50
+
+        fun unreadableMessage(e: Exception): String = "Unreadable local edit: ${e::class.simpleName}"
+        private const val UPSERT = "upsert"
+        private val NEVER_COALESCE = setOf("stock_adjustment", "item_label")
+        private val LIVE_STATES = listOf(OutboxState.PENDING, OutboxState.IN_FLIGHT, OutboxState.HELD)
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/outbox/PendingDeltas.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/outbox/PendingDeltas.kt
new file mode 100644
index 0000000..c079318
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/outbox/PendingDeltas.kt
@@ -0,0 +1,26 @@
+package dev.hho.android.data.outbox
+
+import dev.hho.android.data.room.HhoDatabase
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.longOrNull
+
+internal object PendingDeltas {
+    fun observe(db: HhoDatabase): Flow<Map<String, Long>> =
+        db.invalidationTracker
+            .createFlow("outbox_mutation", emitInitialState = true)
+            .map { deltasByItem(db) }
+
+    suspend fun deltasByItem(db: HhoDatabase): Map<String, Long> {
+        val totals = HashMap<String, Long>()
+        for (row in db.outboxDao().getLive()) {
+            if (row.entityType != "stock_adjustment") continue
+            val fields = LocalMutation.from(row).fields
+            val itemId = (fields["item_id"] as? JsonPrimitive)?.content ?: continue
+            val delta = (fields["delta"] as? JsonPrimitive)?.longOrNull ?: 0L
+            totals[itemId] = (totals[itemId] ?: 0L) + delta
+        }
+        return totals
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoCapture.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoCapture.kt
new file mode 100644
index 0000000..b64f64f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoCapture.kt
@@ -0,0 +1,100 @@
+package dev.hho.android.data.photoqueue
+
+import android.content.Context
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.ImageCapture
+import androidx.camera.core.ImageCaptureException
+import androidx.camera.core.Preview
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.LifecycleOwner
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.suspendCancellableCoroutine
+import java.io.File
+import java.io.IOException
+import java.util.UUID
+import javax.inject.Inject
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+interface PhotoCapture {
+    suspend fun bind(
+        lifecycleOwner: LifecycleOwner,
+        surfaceProvider: Preview.SurfaceProvider,
+    )
+
+    fun unbind()
+
+    suspend fun capture(): File
+}
+
+internal class CameraXPhotoCapture
+    @Inject
+    constructor(
+        @ApplicationContext private val context: Context,
+    ) : PhotoCapture {
+        private var provider: ProcessCameraProvider? = null
+        private var imageCapture: ImageCapture? = null
+
+        override suspend fun bind(
+            lifecycleOwner: LifecycleOwner,
+            surfaceProvider: Preview.SurfaceProvider,
+        ) {
+            val cameraProvider = awaitProvider()
+            val preview = Preview.Builder().build().also { it.setSurfaceProvider(surfaceProvider) }
+            val capture =
+                ImageCapture.Builder()
+                    .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
+                    .build()
+            cameraProvider.unbindAll()
+            cameraProvider.bindToLifecycle(lifecycleOwner, CameraSelector.DEFAULT_BACK_CAMERA, preview, capture)
+            provider = cameraProvider
+            imageCapture = capture
+        }
+
+        override fun unbind() {
+            provider?.unbindAll()
+            provider = null
+            imageCapture = null
+        }
+
+        override suspend fun capture(): File {
+            val useCase = imageCapture ?: throw IOException("The camera is not ready")
+            val dir = File(context.cacheDir, "photo-capture").apply { mkdirs() }
+            val file = File(dir, "${UUID.randomUUID()}.jpg")
+            try {
+                suspendCancellableCoroutine<Unit> { continuation ->
+                    useCase.takePicture(
+                        ImageCapture.OutputFileOptions.Builder(file).build(),
+                        ContextCompat.getMainExecutor(context),
+                        object : ImageCapture.OnImageSavedCallback {
+                            override fun onImageSaved(output: ImageCapture.OutputFileResults) = continuation.resume(Unit)
+
+                            override fun onError(exception: ImageCaptureException) =
+                                continuation.resumeWithException(IOException("Capture failed", exception))
+                        },
+                    )
+                }
+            } catch (e: Throwable) {
+                file.delete()
+                throw e
+            }
+            return file
+        }
+
+        private suspend fun awaitProvider(): ProcessCameraProvider =
+            suspendCancellableCoroutine { continuation ->
+                val future = ProcessCameraProvider.getInstance(context)
+                future.addListener(
+                    {
+                        try {
+                            continuation.resume(future.get())
+                        } catch (e: Exception) {
+                            continuation.resumeWithException(e)
+                        }
+                    },
+                    ContextCompat.getMainExecutor(context),
+                )
+                continuation.invokeOnCancellation { future.cancel(false) }
+            }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoPostSyncHook.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoPostSyncHook.kt
new file mode 100644
index 0000000..b93dd17
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoPostSyncHook.kt
@@ -0,0 +1,18 @@
+package dev.hho.android.data.photoqueue
+
+import dev.hho.android.data.sync.PostSyncHook
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+internal class PhotoPostSyncHook
+    @Inject
+    constructor(
+        private val queue: PhotoQueueRepository,
+        private val scheduler: PhotoScheduler,
+    ) : PostSyncHook {
+        override suspend fun onSyncSucceeded() {
+            queue.releaseWaitingParent()
+            scheduler.schedule()
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoQueueRepository.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoQueueRepository.kt
new file mode 100644
index 0000000..8c13d7b
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoQueueRepository.kt
@@ -0,0 +1,196 @@
+package dev.hho.android.data.photoqueue
+
+import android.content.Context
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.room.PhotoQueueDao
+import dev.hho.android.data.room.PhotoQueueEntryEntity
+import dev.hho.android.data.room.PhotoState
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.withContext
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.InputStream
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
+import java.security.MessageDigest
+import javax.inject.Inject
+import javax.inject.Singleton
+
+const val PHOTO_MAX_ATTEMPTS: Int = 8
+
+const val PHOTO_BACKOFF_BASE_MS: Long = 30_000L
+
+const val PHOTO_BACKOFF_CAP_MS: Long = 30L * 60 * 1000
+
+fun photoBackoffMillis(attempt: Int): Long {
+    require(attempt >= 1) { "attempt is 1-based" }
+    val shift = (attempt - 1).coerceAtMost(20)
+    return (PHOTO_BACKOFF_BASE_MS shl shift).coerceAtMost(PHOTO_BACKOFF_CAP_MS)
+}
+
+const val PHOTO_CATEGORY_IMAGE: String = "image"
+
+@Singleton
+class PhotoQueueRepository
+    internal constructor(
+        baseDir: File,
+        private val dao: PhotoQueueDao,
+        private val clock: () -> Long,
+        private val openSource: (File) -> InputStream,
+    ) {
+        @Inject
+        constructor(
+            @ApplicationContext context: Context,
+            dao: PhotoQueueDao,
+        ) : this(context.filesDir, dao, System::currentTimeMillis, { it.inputStream() })
+
+        private val ids = UuidV7Generator(clock)
+        private val dir: File = File(baseDir, "photo-queue")
+
+        init {
+            dir.mkdirs()
+            dir.listFiles { f -> f.name.endsWith(PART_SUFFIX) }?.forEach { it.delete() }
+        }
+
+        suspend fun enqueue(
+            itemId: String,
+            sourceFile: File,
+            category: String = PHOTO_CATEGORY_IMAGE,
+        ): PhotoQueueEntryEntity =
+            withContext(Dispatchers.IO) {
+                val id = ids.generate()
+                val staged = File(dir, id + PART_SUFFIX)
+                val target = File(dir, id + FILE_SUFFIX)
+                val (sha, size) =
+                    try {
+                        copyHashing(sourceFile, staged)
+                    } catch (e: Throwable) {
+                        staged.delete()
+                        throw e
+                    }
+                try {
+                    Files.move(staged.toPath(), target.toPath(), StandardCopyOption.ATOMIC_MOVE)
+                } catch (e: Throwable) {
+                    staged.delete()
+                    throw e
+                }
+                val entry =
+                    PhotoQueueEntryEntity(
+                        id = id,
+                        itemId = itemId,
+                        filePath = target.absolutePath,
+                        sha256 = sha,
+                        sizeBytes = size,
+                        category = category,
+                        state = PhotoState.QUEUED,
+                        createdAt = clock(),
+                    )
+                try {
+                    dao.insert(entry)
+                } catch (e: Throwable) {
+                    target.delete()
+                    throw e
+                }
+                entry
+            }
+
+        suspend fun nextDue(now: Long = clock()): PhotoQueueEntryEntity? {
+            for (entry in dao.getDue(listOf(PhotoState.QUEUED), now)) {
+                if (failIfFileMissing(entry)) continue
+                return entry
+            }
+            return null
+        }
+
+        suspend fun markUploading(id: String): Boolean {
+            val entry = dao.getById(id) ?: return false
+            if (entry.state != PhotoState.QUEUED || failIfFileMissing(entry)) return false
+            dao.updateProgress(id, PhotoState.UPLOADING, entry.attemptCount, null, entry.lastError)
+            return true
+        }
+
+        suspend fun markUploaded(id: String) {
+            val entry = dao.getById(id) ?: return
+            dao.deleteById(id)
+            withContext(Dispatchers.IO) { File(entry.filePath).delete() }
+        }
+
+        suspend fun markWaitingParent(id: String) {
+            val entry = dao.getById(id) ?: return
+            dao.updateProgress(id, PhotoState.WAITING_PARENT, entry.attemptCount, null, entry.lastError)
+        }
+
+        suspend fun releaseWaitingParent(): Int = dao.moveState(PhotoState.WAITING_PARENT, PhotoState.QUEUED)
+
+        suspend fun recordFailure(
+            id: String,
+            error: String,
+            retryable: Boolean,
+            now: Long = clock(),
+        ) {
+            val entry = dao.getById(id) ?: return
+            val attempts = entry.attemptCount + 1
+            if (!retryable || attempts >= PHOTO_MAX_ATTEMPTS) {
+                dao.updateProgress(id, PhotoState.FAILED, attempts, null, error)
+            } else {
+                dao.updateProgress(id, PhotoState.QUEUED, attempts, now + photoBackoffMillis(attempts), error)
+            }
+        }
+
+        suspend fun resetUploadingToQueued(): Int = dao.moveState(PhotoState.UPLOADING, PhotoState.QUEUED)
+
+        fun fileFor(entry: PhotoQueueEntryEntity): File = File(entry.filePath)
+
+        fun observeEntries(): Flow<List<PhotoQueueEntryEntity>> = dao.observeAll()
+
+        fun observeEntriesForItem(itemId: String): Flow<List<PhotoQueueEntryEntity>> = dao.observeByItem(itemId)
+
+        fun observePendingCount(): Flow<Int> =
+            dao.observeCount(listOf(PhotoState.QUEUED, PhotoState.UPLOADING, PhotoState.WAITING_PARENT))
+
+        fun observeFailedCount(): Flow<Int> = dao.observeCount(listOf(PhotoState.FAILED))
+
+        private suspend fun failIfFileMissing(entry: PhotoQueueEntryEntity): Boolean {
+            if (File(entry.filePath).isFile) return false
+            dao.updateProgress(
+                entry.id,
+                PhotoState.FAILED,
+                entry.attemptCount,
+                null,
+                "Queued photo file is missing: ${File(entry.filePath).name}",
+            )
+            return true
+        }
+
+        private fun copyHashing(
+            source: File,
+            staged: File,
+        ): Pair<String, Long> {
+            val digest = MessageDigest.getInstance("SHA-256")
+            var total = 0L
+            openSource(source).use { input ->
+                FileOutputStream(staged).use { out ->
+                    val buffer = ByteArray(BUFFER_SIZE)
+                    while (true) {
+                        val read = input.read(buffer)
+                        if (read == -1) break
+                        digest.update(buffer, 0, read)
+                        out.write(buffer, 0, read)
+                        total += read
+                    }
+                    out.flush()
+                    out.fd.sync()
+                }
+            }
+            return digest.digest().joinToString("") { "%02x".format(it) } to total
+        }
+
+        private companion object {
+            const val PART_SUFFIX = ".part"
+            const val FILE_SUFFIX = ".jpg"
+            const val BUFFER_SIZE = 8192
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoQueueStatusSource.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoQueueStatusSource.kt
new file mode 100644
index 0000000..875f1b7
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoQueueStatusSource.kt
@@ -0,0 +1,15 @@
+package dev.hho.android.data.photoqueue
+
+import dev.hho.android.data.sync.PhotoQueueStatus
+import kotlinx.coroutines.flow.Flow
+import javax.inject.Inject
+
+internal class PhotoQueueStatusSource
+    @Inject
+    constructor(
+        private val queue: PhotoQueueRepository,
+    ) : PhotoQueueStatus {
+        override fun observePendingCount(): Flow<Int> = queue.observePendingCount()
+
+        override fun observeFailedCount(): Flow<Int> = queue.observeFailedCount()
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoScheduler.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoScheduler.kt
new file mode 100644
index 0000000..12a6d0f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoScheduler.kt
@@ -0,0 +1,39 @@
+package dev.hho.android.data.photoqueue
+
+import android.content.Context
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequest
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.WorkRequest
+import dagger.hilt.android.qualifiers.ApplicationContext
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class PhotoScheduler
+    @Inject
+    constructor(
+        @ApplicationContext private val context: Context,
+    ) {
+        private val workManager: WorkManager
+            get() = WorkManager.getInstance(context)
+
+        fun schedule() {
+            workManager.enqueueUniqueWork(UNIQUE_WORK_NAME, ExistingWorkPolicy.KEEP, buildRequest())
+        }
+
+        companion object {
+            const val UNIQUE_WORK_NAME = "dev.hho.android.photoqueue.upload"
+
+            internal fun buildRequest(): OneTimeWorkRequest =
+                OneTimeWorkRequestBuilder<PhotoUploadWorker>()
+                    .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
+                    .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, WorkRequest.MIN_BACKOFF_MILLIS, TimeUnit.MILLISECONDS)
+                    .build()
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoUploadWorker.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoUploadWorker.kt
new file mode 100644
index 0000000..96835d7
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoUploadWorker.kt
@@ -0,0 +1,29 @@
+package dev.hho.android.data.photoqueue
+
+import android.content.Context
+import androidx.hilt.work.HiltWorker
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import dev.hho.android.domain.AuthRepository
+import dev.hho.android.domain.AuthState
+import kotlinx.coroutines.flow.first
+
+@HiltWorker
+class PhotoUploadWorker
+    @AssistedInject
+    constructor(
+        @Assisted context: Context,
+        @Assisted params: WorkerParameters,
+        private val uploader: PhotoUploader,
+        private val authRepository: AuthRepository,
+    ) : CoroutineWorker(context, params) {
+        override suspend fun doWork(): Result {
+            if (authRepository.authState.first() != AuthState.LoggedIn) return Result.success()
+            return when (uploader.drain()) {
+                PhotoDrainOutcome.DRAINED -> Result.success()
+                PhotoDrainOutcome.RETRY_LATER, PhotoDrainOutcome.BLOCKED -> Result.retry()
+            }
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoUploader.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoUploader.kt
new file mode 100644
index 0000000..d7622a1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/photoqueue/PhotoUploader.kt
@@ -0,0 +1,130 @@
+package dev.hho.android.data.photoqueue
+
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.data.apiclient.AttachmentCategory
+import dev.hho.android.data.apiclient.AttachmentInfo
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.room.OutboxDao
+import dev.hho.android.data.room.PhotoQueueDao
+import dev.hho.android.data.room.PhotoQueueEntryEntity
+import dev.hho.android.data.room.PhotoState
+import javax.inject.Inject
+
+enum class PhotoDrainOutcome {
+    DRAINED,
+
+    RETRY_LATER,
+
+    BLOCKED,
+}
+
+open class PhotoUploader
+    @Inject
+    constructor(
+        private val repository: PhotoQueueRepository,
+        private val photoDao: PhotoQueueDao,
+        private val outboxDao: OutboxDao,
+        private val api: HhoApiClient,
+    ) {
+        open suspend fun drain(clock: () -> Long = System::currentTimeMillis): PhotoDrainOutcome {
+            repository.releaseWaitingParent()
+
+            for (orphan in photoDao.getByStates(listOf(PhotoState.UPLOADING))) {
+                when (val r = reconcile(orphan)) {
+                    ReconcileResult.Hit -> repository.markUploaded(orphan.id)
+                    ReconcileResult.Miss -> Unit
+                    is ReconcileResult.Failed -> {
+                        if (!r.error.isBlocking()) return PhotoDrainOutcome.RETRY_LATER
+                        repository.resetUploadingToQueued()
+                        return PhotoDrainOutcome.BLOCKED
+                    }
+                }
+            }
+            repository.resetUploadingToQueued()
+
+            var transientFailure = false
+            while (true) {
+                val entry = repository.nextDue(clock()) ?: break
+                if (outboxDao.hasPendingCreate(entry.itemId)) {
+                    repository.markWaitingParent(entry.id)
+                    continue
+                }
+                if (!repository.markUploading(entry.id)) continue
+                when (process(entry, clock)) {
+                    Step.Done -> Unit
+                    Step.Transient -> transientFailure = true
+                    Step.Blocked -> {
+                        repository.resetUploadingToQueued()
+                        return PhotoDrainOutcome.BLOCKED
+                    }
+                }
+            }
+            val waiting = photoDao.getByStates(listOf(PhotoState.QUEUED)).isNotEmpty()
+            return if (transientFailure || waiting) PhotoDrainOutcome.RETRY_LATER else PhotoDrainOutcome.DRAINED
+        }
+
+        private suspend fun process(
+            entry: PhotoQueueEntryEntity,
+            clock: () -> Long,
+        ): Step {
+            if (entry.attemptCount > 0) {
+                when (val r = reconcile(entry)) {
+                    ReconcileResult.Hit -> {
+                        repository.markUploaded(entry.id)
+                        return Step.Done
+                    }
+                    ReconcileResult.Miss -> Unit
+                    is ReconcileResult.Failed -> return fail(entry, r.error, clock)
+                }
+            }
+            val category = AttachmentCategory.entries.firstOrNull { it.wire == entry.category } ?: AttachmentCategory.IMAGE
+            val result = api.uploadAttachment(entry.itemId, category, repository.fileFor(entry))
+            val error = result.exceptionOrNull() ?: run {
+                repository.markUploaded(entry.id)
+                return Step.Done
+            }
+            return fail(entry, error, clock)
+        }
+
+        private suspend fun fail(
+            entry: PhotoQueueEntryEntity,
+            error: Throwable,
+            clock: () -> Long,
+        ): Step {
+            if (error.isBlocking()) return Step.Blocked
+            val retryable =
+                when (error) {
+                    is ApiError.PayloadTooLarge -> false
+                    is ApiError.Validation, is ApiError.Conflict -> false
+                    else -> true
+                }
+            repository.recordFailure(entry.id, describe(error), retryable, clock())
+            return if (retryable) Step.Transient else Step.Done
+        }
+
+        private suspend fun reconcile(entry: PhotoQueueEntryEntity): ReconcileResult {
+            val list = api.listAttachments(entry.itemId)
+            val error = list.exceptionOrNull()
+            if (error != null) return ReconcileResult.Failed(error)
+            val hit = list.getOrThrow().any { it.matches(entry) }
+            return if (hit) ReconcileResult.Hit else ReconcileResult.Miss
+        }
+
+        private fun AttachmentInfo.matches(entry: PhotoQueueEntryEntity): Boolean =
+            sha256.equals(entry.sha256, ignoreCase = true) && sizeBytes == entry.sizeBytes
+
+        private fun Throwable.isBlocking(): Boolean =
+            this is ApiError.Unauthorized || this is ApiError.UpgradeRequired || this is ApiError.NoInstanceConfigured
+
+        private fun describe(error: Throwable): String = (error as? ApiError)?.message ?: error.javaClass.simpleName
+
+        private sealed interface ReconcileResult {
+            data object Hit : ReconcileResult
+
+            data object Miss : ReconcileResult
+
+            data class Failed(val error: Throwable) : ReconcileResult
+        }
+
+        private enum class Step { Done, Transient, Blocked }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/receiving/ReceivingRepository.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/receiving/ReceivingRepository.kt
new file mode 100644
index 0000000..97e24c1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/receiving/ReceivingRepository.kt
@@ -0,0 +1,187 @@
+package dev.hho.android.data.receiving
+
+import androidx.room.withTransaction
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ReceivingLineEntity
+import dev.hho.android.data.room.ReceivingSessionEntity
+import dev.hho.android.data.room.ReceivingStatus
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import java.time.LocalDate
+import javax.inject.Inject
+import javax.inject.Singleton
+
+sealed class ReceivingException(message: String) : RuntimeException(message) {
+    class SessionNotFound(val sessionId: String) : ReceivingException("No receiving session $sessionId")
+
+    class SessionNotOpen(val sessionId: String, val status: String) :
+        ReceivingException("Receiving session $sessionId is $status, not OPEN")
+
+    class UnknownItem(val itemId: String) : ReceivingException("Item $itemId is not in the local mirror")
+
+    class LineNotFound(val sessionId: String, val itemId: String) :
+        ReceivingException("Session $sessionId has no line for item $itemId")
+
+    class InvalidArgument(message: String) : ReceivingException(message)
+}
+
+sealed interface ScanOutcome {
+    data class Counted(val line: ReceivingLineEntity) : ScanOutcome
+
+    data class Unexpected(val itemId: String) : ScanOutcome
+}
+
+enum class LineStatus { MATCHED, SHORT, OVER, UNEXPECTED }
+
+data class LineDiscrepancy(
+    val itemId: String,
+    val expectedQty: Int?,
+    val receivedQty: Int,
+    val status: LineStatus,
+    val difference: Int?,
+)
+
+data class DiscrepancySummary(val lines: List<LineDiscrepancy>) {
+    val shortLines: List<LineDiscrepancy> get() = lines.filter { it.status == LineStatus.SHORT }
+    val overLines: List<LineDiscrepancy> get() = lines.filter { it.status == LineStatus.OVER }
+    val unexpectedLines: List<LineDiscrepancy> get() = lines.filter { it.status == LineStatus.UNEXPECTED }
+    val matchedCount: Int get() = lines.count { it.status == LineStatus.MATCHED }
+
+    val totalExpected: Int get() = lines.sumOf { it.expectedQty ?: 0 }
+
+    val totalReceived: Int get() = lines.sumOf { it.receivedQty }
+
+    val isClean: Boolean get() = lines.all { it.status == LineStatus.MATCHED }
+}
+
+fun ReceivingLineEntity.toDiscrepancy(): LineDiscrepancy {
+    val expected = expectedQty
+    val status = when {
+        expected == null -> LineStatus.UNEXPECTED
+        receivedQty < expected -> LineStatus.SHORT
+        receivedQty > expected -> LineStatus.OVER
+        else -> LineStatus.MATCHED
+    }
+    return LineDiscrepancy(itemId, expected, receivedQty, status, expected?.let { receivedQty - it })
+}
+
+@Singleton
+class ReceivingRepository(
+    private val db: HhoDatabase,
+    private val newId: () -> String,
+    private val clock: () -> Long,
+) {
+    @Inject
+    constructor(db: HhoDatabase) : this(db, UuidV7Generator()::generate, System::currentTimeMillis)
+
+    private val dao get() = db.receivingDao()
+
+    suspend fun startSession(
+        vendor: String,
+        orderReference: String? = null,
+        purchasedOn: LocalDate? = null,
+    ): ReceivingSessionEntity {
+        val trimmed = vendor.trim()
+        if (trimmed.isEmpty()) throw ReceivingException.InvalidArgument("vendor must not be blank")
+        val session = ReceivingSessionEntity(
+            id = newId(),
+            vendor = trimmed,
+            orderReference = orderReference?.trim()?.ifEmpty { null },
+            purchasedOn = purchasedOn,
+            status = ReceivingStatus.OPEN,
+            createdAt = clock(),
+        )
+        dao.insertSession(session)
+        return session
+    }
+
+    suspend fun addExpected(sessionId: String, itemId: String, expectedQty: Int): ReceivingLineEntity {
+        if (expectedQty < 1) throw ReceivingException.InvalidArgument("expectedQty must be >= 1")
+        return db.withTransaction {
+            requireOpen(sessionId)
+            requireItem(itemId)
+            val line = ReceivingLineEntity(
+                sessionId, itemId, expectedQty, dao.getLine(sessionId, itemId)?.receivedQty ?: 0,
+            )
+            dao.upsertLine(line)
+            line
+        }
+    }
+
+    suspend fun recordScan(sessionId: String, itemId: String): ScanOutcome =
+        db.withTransaction {
+            requireOpen(sessionId)
+            requireItem(itemId)
+            if (dao.addReceived(sessionId, itemId, 1) == 0) {
+                ScanOutcome.Unexpected(itemId)
+            } else {
+                ScanOutcome.Counted(checkNotNull(dao.getLine(sessionId, itemId)))
+            }
+        }
+
+    suspend fun confirmUnexpected(sessionId: String, itemId: String): ReceivingLineEntity =
+        db.withTransaction {
+            requireOpen(sessionId)
+            requireItem(itemId)
+            if (dao.addReceived(sessionId, itemId, 1) == 0) {
+                dao.upsertLine(ReceivingLineEntity(sessionId, itemId, null, 1))
+            }
+            checkNotNull(dao.getLine(sessionId, itemId))
+        }
+
+    suspend fun setReceived(sessionId: String, itemId: String, receivedQty: Int): ReceivingLineEntity {
+        if (receivedQty < 0) throw ReceivingException.InvalidArgument("receivedQty must be >= 0")
+        return db.withTransaction {
+            requireOpen(sessionId)
+            if (dao.setReceived(sessionId, itemId, receivedQty) == 0) {
+                throw ReceivingException.LineNotFound(sessionId, itemId)
+            }
+            checkNotNull(dao.getLine(sessionId, itemId))
+        }
+    }
+
+    suspend fun adjustReceived(sessionId: String, itemId: String, delta: Int): ReceivingLineEntity =
+        db.withTransaction {
+            if (dao.adjustReceived(sessionId, itemId, delta) == 0) {
+                requireOpen(sessionId)
+                throw ReceivingException.LineNotFound(sessionId, itemId)
+            }
+            checkNotNull(dao.getLine(sessionId, itemId))
+        }
+
+    suspend fun cancel(sessionId: String) {
+        db.withTransaction {
+            val session = dao.getSession(sessionId) ?: throw ReceivingException.SessionNotFound(sessionId)
+            when (session.status) {
+                ReceivingStatus.CANCELLED -> Unit
+                ReceivingStatus.OPEN ->
+                    dao.updateSession(session.copy(status = ReceivingStatus.CANCELLED, completedAt = clock()))
+                else -> throw ReceivingException.SessionNotOpen(sessionId, session.status)
+            }
+        }
+    }
+
+    fun observeSession(sessionId: String): Flow<ReceivingSessionEntity?> = dao.observeSession(sessionId)
+
+    fun observeLines(sessionId: String): Flow<List<ReceivingLineEntity>> = dao.observeLines(sessionId)
+
+    fun observeOpenSessions(): Flow<List<ReceivingSessionEntity>> = dao.observeByStatus(ReceivingStatus.OPEN)
+
+    fun observeSummary(sessionId: String): Flow<DiscrepancySummary> =
+        dao.observeLines(sessionId).map { DiscrepancySummary(it.map(ReceivingLineEntity::toDiscrepancy)) }
+
+    suspend fun summary(sessionId: String): DiscrepancySummary =
+        DiscrepancySummary(dao.getLines(sessionId).map(ReceivingLineEntity::toDiscrepancy))
+
+    private suspend fun requireOpen(sessionId: String) {
+        val session = dao.getSession(sessionId) ?: throw ReceivingException.SessionNotFound(sessionId)
+        if (session.status != ReceivingStatus.OPEN) {
+            throw ReceivingException.SessionNotOpen(sessionId, session.status)
+        }
+    }
+
+    private suspend fun requireItem(itemId: String) {
+        if (db.itemDao().getById(itemId) == null) throw ReceivingException.UnknownItem(itemId)
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/AttachmentEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/AttachmentEntity.kt
new file mode 100644
index 0000000..63c649e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/AttachmentEntity.kt
@@ -0,0 +1,68 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Upsert
+import dev.hho.android.data.apiclient.SyncChange
+import kotlinx.coroutines.flow.Flow
+
+@Entity(tableName = "attachment", indices = [Index("item_id")])
+data class AttachmentEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(name = "group_change_seq") val groupChangeSeq: Long,
+    @ColumnInfo(name = "item_id") val itemId: String,
+    val category: String,
+    @ColumnInfo(name = "original_filename") val originalFilename: String,
+    @ColumnInfo(name = "content_type") val contentType: String,
+    @ColumnInfo(name = "size_bytes") val sizeBytes: Long,
+    val sha256: String,
+    @ColumnInfo(name = "has_thumbnail") val hasThumbnail: Boolean,
+    @ColumnInfo(name = "created_at") val createdAt: Long,
+    @ColumnInfo(name = "updated_at") val updatedAt: Long,
+    val version: Long,
+)
+
+fun SyncChange.AttachmentChange.toEntity(): AttachmentEntity =
+    AttachmentEntity(
+        id = id,
+        groupChangeSeq = groupChangeSeq,
+        itemId = data.itemId,
+        category = data.category.value,
+        originalFilename = data.originalFilename,
+        contentType = data.contentType,
+        sizeBytes = data.sizeBytes,
+        sha256 = data.sha256,
+        hasThumbnail = data.hasThumbnail,
+        createdAt = data.createdAt,
+        updatedAt = data.updatedAt,
+        version = data.version,
+    )
+
+@Dao
+interface AttachmentDao {
+
+    @Upsert
+    suspend fun upsert(entity: AttachmentEntity)
+
+    @Upsert
+    suspend fun upsertAll(entities: List<AttachmentEntity>)
+
+    @Query("DELETE FROM attachment WHERE id = :id")
+    suspend fun deleteById(id: String)
+
+    @Query("DELETE FROM attachment WHERE id IN (:ids)")
+    suspend fun deleteByIds(ids: List<String>)
+
+    @Query("DELETE FROM attachment")
+    suspend fun clearAll()
+
+    @Query("SELECT * FROM attachment WHERE item_id = :itemId")
+    fun observeByItemId(itemId: String): Flow<List<AttachmentEntity>>
+
+    @Query("SELECT * FROM attachment WHERE id = :id")
+    suspend fun getById(id: String): AttachmentEntity?
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/ConflictRecordEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/ConflictRecordEntity.kt
new file mode 100644
index 0000000..86b4f2b
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/ConflictRecordEntity.kt
@@ -0,0 +1,89 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import kotlinx.coroutines.flow.Flow
+
+@Entity(
+    tableName = "conflict_record",
+    indices = [Index(value = ["mutation_id", "entity_id", "field_name"], unique = true)],
+)
+data class ConflictRecordEntity(
+    @PrimaryKey(autoGenerate = true) val id: Long = 0,
+    @ColumnInfo(name = "mutation_id") val mutationId: String,
+    @ColumnInfo(name = "entity_type") val entityType: String,
+    @ColumnInfo(name = "entity_id") val entityId: String,
+    @ColumnInfo(name = "field_name") val fieldName: String,
+    @ColumnInfo(name = "losing_value_json") val losingValueJson: String? = null,
+    @ColumnInfo(name = "server_value_json") val serverValueJson: String? = null,
+    @ColumnInfo(name = "detected_at") val detectedAt: Long,
+    val origin: String,
+)
+
+object ConflictOrigin {
+    const val LOCAL_PUSH: String = "LOCAL_PUSH"
+    const val SERVER_LOG: String = "SERVER_LOG"
+}
+
+@Dao
+interface ConflictRecordDao {
+    @Insert(onConflict = OnConflictStrategy.IGNORE)
+    suspend fun insertIgnore(record: ConflictRecordEntity): Long
+
+    @Query(
+        "SELECT * FROM conflict_record WHERE mutation_id = :mutationId " +
+            "AND entity_id = :entityId AND field_name = :fieldName",
+    )
+    suspend fun find(mutationId: String, entityId: String, fieldName: String): ConflictRecordEntity?
+
+    @Query(
+        "UPDATE conflict_record SET losing_value_json = :losing, server_value_json = :server " +
+            "WHERE mutation_id = :mutationId AND entity_id = :entityId AND field_name = :fieldName",
+    )
+    suspend fun enrich(mutationId: String, entityId: String, fieldName: String, losing: String?, server: String?): Int
+
+    @Query(
+        "UPDATE conflict_record SET losing_value_json = COALESCE(:losing, losing_value_json), " +
+            "server_value_json = COALESCE(:server, server_value_json), detected_at = :detectedAt, " +
+            "origin = '${ConflictOrigin.SERVER_LOG}' " +
+            "WHERE mutation_id = :mutationId AND entity_id = :entityId AND field_name = :fieldName",
+    )
+    suspend fun mergeServerLog(
+        mutationId: String,
+        entityId: String,
+        fieldName: String,
+        losing: String?,
+        server: String?,
+        detectedAt: Long,
+    ): Int
+
+    @Query("SELECT * FROM conflict_record ORDER BY detected_at DESC, id DESC")
+    fun observeAll(): Flow<List<ConflictRecordEntity>>
+
+    @Query("SELECT * FROM conflict_record ORDER BY detected_at DESC, id DESC")
+    suspend fun getAll(): List<ConflictRecordEntity>
+
+    @Query("SELECT COUNT(*) FROM conflict_record")
+    fun observeCount(): Flow<Int>
+
+    @Query(
+        "SELECT name FROM (" +
+            "SELECT name FROM item WHERE :entityType = 'item' AND id = :entityId " +
+            "UNION ALL SELECT item.name AS name FROM stock_adjustment JOIN item ON item.id = stock_adjustment.item_id " +
+            "WHERE :entityType = 'stock_adjustment' AND stock_adjustment.id = :entityId " +
+            "UNION ALL SELECT item.name AS name FROM purchased_from_block JOIN item ON item.id = purchased_from_block.item_id " +
+            "WHERE :entityType = 'purchased_from_block' AND purchased_from_block.id = :entityId " +
+            "UNION ALL SELECT item.name AS name FROM item_identification JOIN item ON item.id = item_identification.item_id " +
+            "WHERE :entityType = 'item_identification' AND item_identification.id = :entityId " +
+            "UNION ALL SELECT item.name AS name FROM item_label JOIN item ON item.id = item_label.item_id " +
+            "WHERE :entityType = 'item_label' AND item_label.id = :entityId" +
+            ") LIMIT 1",
+    )
+    suspend fun itemNameFor(entityType: String, entityId: String): String?
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/Converters.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/Converters.kt
new file mode 100644
index 0000000..c15e75c
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/Converters.kt
@@ -0,0 +1,20 @@
+package dev.hho.android.data.room
+
+import androidx.room.TypeConverter
+import java.math.BigDecimal
+import java.time.LocalDate
+
+internal object Converters {
+
+    @TypeConverter
+    fun fromLocalDate(value: LocalDate?): Long? = value?.toEpochDay()
+
+    @TypeConverter
+    fun toLocalDate(epochDay: Long?): LocalDate? = epochDay?.let(LocalDate::ofEpochDay)
+
+    @TypeConverter
+    fun fromBigDecimal(value: BigDecimal?): String? = value?.toPlainString()
+
+    @TypeConverter
+    fun toBigDecimal(value: String?): BigDecimal? = value?.let(::BigDecimal)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/HhoDatabase.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/HhoDatabase.kt
new file mode 100644
index 0000000..51c512a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/HhoDatabase.kt
@@ -0,0 +1,113 @@
+package dev.hho.android.data.room
+
+import androidx.room.Database
+import androidx.room.RoomDatabase
+import androidx.room.TypeConverters
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
+
+@Database(
+    entities = [
+        ItemEntity::class,
+        WarrantyBlockEntity::class,
+        SoldToBlockEntity::class,
+        PurchasedFromBlockEntity::class,
+        ItemIdentificationEntity::class,
+        ItemCustomFieldEntity::class,
+        StockAdjustmentEntity::class,
+        LocationEntity::class,
+        LabelEntity::class,
+        ItemLabelEntity::class,
+        AttachmentEntity::class,
+        SyncStateEntity::class,
+        OutboxMutationEntity::class,
+        ReceivingSessionEntity::class,
+        ReceivingLineEntity::class,
+        PhotoQueueEntryEntity::class,
+        ConflictRecordEntity::class,
+        SyncRunStateEntity::class,
+    ],
+    version = 2,
+    exportSchema = true,
+)
+@TypeConverters(Converters::class)
+abstract class HhoDatabase : RoomDatabase() {
+    abstract fun itemDao(): ItemDao
+
+    abstract fun warrantyBlockDao(): WarrantyBlockDao
+
+    abstract fun soldToBlockDao(): SoldToBlockDao
+
+    abstract fun purchasedFromBlockDao(): PurchasedFromBlockDao
+
+    abstract fun itemIdentificationDao(): ItemIdentificationDao
+
+    abstract fun itemCustomFieldDao(): ItemCustomFieldDao
+
+    abstract fun stockAdjustmentDao(): StockAdjustmentDao
+
+    abstract fun locationDao(): LocationDao
+
+    abstract fun labelDao(): LabelDao
+
+    abstract fun itemLabelDao(): ItemLabelDao
+
+    abstract fun attachmentDao(): AttachmentDao
+
+    abstract fun syncStateDao(): SyncStateDao
+
+    abstract fun outboxDao(): OutboxDao
+
+    abstract fun receivingDao(): ReceivingDao
+
+    abstract fun photoQueueDao(): PhotoQueueDao
+
+    abstract fun conflictRecordDao(): ConflictRecordDao
+
+    abstract fun syncRunStateDao(): SyncRunStateDao
+}
+
+val MIGRATION_1_2: Migration = object : Migration(1, 2) {
+    override fun migrate(db: SupportSQLiteDatabase) {
+        db.execSQL(
+            "CREATE TABLE IF NOT EXISTS `outbox_mutation` (`seq` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " +
+                "`mutation_id` TEXT NOT NULL, `entity_type` TEXT NOT NULL, `entity_id` TEXT NOT NULL, " +
+                "`op` TEXT NOT NULL, `base_version` INTEGER NOT NULL, `fields_json` TEXT NOT NULL, " +
+                "`state` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, `last_error` TEXT, " +
+                "`last_attempt_at` INTEGER, `created_at` INTEGER NOT NULL)",
+        )
+        db.execSQL("CREATE UNIQUE INDEX IF NOT EXISTS `index_outbox_mutation_mutation_id` ON `outbox_mutation` (`mutation_id`)")
+        db.execSQL("CREATE INDEX IF NOT EXISTS `index_outbox_mutation_state_seq` ON `outbox_mutation` (`state`, `seq`)")
+        db.execSQL("CREATE INDEX IF NOT EXISTS `index_outbox_mutation_entity_type_entity_id` ON `outbox_mutation` (`entity_type`, `entity_id`)")
+        db.execSQL(
+            "CREATE TABLE IF NOT EXISTS `receiving_session` (`id` TEXT NOT NULL, `vendor` TEXT NOT NULL, " +
+                "`order_reference` TEXT, `purchased_on` INTEGER, `status` TEXT NOT NULL, " +
+                "`created_at` INTEGER NOT NULL, `completed_at` INTEGER, PRIMARY KEY(`id`))",
+        )
+        db.execSQL("CREATE INDEX IF NOT EXISTS `index_receiving_session_status` ON `receiving_session` (`status`)")
+        db.execSQL(
+            "CREATE TABLE IF NOT EXISTS `receiving_line` (`session_id` TEXT NOT NULL, `item_id` TEXT NOT NULL, " +
+                "`expected_qty` INTEGER, `received_qty` INTEGER NOT NULL, PRIMARY KEY(`session_id`, `item_id`))",
+        )
+        db.execSQL(
+            "CREATE TABLE IF NOT EXISTS `photo_queue_entry` (`id` TEXT NOT NULL, `item_id` TEXT NOT NULL, " +
+                "`file_path` TEXT NOT NULL, `sha256` TEXT NOT NULL, `size_bytes` INTEGER NOT NULL, " +
+                "`category` TEXT NOT NULL, `state` TEXT NOT NULL, `attempt_count` INTEGER NOT NULL, " +
+                "`next_attempt_at` INTEGER, `last_error` TEXT, `created_at` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        )
+        db.execSQL("CREATE INDEX IF NOT EXISTS `index_photo_queue_entry_state_created_at` ON `photo_queue_entry` (`state`, `created_at`)")
+        db.execSQL("CREATE INDEX IF NOT EXISTS `index_photo_queue_entry_item_id` ON `photo_queue_entry` (`item_id`)")
+        db.execSQL(
+            "CREATE TABLE IF NOT EXISTS `conflict_record` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " +
+                "`mutation_id` TEXT NOT NULL, `entity_type` TEXT NOT NULL, `entity_id` TEXT NOT NULL, " +
+                "`field_name` TEXT NOT NULL, `losing_value_json` TEXT, `server_value_json` TEXT, " +
+                "`detected_at` INTEGER NOT NULL, `origin` TEXT NOT NULL)",
+        )
+        db.execSQL("CREATE UNIQUE INDEX IF NOT EXISTS `index_conflict_record_mutation_id_entity_id_field_name` ON `conflict_record` (`mutation_id`, `entity_id`, `field_name`)")
+        db.execSQL(
+            "CREATE TABLE IF NOT EXISTS `sync_run_state` (`id` INTEGER NOT NULL, `last_run_at` INTEGER, " +
+                "`last_push_at` INTEGER, `last_error` TEXT, `last_error_at` INTEGER, `conflict_cursor` TEXT, " +
+                "`reconcile_pending` INTEGER NOT NULL DEFAULT 0, PRIMARY KEY(`id`))",
+        )
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/ItemCustomFieldEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/ItemCustomFieldEntity.kt
new file mode 100644
index 0000000..acd2853
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/ItemCustomFieldEntity.kt
@@ -0,0 +1,69 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Upsert
+import dev.hho.android.data.apiclient.SyncChange
+import kotlinx.coroutines.flow.Flow
+import java.math.BigDecimal
+import java.time.LocalDate
+
+@Entity(tableName = "item_custom_field", indices = [Index("item_id")])
+data class ItemCustomFieldEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(name = "group_change_seq") val groupChangeSeq: Long,
+    @ColumnInfo(name = "item_id") val itemId: String?,
+    val name: String,
+    @ColumnInfo(name = "field_type") val fieldType: String,
+    @ColumnInfo(name = "field_def_id") val fieldDefId: String?,
+    @ColumnInfo(name = "text_value") val textValue: String?,
+    @ColumnInfo(name = "number_value") val numberValue: BigDecimal?,
+    @ColumnInfo(name = "bool_value") val boolValue: Boolean?,
+    @ColumnInfo(name = "date_value") val dateValue: LocalDate?,
+    @ColumnInfo(name = "created_at") val createdAt: Long?,
+    @ColumnInfo(name = "updated_at") val updatedAt: Long?,
+    val version: Long?,
+)
+
+fun SyncChange.ItemCustomFieldChange.toEntity(): ItemCustomFieldEntity =
+    ItemCustomFieldEntity(
+        id = id,
+        groupChangeSeq = groupChangeSeq,
+        itemId = data.itemId,
+        name = data.name,
+        fieldType = data.fieldType.value,
+        fieldDefId = data.fieldDefId,
+        textValue = data.textValue,
+        numberValue = data.numberValue,
+        boolValue = data.boolValue,
+        dateValue = data.dateValue,
+        createdAt = data.createdAt,
+        updatedAt = data.updatedAt,
+        version = data.version,
+    )
+
+@Dao
+interface ItemCustomFieldDao {
+
+    @Upsert
+    suspend fun upsert(entity: ItemCustomFieldEntity)
+
+    @Upsert
+    suspend fun upsertAll(entities: List<ItemCustomFieldEntity>)
+
+    @Query("DELETE FROM item_custom_field WHERE id = :id")
+    suspend fun deleteById(id: String)
+
+    @Query("DELETE FROM item_custom_field WHERE id IN (:ids)")
+    suspend fun deleteByIds(ids: List<String>)
+
+    @Query("DELETE FROM item_custom_field")
+    suspend fun clearAll()
+
+    @Query("SELECT * FROM item_custom_field WHERE item_id = :itemId")
+    fun observeByItemId(itemId: String): Flow<List<ItemCustomFieldEntity>>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/ItemEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/ItemEntity.kt
new file mode 100644
index 0000000..475dfb6
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/ItemEntity.kt
@@ -0,0 +1,91 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Upsert
+import dev.hho.android.data.apiclient.SyncChange
+import kotlinx.coroutines.flow.Flow
+
+@Entity(tableName = "item", indices = [Index("location_id")])
+data class ItemEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(name = "group_change_seq") val groupChangeSeq: Long,
+    val name: String,
+    val description: String?,
+    @ColumnInfo(name = "location_id") val locationId: String?,
+    val quantity: Long?,
+    @ColumnInfo(name = "short_code") val shortCode: String?,
+    @ColumnInfo(name = "created_at") val createdAt: Long?,
+    @ColumnInfo(name = "updated_at") val updatedAt: Long?,
+    val version: Long?,
+)
+
+fun SyncChange.ItemChange.toEntity(): ItemEntity =
+    ItemEntity(
+        id = id,
+        groupChangeSeq = groupChangeSeq,
+        name = data.name,
+        description = data.description,
+        locationId = data.locationId,
+        quantity = data.quantity,
+        shortCode = data.shortCode,
+        createdAt = data.createdAt,
+        updatedAt = data.updatedAt,
+        version = data.version,
+    )
+
+@Dao
+interface ItemDao {
+
+    @Upsert
+    suspend fun upsert(entity: ItemEntity)
+
+    @Upsert
+    suspend fun upsertAll(entities: List<ItemEntity>)
+
+    @Query("DELETE FROM item WHERE id = :id")
+    suspend fun deleteById(id: String)
+
+    @Query("DELETE FROM item WHERE id IN (:ids)")
+    suspend fun deleteByIds(ids: List<String>)
+
+    @Query("DELETE FROM item")
+    suspend fun clearAll()
+
+    @Query("SELECT * FROM item ORDER BY name")
+    fun observeAll(): Flow<List<ItemEntity>>
+
+    @Query("SELECT * FROM item WHERE id = :id")
+    fun observeById(id: String): Flow<ItemEntity?>
+
+    @Query("SELECT * FROM item WHERE id = :id")
+    suspend fun getById(id: String): ItemEntity?
+
+    @Query("SELECT * FROM item WHERE location_id = :locationId ORDER BY name")
+    fun observeByLocation(locationId: String): Flow<List<ItemEntity>>
+
+    @Query(
+        """
+        SELECT DISTINCT item.* FROM item
+        LEFT JOIN item_identification ON item_identification.item_id = item.id
+        WHERE item.name LIKE :likePattern ESCAPE '\'
+           OR item.short_code LIKE :likePattern ESCAPE '\'
+           OR item_identification.value LIKE :likePattern ESCAPE '\'
+        ORDER BY item.name
+        """,
+    )
+    fun search(likePattern: String): Flow<List<ItemEntity>>
+
+    @Query(
+        """
+        SELECT DISTINCT item.* FROM item
+        INNER JOIN item_identification ON item_identification.item_id = item.id
+        WHERE item_identification.value = :value
+        """,
+    )
+    suspend fun findByIdentifierValue(value: String): List<ItemEntity>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/ItemIdentificationEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/ItemIdentificationEntity.kt
new file mode 100644
index 0000000..daecb3c
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/ItemIdentificationEntity.kt
@@ -0,0 +1,63 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Upsert
+import dev.hho.android.data.apiclient.SyncChange
+import kotlinx.coroutines.flow.Flow
+
+@Entity(
+    tableName = "item_identification",
+    indices = [Index("item_id"), Index("value")],
+)
+data class ItemIdentificationEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(name = "group_change_seq") val groupChangeSeq: Long,
+    @ColumnInfo(name = "item_id") val itemId: String?,
+    val kind: String,
+    val value: String,
+    @ColumnInfo(name = "created_at") val createdAt: Long?,
+    @ColumnInfo(name = "updated_at") val updatedAt: Long?,
+    val version: Long?,
+)
+
+fun SyncChange.ItemIdentificationChange.toEntity(): ItemIdentificationEntity =
+    ItemIdentificationEntity(
+        id = id,
+        groupChangeSeq = groupChangeSeq,
+        itemId = data.itemId,
+        kind = data.kind.value,
+        value = data.value,
+        createdAt = data.createdAt,
+        updatedAt = data.updatedAt,
+        version = data.version,
+    )
+
+@Dao
+interface ItemIdentificationDao {
+
+    @Upsert
+    suspend fun upsert(entity: ItemIdentificationEntity)
+
+    @Upsert
+    suspend fun upsertAll(entities: List<ItemIdentificationEntity>)
+
+    @Query("DELETE FROM item_identification WHERE id = :id")
+    suspend fun deleteById(id: String)
+
+    @Query("DELETE FROM item_identification WHERE id IN (:ids)")
+    suspend fun deleteByIds(ids: List<String>)
+
+    @Query("DELETE FROM item_identification")
+    suspend fun clearAll()
+
+    @Query("SELECT * FROM item_identification WHERE item_id = :itemId")
+    fun observeByItemId(itemId: String): Flow<List<ItemIdentificationEntity>>
+
+    @Query("SELECT * FROM item_identification WHERE value = :value")
+    suspend fun findByValue(value: String): List<ItemIdentificationEntity>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/ItemLabelEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/ItemLabelEntity.kt
new file mode 100644
index 0000000..3dcb97a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/ItemLabelEntity.kt
@@ -0,0 +1,55 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Upsert
+import dev.hho.android.data.apiclient.SyncChange
+import kotlinx.coroutines.flow.Flow
+
+@Entity(
+    tableName = "item_label",
+    indices = [Index("item_id"), Index("label_id")],
+)
+data class ItemLabelEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(name = "group_change_seq") val groupChangeSeq: Long,
+    @ColumnInfo(name = "item_id") val itemId: String,
+    @ColumnInfo(name = "label_id") val labelId: String,
+)
+
+fun SyncChange.ItemLabelChange.toEntity(): ItemLabelEntity =
+    ItemLabelEntity(
+        id = id,
+        groupChangeSeq = groupChangeSeq,
+        itemId = data.itemId,
+        labelId = data.labelId,
+    )
+
+@Dao
+interface ItemLabelDao {
+
+    @Upsert
+    suspend fun upsert(entity: ItemLabelEntity)
+
+    @Upsert
+    suspend fun upsertAll(entities: List<ItemLabelEntity>)
+
+    @Query("DELETE FROM item_label WHERE id = :id")
+    suspend fun deleteById(id: String)
+
+    @Query("DELETE FROM item_label WHERE id IN (:ids)")
+    suspend fun deleteByIds(ids: List<String>)
+
+    @Query("DELETE FROM item_label")
+    suspend fun clearAll()
+
+    @Query("SELECT * FROM item_label WHERE item_id = :itemId")
+    fun observeByItemId(itemId: String): Flow<List<ItemLabelEntity>>
+
+    @Query("SELECT * FROM item_label WHERE label_id = :labelId")
+    fun observeByLabelId(labelId: String): Flow<List<ItemLabelEntity>>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/LabelEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/LabelEntity.kt
new file mode 100644
index 0000000..fb7b714
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/LabelEntity.kt
@@ -0,0 +1,57 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Upsert
+import dev.hho.android.data.apiclient.SyncChange
+import kotlinx.coroutines.flow.Flow
+
+@Entity(tableName = "label")
+data class LabelEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(name = "group_change_seq") val groupChangeSeq: Long,
+    val name: String,
+    val color: String,
+    @ColumnInfo(name = "created_at") val createdAt: Long,
+    @ColumnInfo(name = "updated_at") val updatedAt: Long,
+    val version: Long,
+)
+
+fun SyncChange.LabelChange.toEntity(): LabelEntity =
+    LabelEntity(
+        id = id,
+        groupChangeSeq = groupChangeSeq,
+        name = data.name,
+        color = data.color,
+        createdAt = data.createdAt,
+        updatedAt = data.updatedAt,
+        version = data.version,
+    )
+
+@Dao
+interface LabelDao {
+
+    @Upsert
+    suspend fun upsert(entity: LabelEntity)
+
+    @Upsert
+    suspend fun upsertAll(entities: List<LabelEntity>)
+
+    @Query("DELETE FROM label WHERE id = :id")
+    suspend fun deleteById(id: String)
+
+    @Query("DELETE FROM label WHERE id IN (:ids)")
+    suspend fun deleteByIds(ids: List<String>)
+
+    @Query("DELETE FROM label")
+    suspend fun clearAll()
+
+    @Query("SELECT * FROM label ORDER BY name")
+    fun observeAll(): Flow<List<LabelEntity>>
+
+    @Query("SELECT * FROM label WHERE id = :id")
+    suspend fun getById(id: String): LabelEntity?
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/LocationEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/LocationEntity.kt
new file mode 100644
index 0000000..8af60dc
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/LocationEntity.kt
@@ -0,0 +1,61 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Upsert
+import dev.hho.android.data.apiclient.SyncChange
+import kotlinx.coroutines.flow.Flow
+
+@Entity(tableName = "location", indices = [Index("parent_id")])
+data class LocationEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(name = "group_change_seq") val groupChangeSeq: Long,
+    val name: String,
+    @ColumnInfo(name = "parent_id") val parentId: String?,
+    @ColumnInfo(name = "created_at") val createdAt: Long,
+    @ColumnInfo(name = "updated_at") val updatedAt: Long,
+    val version: Long,
+)
+
+fun SyncChange.LocationChange.toEntity(): LocationEntity =
+    LocationEntity(
+        id = id,
+        groupChangeSeq = groupChangeSeq,
+        name = data.name,
+        parentId = data.parentId,
+        createdAt = data.createdAt,
+        updatedAt = data.updatedAt,
+        version = data.version,
+    )
+
+@Dao
+interface LocationDao {
+
+    @Upsert
+    suspend fun upsert(entity: LocationEntity)
+
+    @Upsert
+    suspend fun upsertAll(entities: List<LocationEntity>)
+
+    @Query("DELETE FROM location WHERE id = :id")
+    suspend fun deleteById(id: String)
+
+    @Query("DELETE FROM location WHERE id IN (:ids)")
+    suspend fun deleteByIds(ids: List<String>)
+
+    @Query("DELETE FROM location")
+    suspend fun clearAll()
+
+    @Query("SELECT * FROM location ORDER BY name")
+    fun observeAll(): Flow<List<LocationEntity>>
+
+    @Query("SELECT * FROM location WHERE id = :id")
+    suspend fun getById(id: String): LocationEntity?
+
+    @Query("SELECT * FROM location WHERE parent_id = :parentId ORDER BY name")
+    fun observeByParentId(parentId: String): Flow<List<LocationEntity>>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/OutboxMutationEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/OutboxMutationEntity.kt
new file mode 100644
index 0000000..a9b70d2
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/OutboxMutationEntity.kt
@@ -0,0 +1,109 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.Insert
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import kotlinx.coroutines.flow.Flow
+
+@Entity(
+    tableName = "outbox_mutation",
+    indices = [
+        Index(value = ["mutation_id"], unique = true),
+        Index(value = ["state", "seq"]),
+        Index(value = ["entity_type", "entity_id"]),
+    ],
+)
+data class OutboxMutationEntity(
+    @PrimaryKey(autoGenerate = true) val seq: Long = 0,
+    @ColumnInfo(name = "mutation_id") val mutationId: String,
+    @ColumnInfo(name = "entity_type") val entityType: String,
+    @ColumnInfo(name = "entity_id") val entityId: String,
+    val op: String,
+    @ColumnInfo(name = "base_version") val baseVersion: Long,
+    @ColumnInfo(name = "fields_json") val fieldsJson: String,
+    val state: String,
+    @ColumnInfo(name = "attempt_count") val attemptCount: Int = 0,
+    @ColumnInfo(name = "last_error") val lastError: String? = null,
+    @ColumnInfo(name = "last_attempt_at") val lastAttemptAt: Long? = null,
+    @ColumnInfo(name = "created_at") val createdAt: Long,
+)
+
+object OutboxState {
+    const val PENDING: String = "PENDING"
+    const val IN_FLIGHT: String = "IN_FLIGHT"
+    const val HELD: String = "HELD"
+    const val FAILED: String = "FAILED"
+}
+
+@Dao
+interface OutboxDao {
+    @Insert
+    suspend fun insert(mutation: OutboxMutationEntity): Long
+
+    @Query("SELECT * FROM outbox_mutation ORDER BY seq ASC")
+    suspend fun getAllOrdered(): List<OutboxMutationEntity>
+
+    @Query("SELECT * FROM outbox_mutation WHERE state = :state ORDER BY seq ASC LIMIT :limit")
+    suspend fun getByState(state: String, limit: Int = Int.MAX_VALUE): List<OutboxMutationEntity>
+
+    @Query("SELECT * FROM outbox_mutation WHERE entity_type = :entityType AND entity_id = :entityId ORDER BY seq ASC")
+    suspend fun getForEntity(entityType: String, entityId: String): List<OutboxMutationEntity>
+
+    @Query("SELECT * FROM outbox_mutation WHERE mutation_id = :mutationId")
+    suspend fun getByMutationId(mutationId: String): OutboxMutationEntity?
+
+    @Query("UPDATE outbox_mutation SET state = :state WHERE seq = :seq")
+    suspend fun updateState(seq: Long, state: String)
+
+    @Query("DELETE FROM outbox_mutation WHERE seq = :seq")
+    suspend fun deleteBySeq(seq: Long)
+
+    @Query(
+        "SELECT EXISTS(SELECT 1 FROM outbox_mutation WHERE entity_type = 'item' AND entity_id = :itemId " +
+            "AND op = 'upsert' AND base_version = 0 AND state IN ('PENDING', 'IN_FLIGHT', 'HELD'))",
+    )
+    suspend fun hasPendingCreate(itemId: String): Boolean
+
+    @Query("SELECT * FROM outbox_mutation WHERE state IN ('PENDING', 'IN_FLIGHT', 'HELD') ORDER BY seq ASC")
+    suspend fun getLive(): List<OutboxMutationEntity>
+
+    @Query(
+        "SELECT * FROM outbox_mutation WHERE entity_type = :entityType AND entity_id = :entityId " +
+            "AND state != 'FAILED' ORDER BY seq ASC",
+    )
+    suspend fun getLiveForEntity(entityType: String, entityId: String): List<OutboxMutationEntity>
+
+    @Query("UPDATE outbox_mutation SET fields_json = :fieldsJson WHERE seq = :seq")
+    suspend fun updateFields(seq: Long, fieldsJson: String)
+
+    @Query("UPDATE outbox_mutation SET state = :state, base_version = :baseVersion WHERE seq = :seq")
+    suspend fun updateStateAndBase(seq: Long, state: String, baseVersion: Long)
+
+    @Query(
+        "UPDATE outbox_mutation SET state = 'IN_FLIGHT', last_attempt_at = :now " +
+            "WHERE mutation_id IN (:mutationIds) AND state = 'PENDING'",
+    )
+    suspend fun markInFlight(mutationIds: List<String>, now: Long)
+
+    @Query("UPDATE outbox_mutation SET state = 'PENDING' WHERE state = 'IN_FLIGHT'")
+    suspend fun resetInFlightToPending(): Int
+
+    @Query("UPDATE outbox_mutation SET state = 'FAILED', last_error = :error WHERE mutation_id = :mutationId")
+    suspend fun markFailed(mutationId: String, error: String): Int
+
+    @Query(
+        "UPDATE outbox_mutation SET attempt_count = attempt_count + 1, last_error = :error, " +
+            "last_attempt_at = :now WHERE mutation_id = :mutationId",
+    )
+    suspend fun recordAttempt(mutationId: String, error: String?, now: Long): Int
+
+    @Query("SELECT COUNT(*) FROM outbox_mutation WHERE state IN (:states)")
+    fun observeCount(states: List<String>): Flow<Int>
+
+    @Query("SELECT * FROM outbox_mutation WHERE state = 'FAILED' ORDER BY seq ASC")
+    fun observeFailed(): Flow<List<OutboxMutationEntity>>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/PhotoQueueEntryEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/PhotoQueueEntryEntity.kt
new file mode 100644
index 0000000..79b5d7f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/PhotoQueueEntryEntity.kt
@@ -0,0 +1,84 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.Insert
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import kotlinx.coroutines.flow.Flow
+
+@Entity(
+    tableName = "photo_queue_entry",
+    indices = [
+        Index(value = ["state", "created_at"]),
+        Index(value = ["item_id"]),
+    ],
+)
+data class PhotoQueueEntryEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(name = "item_id") val itemId: String,
+    @ColumnInfo(name = "file_path") val filePath: String,
+    val sha256: String,
+    @ColumnInfo(name = "size_bytes") val sizeBytes: Long,
+    val category: String,
+    val state: String,
+    @ColumnInfo(name = "attempt_count") val attemptCount: Int = 0,
+    @ColumnInfo(name = "next_attempt_at") val nextAttemptAt: Long? = null,
+    @ColumnInfo(name = "last_error") val lastError: String? = null,
+    @ColumnInfo(name = "created_at") val createdAt: Long,
+)
+
+object PhotoState {
+    const val QUEUED: String = "QUEUED"
+    const val UPLOADING: String = "UPLOADING"
+    const val WAITING_PARENT: String = "WAITING_PARENT"
+    const val FAILED: String = "FAILED"
+}
+
+@Dao
+interface PhotoQueueDao {
+
+    @Insert
+    suspend fun insert(entry: PhotoQueueEntryEntity)
+
+    @Query("SELECT * FROM photo_queue_entry WHERE id = :id")
+    suspend fun getById(id: String): PhotoQueueEntryEntity?
+
+    @Query("SELECT * FROM photo_queue_entry ORDER BY created_at ASC, id ASC")
+    suspend fun getAllOrdered(): List<PhotoQueueEntryEntity>
+
+    @Query("SELECT * FROM photo_queue_entry WHERE state IN (:states) ORDER BY created_at ASC, id ASC")
+    suspend fun getByStates(states: List<String>): List<PhotoQueueEntryEntity>
+
+    @Query(
+        "SELECT * FROM photo_queue_entry WHERE state IN (:states) " +
+            "AND (next_attempt_at IS NULL OR next_attempt_at <= :now) ORDER BY created_at ASC, id ASC",
+    )
+    suspend fun getDue(states: List<String>, now: Long): List<PhotoQueueEntryEntity>
+
+    @Query(
+        "UPDATE photo_queue_entry SET state = :state, attempt_count = :attemptCount, " +
+            "next_attempt_at = :nextAttemptAt, last_error = :lastError WHERE id = :id",
+    )
+    suspend fun updateProgress(id: String, state: String, attemptCount: Int, nextAttemptAt: Long?, lastError: String?)
+
+    @Query("DELETE FROM photo_queue_entry WHERE id = :id")
+    suspend fun deleteById(id: String)
+
+    @Query("SELECT * FROM photo_queue_entry ORDER BY created_at ASC, id ASC")
+    fun observeAll(): Flow<List<PhotoQueueEntryEntity>>
+
+    @Query("SELECT * FROM photo_queue_entry WHERE item_id = :itemId ORDER BY created_at ASC, id ASC")
+    fun observeByItem(itemId: String): Flow<List<PhotoQueueEntryEntity>>
+
+    @Query("UPDATE photo_queue_entry SET state = :to, next_attempt_at = NULL WHERE state = :from")
+    suspend fun moveState(from: String, to: String): Int
+
+    @Query("SELECT COUNT(*) FROM photo_queue_entry WHERE state IN (:states)")
+    fun observeCount(states: List<String>): Flow<Int>
+
+    @Query("SELECT * FROM photo_queue_entry WHERE state = 'FAILED' ORDER BY created_at ASC, id ASC")
+    fun observeFailed(): Flow<List<PhotoQueueEntryEntity>>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/PurchasedFromBlockEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/PurchasedFromBlockEntity.kt
new file mode 100644
index 0000000..7747311
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/PurchasedFromBlockEntity.kt
@@ -0,0 +1,70 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Upsert
+import dev.hho.android.data.apiclient.SyncChange
+import kotlinx.coroutines.flow.Flow
+import java.time.LocalDate
+
+@Entity(tableName = "purchased_from_block", indices = [Index("item_id")])
+data class PurchasedFromBlockEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(name = "group_change_seq") val groupChangeSeq: Long,
+    @ColumnInfo(name = "item_id") val itemId: String?,
+    @ColumnInfo(name = "purchase_price_minor") val purchasePriceMinor: Long,
+    val vendor: String?,
+    @ColumnInfo(name = "purchased_on") val purchasedOn: LocalDate?,
+    @ColumnInfo(name = "order_reference") val orderReference: String?,
+    val notes: String?,
+    @ColumnInfo(name = "created_at") val createdAt: Long?,
+    @ColumnInfo(name = "updated_at") val updatedAt: Long?,
+    val version: Long?,
+)
+
+fun SyncChange.PurchasedFromBlockChange.toEntity(): PurchasedFromBlockEntity =
+    PurchasedFromBlockEntity(
+        id = id,
+        groupChangeSeq = groupChangeSeq,
+        itemId = data.itemId,
+        purchasePriceMinor = data.purchasePriceMinor,
+        vendor = data.vendor,
+        purchasedOn = data.purchasedOn,
+        orderReference = data.orderReference,
+        notes = data.notes,
+        createdAt = data.createdAt,
+        updatedAt = data.updatedAt,
+        version = data.version,
+    )
+
+@Dao
+interface PurchasedFromBlockDao {
+
+    @Upsert
+    suspend fun upsert(entity: PurchasedFromBlockEntity)
+
+    @Upsert
+    suspend fun upsertAll(entities: List<PurchasedFromBlockEntity>)
+
+    @Query("DELETE FROM purchased_from_block WHERE id = :id")
+    suspend fun deleteById(id: String)
+
+    @Query("DELETE FROM purchased_from_block WHERE id IN (:ids)")
+    suspend fun deleteByIds(ids: List<String>)
+
+    @Query("DELETE FROM purchased_from_block")
+    suspend fun clearAll()
+
+    @Query("SELECT version FROM purchased_from_block WHERE id = :id")
+    suspend fun versionById(id: String): Long?
+
+    @Query("SELECT * FROM purchased_from_block WHERE item_id = :itemId LIMIT 1")
+    suspend fun getByItemId(itemId: String): PurchasedFromBlockEntity?
+
+    @Query("SELECT * FROM purchased_from_block WHERE item_id = :itemId LIMIT 1")
+    fun observeByItemId(itemId: String): Flow<PurchasedFromBlockEntity?>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/ReceivingEntities.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/ReceivingEntities.kt
new file mode 100644
index 0000000..258d9aa
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/ReceivingEntities.kt
@@ -0,0 +1,100 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Update
+import kotlinx.coroutines.flow.Flow
+import java.time.LocalDate
+
+@Entity(
+    tableName = "receiving_session",
+    indices = [Index(value = ["status"])],
+)
+data class ReceivingSessionEntity(
+    @PrimaryKey val id: String,
+    val vendor: String,
+    @ColumnInfo(name = "order_reference") val orderReference: String? = null,
+    @ColumnInfo(name = "purchased_on") val purchasedOn: LocalDate? = null,
+    val status: String,
+    @ColumnInfo(name = "created_at") val createdAt: Long,
+    @ColumnInfo(name = "completed_at") val completedAt: Long? = null,
+)
+
+object ReceivingStatus {
+    const val OPEN: String = "OPEN"
+    const val COMPLETED: String = "COMPLETED"
+    const val CANCELLED: String = "CANCELLED"
+}
+
+@Entity(
+    tableName = "receiving_line",
+    primaryKeys = ["session_id", "item_id"],
+)
+data class ReceivingLineEntity(
+    @ColumnInfo(name = "session_id") val sessionId: String,
+    @ColumnInfo(name = "item_id") val itemId: String,
+    @ColumnInfo(name = "expected_qty") val expectedQty: Int? = null,
+    @ColumnInfo(name = "received_qty") val receivedQty: Int = 0,
+)
+
+@Dao
+interface ReceivingDao {
+
+    @Insert(onConflict = OnConflictStrategy.ABORT)
+    suspend fun insertSession(session: ReceivingSessionEntity)
+
+    @Update
+    suspend fun updateSession(session: ReceivingSessionEntity)
+
+    @Query("SELECT * FROM receiving_session WHERE id = :id")
+    suspend fun getSession(id: String): ReceivingSessionEntity?
+
+    @Query("SELECT * FROM receiving_session WHERE status = :status ORDER BY created_at DESC")
+    fun observeByStatus(status: String): Flow<List<ReceivingSessionEntity>>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun upsertLine(line: ReceivingLineEntity)
+
+    @Query("SELECT * FROM receiving_line WHERE session_id = :sessionId ORDER BY item_id ASC")
+    suspend fun getLines(sessionId: String): List<ReceivingLineEntity>
+
+    @Query("SELECT * FROM receiving_line WHERE session_id = :sessionId ORDER BY item_id ASC")
+    fun observeLines(sessionId: String): Flow<List<ReceivingLineEntity>>
+
+    @Query(
+        "UPDATE receiving_line SET received_qty = received_qty + :delta " +
+            "WHERE session_id = :sessionId AND item_id = :itemId",
+    )
+    suspend fun addReceived(sessionId: String, itemId: String, delta: Int): Int
+
+    @Query(
+        "UPDATE receiving_line SET received_qty = MAX(0, received_qty + :delta) " +
+            "WHERE session_id = :sessionId AND item_id = :itemId " +
+            "AND EXISTS (SELECT 1 FROM receiving_session WHERE id = :sessionId AND status = 'OPEN')",
+    )
+    suspend fun adjustReceived(sessionId: String, itemId: String, delta: Int): Int
+
+    @Query("SELECT * FROM receiving_session WHERE id = :id")
+    fun observeSession(id: String): Flow<ReceivingSessionEntity?>
+
+    @Query("SELECT * FROM receiving_line WHERE session_id = :sessionId AND item_id = :itemId")
+    suspend fun getLine(sessionId: String, itemId: String): ReceivingLineEntity?
+
+    @Query(
+        "UPDATE receiving_line SET received_qty = :qty " +
+            "WHERE session_id = :sessionId AND item_id = :itemId",
+    )
+    suspend fun setReceived(sessionId: String, itemId: String, qty: Int): Int
+
+    @Query("DELETE FROM receiving_line WHERE session_id = :sessionId")
+    suspend fun deleteLines(sessionId: String)
+
+    @Query("DELETE FROM receiving_session WHERE id = :id")
+    suspend fun deleteSession(id: String)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/SoldToBlockEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/SoldToBlockEntity.kt
new file mode 100644
index 0000000..c771613
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/SoldToBlockEntity.kt
@@ -0,0 +1,65 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Upsert
+import dev.hho.android.data.apiclient.SyncChange
+import kotlinx.coroutines.flow.Flow
+import java.time.LocalDate
+
+@Entity(tableName = "sold_to_block", indices = [Index("item_id")])
+data class SoldToBlockEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(name = "group_change_seq") val groupChangeSeq: Long,
+    @ColumnInfo(name = "item_id") val itemId: String?,
+    @ColumnInfo(name = "sale_price_minor") val salePriceMinor: Long,
+    @ColumnInfo(name = "buyer_name") val buyerName: String?,
+    @ColumnInfo(name = "sold_on") val soldOn: LocalDate?,
+    val notes: String?,
+    @ColumnInfo(name = "created_at") val createdAt: Long?,
+    @ColumnInfo(name = "updated_at") val updatedAt: Long?,
+    val version: Long?,
+)
+
+fun SyncChange.SoldToBlockChange.toEntity(): SoldToBlockEntity =
+    SoldToBlockEntity(
+        id = id,
+        groupChangeSeq = groupChangeSeq,
+        itemId = data.itemId,
+        salePriceMinor = data.salePriceMinor,
+        buyerName = data.buyerName,
+        soldOn = data.soldOn,
+        notes = data.notes,
+        createdAt = data.createdAt,
+        updatedAt = data.updatedAt,
+        version = data.version,
+    )
+
+@Dao
+interface SoldToBlockDao {
+
+    @Upsert
+    suspend fun upsert(entity: SoldToBlockEntity)
+
+    @Upsert
+    suspend fun upsertAll(entities: List<SoldToBlockEntity>)
+
+    @Query("DELETE FROM sold_to_block WHERE id = :id")
+    suspend fun deleteById(id: String)
+
+    @Query("DELETE FROM sold_to_block WHERE id IN (:ids)")
+    suspend fun deleteByIds(ids: List<String>)
+
+    @Query("DELETE FROM sold_to_block")
+    suspend fun clearAll()
+
+    @Query("SELECT * FROM sold_to_block WHERE item_id = :itemId LIMIT 1")
+    suspend fun getByItemId(itemId: String): SoldToBlockEntity?
+
+    @Query("SELECT * FROM sold_to_block WHERE item_id = :itemId LIMIT 1")
+    fun observeByItemId(itemId: String): Flow<SoldToBlockEntity?>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/StockAdjustmentEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/StockAdjustmentEntity.kt
new file mode 100644
index 0000000..cabd791
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/StockAdjustmentEntity.kt
@@ -0,0 +1,61 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Upsert
+import dev.hho.android.data.apiclient.SyncChange
+import kotlinx.coroutines.flow.Flow
+
+@Entity(tableName = "stock_adjustment", indices = [Index("item_id")])
+data class StockAdjustmentEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(name = "group_change_seq") val groupChangeSeq: Long,
+    @ColumnInfo(name = "item_id") val itemId: String?,
+    val delta: Long,
+    @ColumnInfo(name = "resulting_quantity") val resultingQuantity: Long,
+    val reason: String?,
+    val note: String?,
+    @ColumnInfo(name = "created_at") val createdAt: Long?,
+    @ColumnInfo(name = "updated_at") val updatedAt: Long?,
+    val version: Long?,
+)
+
+fun SyncChange.StockAdjustmentChange.toEntity(): StockAdjustmentEntity =
+    StockAdjustmentEntity(
+        id = id,
+        groupChangeSeq = groupChangeSeq,
+        itemId = data.itemId,
+        delta = data.delta,
+        resultingQuantity = data.resultingQuantity,
+        reason = data.reason,
+        note = data.note,
+        createdAt = data.createdAt,
+        updatedAt = data.updatedAt,
+        version = data.version,
+    )
+
+@Dao
+interface StockAdjustmentDao {
+
+    @Upsert
+    suspend fun upsert(entity: StockAdjustmentEntity)
+
+    @Upsert
+    suspend fun upsertAll(entities: List<StockAdjustmentEntity>)
+
+    @Query("DELETE FROM stock_adjustment WHERE id = :id")
+    suspend fun deleteById(id: String)
+
+    @Query("DELETE FROM stock_adjustment WHERE id IN (:ids)")
+    suspend fun deleteByIds(ids: List<String>)
+
+    @Query("DELETE FROM stock_adjustment")
+    suspend fun clearAll()
+
+    @Query("SELECT * FROM stock_adjustment WHERE item_id = :itemId ORDER BY created_at ASC")
+    fun observeByItemId(itemId: String): Flow<List<StockAdjustmentEntity>>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/SyncRunStateEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/SyncRunStateEntity.kt
new file mode 100644
index 0000000..7ee777a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/SyncRunStateEntity.kt
@@ -0,0 +1,59 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import kotlinx.coroutines.flow.Flow
+
+@Entity(tableName = "sync_run_state")
+data class SyncRunStateEntity(
+    @PrimaryKey val id: Int = SINGLETON_ID,
+    @ColumnInfo(name = "last_run_at") val lastRunAt: Long? = null,
+    @ColumnInfo(name = "last_push_at") val lastPushAt: Long? = null,
+    @ColumnInfo(name = "last_error") val lastError: String? = null,
+    @ColumnInfo(name = "last_error_at") val lastErrorAt: Long? = null,
+    @ColumnInfo(name = "conflict_cursor") val conflictCursor: String? = null,
+    @ColumnInfo(name = "reconcile_pending", defaultValue = "0") val reconcilePending: Boolean = false,
+) {
+    companion object {
+        const val SINGLETON_ID: Int = 0
+    }
+}
+
+@Dao
+interface SyncRunStateDao {
+
+    @Query("SELECT * FROM sync_run_state WHERE id = ${SyncRunStateEntity.SINGLETON_ID}")
+    suspend fun get(): SyncRunStateEntity?
+
+    @Query("SELECT * FROM sync_run_state WHERE id = ${SyncRunStateEntity.SINGLETON_ID}")
+    fun observe(): Flow<SyncRunStateEntity?>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun upsert(state: SyncRunStateEntity)
+
+    @Insert(onConflict = OnConflictStrategy.IGNORE)
+    suspend fun insertIfAbsent(state: SyncRunStateEntity)
+
+    @Query("UPDATE sync_run_state SET last_run_at = :at, last_error = NULL, last_error_at = NULL WHERE id = ${SyncRunStateEntity.SINGLETON_ID}")
+    suspend fun setRunSucceeded(at: Long)
+
+    @Query(
+        "UPDATE sync_run_state SET last_run_at = :at, last_error = :message, last_error_at = :at, " +
+            "reconcile_pending = MAX(reconcile_pending, :owed) WHERE id = ${SyncRunStateEntity.SINGLETON_ID}",
+    )
+    suspend fun setRunFailed(at: Long, message: String, owed: Boolean)
+
+    @Query("UPDATE sync_run_state SET last_push_at = :at WHERE id = ${SyncRunStateEntity.SINGLETON_ID}")
+    suspend fun setLastPushAt(at: Long)
+
+    @Query("UPDATE sync_run_state SET reconcile_pending = :owed WHERE id = ${SyncRunStateEntity.SINGLETON_ID}")
+    suspend fun setReconcilePending(owed: Boolean)
+
+    @Query("UPDATE sync_run_state SET conflict_cursor = :cursor WHERE id = ${SyncRunStateEntity.SINGLETON_ID}")
+    suspend fun setConflictCursor(cursor: String?)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/SyncStateEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/SyncStateEntity.kt
new file mode 100644
index 0000000..967f8c2
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/SyncStateEntity.kt
@@ -0,0 +1,35 @@
+package dev.hho.android.data.room
+
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Upsert
+import kotlinx.coroutines.flow.Flow
+
+@Entity(tableName = "sync_state")
+data class SyncStateEntity(
+    @PrimaryKey val id: Int = SINGLETON_ID,
+    val watermark: Long,
+    val lastSyncedAt: Long,
+) {
+    companion object {
+        const val SINGLETON_ID: Int = 0
+    }
+}
+
+@Dao
+interface SyncStateDao {
+
+    @Query("SELECT * FROM sync_state WHERE id = ${SyncStateEntity.SINGLETON_ID}")
+    suspend fun get(): SyncStateEntity?
+
+    @Query("SELECT * FROM sync_state WHERE id = ${SyncStateEntity.SINGLETON_ID}")
+    fun observe(): Flow<SyncStateEntity?>
+
+    @Upsert
+    suspend fun upsert(state: SyncStateEntity)
+
+    @Query("DELETE FROM sync_state")
+    suspend fun clear()
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/room/WarrantyBlockEntity.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/room/WarrantyBlockEntity.kt
new file mode 100644
index 0000000..c777b33
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/room/WarrantyBlockEntity.kt
@@ -0,0 +1,69 @@
+package dev.hho.android.data.room
+
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Upsert
+import dev.hho.android.data.apiclient.SyncChange
+import kotlinx.coroutines.flow.Flow
+import java.time.LocalDate
+
+@Entity(tableName = "warranty_block", indices = [Index("item_id")])
+data class WarrantyBlockEntity(
+    @PrimaryKey val id: String,
+    @ColumnInfo(name = "group_change_seq") val groupChangeSeq: Long,
+    @ColumnInfo(name = "item_id") val itemId: String?,
+    @ColumnInfo(name = "is_lifetime") val isLifetime: Boolean,
+    val holder: String?,
+    val provider: String?,
+    @ColumnInfo(name = "starts_on") val startsOn: LocalDate?,
+    @ColumnInfo(name = "expires_on") val expiresOn: LocalDate?,
+    val notes: String?,
+    @ColumnInfo(name = "created_at") val createdAt: Long?,
+    @ColumnInfo(name = "updated_at") val updatedAt: Long?,
+    val version: Long?,
+)
+
+fun SyncChange.WarrantyBlockChange.toEntity(): WarrantyBlockEntity =
+    WarrantyBlockEntity(
+        id = id,
+        groupChangeSeq = groupChangeSeq,
+        itemId = data.itemId,
+        isLifetime = data.isLifetime,
+        holder = data.holder,
+        provider = data.provider,
+        startsOn = data.startsOn,
+        expiresOn = data.expiresOn,
+        notes = data.notes,
+        createdAt = data.createdAt,
+        updatedAt = data.updatedAt,
+        version = data.version,
+    )
+
+@Dao
+interface WarrantyBlockDao {
+
+    @Upsert
+    suspend fun upsert(entity: WarrantyBlockEntity)
+
+    @Upsert
+    suspend fun upsertAll(entities: List<WarrantyBlockEntity>)
+
+    @Query("DELETE FROM warranty_block WHERE id = :id")
+    suspend fun deleteById(id: String)
+
+    @Query("DELETE FROM warranty_block WHERE id IN (:ids)")
+    suspend fun deleteByIds(ids: List<String>)
+
+    @Query("DELETE FROM warranty_block")
+    suspend fun clearAll()
+
+    @Query("SELECT * FROM warranty_block WHERE item_id = :itemId LIMIT 1")
+    suspend fun getByItemId(itemId: String): WarrantyBlockEntity?
+
+    @Query("SELECT * FROM warranty_block WHERE item_id = :itemId LIMIT 1")
+    fun observeByItemId(itemId: String): Flow<WarrantyBlockEntity?>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/BarcodeCameraSession.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/BarcodeCameraSession.kt
new file mode 100644
index 0000000..b7ab928
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/BarcodeCameraSession.kt
@@ -0,0 +1,82 @@
+package dev.hho.android.data.scanner
+
+import android.content.Context
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.Preview
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.LifecycleOwner
+import com.google.common.util.concurrent.ListenableFuture
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.suspendCancellableCoroutine
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import javax.inject.Inject
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+class BarcodeCameraSession
+    @Inject
+    constructor(
+        @ApplicationContext private val context: Context,
+    ) {
+        private var cameraProvider: ProcessCameraProvider? = null
+        private var analysisExecutor: ExecutorService? = null
+
+        suspend fun start(
+            lifecycleOwner: LifecycleOwner,
+            scanner: BarcodeScanner,
+            analyzerScope: CoroutineScope,
+            previewSurfaceProvider: Preview.SurfaceProvider? = null,
+            onBarcodesDetected: (List<DecodedBarcode>) -> Unit,
+            onScanError: (Throwable) -> Unit = {},
+        ) {
+            val provider = ProcessCameraProvider.getInstance(context).await(context)
+            cameraProvider = provider
+
+            val executor = Executors.newSingleThreadExecutor()
+            analysisExecutor = executor
+
+            val preview =
+                Preview.Builder().build().also { useCase ->
+                    previewSurfaceProvider?.let { useCase.setSurfaceProvider(it) }
+                }
+            val analysis =
+                ImageAnalysis.Builder()
+                    .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+                    .build()
+                    .also { useCase ->
+                        useCase.setAnalyzer(
+                            executor,
+                            BarcodeFrameAnalyzer(scanner, analyzerScope, onBarcodesDetected, onScanError),
+                        )
+                    }
+
+            provider.unbindAll()
+            provider.bindToLifecycle(lifecycleOwner, CameraSelector.DEFAULT_BACK_CAMERA, preview, analysis)
+        }
+
+        fun stop() {
+            cameraProvider?.unbindAll()
+            cameraProvider = null
+            analysisExecutor?.shutdown()
+            analysisExecutor = null
+        }
+    }
+
+private suspend fun <T> ListenableFuture<T>.await(context: Context): T =
+    suspendCancellableCoroutine { continuation ->
+        addListener(
+            {
+                try {
+                    continuation.resume(get())
+                } catch (failure: Exception) {
+                    continuation.resumeWithException(failure)
+                }
+            },
+            ContextCompat.getMainExecutor(context),
+        )
+        continuation.invokeOnCancellation { cancel(false) }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/BarcodeFormat.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/BarcodeFormat.kt
new file mode 100644
index 0000000..fa324b8
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/BarcodeFormat.kt
@@ -0,0 +1,19 @@
+package dev.hho.android.data.scanner
+
+enum class BarcodeFormat {
+    QR_CODE,
+    AZTEC,
+    DATA_MATRIX,
+    PDF_417,
+    CODE_39,
+    CODE_93,
+    CODE_128,
+    CODABAR,
+    ITF,
+    EAN_8,
+    EAN_13,
+    UPC_A,
+    UPC_E,
+
+    UNKNOWN,
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/BarcodeFrameAnalyzer.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/BarcodeFrameAnalyzer.kt
new file mode 100644
index 0000000..6634185
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/BarcodeFrameAnalyzer.kt
@@ -0,0 +1,32 @@
+package dev.hho.android.data.scanner
+
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.ImageProxy
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+
+class BarcodeFrameAnalyzer(
+    private val scanner: BarcodeScanner,
+    private val analyzerScope: CoroutineScope,
+    private val onBarcodesDetected: (List<DecodedBarcode>) -> Unit,
+    private val onScanError: (Throwable) -> Unit = {},
+) : ImageAnalysis.Analyzer {
+
+    override fun analyze(imageProxy: ImageProxy) {
+        analyzerScope.launch {
+            try {
+                val results = scanner.scan(imageProxy)
+                if (results.isNotEmpty()) {
+                    onBarcodesDetected(results)
+                }
+            } catch (cancellation: CancellationException) {
+                throw cancellation
+            } catch (failure: Throwable) {
+                onScanError(failure)
+            } finally {
+                imageProxy.close()
+            }
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/BarcodeScanner.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/BarcodeScanner.kt
new file mode 100644
index 0000000..a300f1d
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/BarcodeScanner.kt
@@ -0,0 +1,8 @@
+package dev.hho.android.data.scanner
+
+import androidx.camera.core.ImageProxy
+import java.io.Closeable
+
+interface BarcodeScanner : Closeable {
+    suspend fun scan(imageProxy: ImageProxy): List<DecodedBarcode>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/DecodedBarcode.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/DecodedBarcode.kt
new file mode 100644
index 0000000..5d2ab28
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/DecodedBarcode.kt
@@ -0,0 +1,6 @@
+package dev.hho.android.data.scanner
+
+data class DecodedBarcode(
+    val value: String,
+    val format: BarcodeFormat,
+)
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/ZxingBarcodeScanner.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/ZxingBarcodeScanner.kt
new file mode 100644
index 0000000..c9ecb94
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/scanner/ZxingBarcodeScanner.kt
@@ -0,0 +1,130 @@
+package dev.hho.android.data.scanner
+
+import androidx.camera.core.ImageProxy
+import com.google.zxing.BinaryBitmap
+import com.google.zxing.DecodeHintType
+import com.google.zxing.InvertedLuminanceSource
+import com.google.zxing.LuminanceSource
+import com.google.zxing.MultiFormatReader
+import com.google.zxing.NotFoundException
+import com.google.zxing.PlanarYUVLuminanceSource
+import com.google.zxing.ReaderException
+import com.google.zxing.common.HybridBinarizer
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
+import com.google.zxing.BarcodeFormat as ZxingFormat
+
+class ZxingBarcodeScanner
+    @Inject
+    constructor() : BarcodeScanner {
+
+        override suspend fun scan(imageProxy: ImageProxy): List<DecodedBarcode> {
+            val plane = imageProxy.planes.firstOrNull() ?: return emptyList()
+            val width = imageProxy.width
+            val height = imageProxy.height
+            val rowStride = plane.rowStride
+            val pixelStride = plane.pixelStride
+            val rotation = imageProxy.imageInfo.rotationDegrees
+            val buffer = plane.buffer.duplicate().also { it.rewind() }
+            val luminance = ByteArray(buffer.remaining()).also { buffer.get(it) }
+            return withContext(Dispatchers.Default) {
+                decodeLuminance(luminance, width, height, rowStride, pixelStride, rotation)
+            }
+        }
+
+        override fun close() = Unit
+    }
+
+internal fun decodeLuminance(
+    yPlane: ByteArray,
+    width: Int,
+    height: Int,
+    rowStride: Int,
+    pixelStride: Int,
+    rotationDegrees: Int,
+): List<DecodedBarcode> {
+    if (width <= 0 || height <= 0) return emptyList()
+    val packed = repackLuminance(yPlane, width, height, rowStride, pixelStride)
+    val (data, w, h) = rotateLuminance(packed, width, height, rotationDegrees)
+    val source = PlanarYUVLuminanceSource(data, w, h, 0, 0, w, h, false)
+    val hints = mapOf(DecodeHintType.TRY_HARDER to true)
+    return decodeSource(source, hints)
+        ?: decodeSource(InvertedLuminanceSource(source), hints)
+        ?: emptyList()
+}
+
+private fun decodeSource(
+    source: LuminanceSource,
+    hints: Map<DecodeHintType, Any>,
+): List<DecodedBarcode>? =
+    try {
+        val result = MultiFormatReader().decode(BinaryBitmap(HybridBinarizer(source)), hints)
+        listOfNotNull(mapZxingBarcode(result.text, result.barcodeFormat))
+    } catch (_: NotFoundException) {
+        null
+    } catch (_: ReaderException) {
+        null
+    }
+
+internal fun repackLuminance(
+    yPlane: ByteArray,
+    width: Int,
+    height: Int,
+    rowStride: Int,
+    pixelStride: Int,
+): ByteArray {
+    val out = ByteArray(width * height)
+    for (row in 0 until height) {
+        val rowStart = row * rowStride
+        for (col in 0 until width) {
+            val index = rowStart + col * pixelStride
+            if (index < yPlane.size) out[row * width + col] = yPlane[index]
+        }
+    }
+    return out
+}
+
+internal fun rotateLuminance(
+    data: ByteArray,
+    width: Int,
+    height: Int,
+    degrees: Int,
+): Triple<ByteArray, Int, Int> =
+    when (((degrees % 360) + 360) % 360) {
+        90 -> {
+            val out = ByteArray(data.size)
+            for (y in 0 until height) for (x in 0 until width) out[x * height + (height - 1 - y)] = data[y * width + x]
+            Triple(out, height, width)
+        }
+        180 -> Triple(data.reversedArray(), width, height)
+        270 -> {
+            val out = ByteArray(data.size)
+            for (y in 0 until height) for (x in 0 until width) out[(width - 1 - x) * height + y] = data[y * width + x]
+            Triple(out, height, width)
+        }
+        else -> Triple(data, width, height)
+    }
+
+internal fun mapZxingBarcode(
+    text: String?,
+    format: ZxingFormat?,
+): DecodedBarcode? = text?.let { DecodedBarcode(it, mapZxingFormat(format)) }
+
+internal fun mapZxingFormat(format: ZxingFormat?): BarcodeFormat =
+    when (format) {
+        ZxingFormat.QR_CODE -> BarcodeFormat.QR_CODE
+        ZxingFormat.AZTEC -> BarcodeFormat.AZTEC
+        ZxingFormat.DATA_MATRIX -> BarcodeFormat.DATA_MATRIX
+        ZxingFormat.PDF_417 -> BarcodeFormat.PDF_417
+        ZxingFormat.CODE_39 -> BarcodeFormat.CODE_39
+        ZxingFormat.CODE_93 -> BarcodeFormat.CODE_93
+        ZxingFormat.CODE_128 -> BarcodeFormat.CODE_128
+        ZxingFormat.CODABAR -> BarcodeFormat.CODABAR
+        ZxingFormat.ITF -> BarcodeFormat.ITF
+        ZxingFormat.EAN_8 -> BarcodeFormat.EAN_8
+        ZxingFormat.EAN_13 -> BarcodeFormat.EAN_13
+        ZxingFormat.UPC_A -> BarcodeFormat.UPC_A
+        ZxingFormat.UPC_E -> BarcodeFormat.UPC_E
+        else -> BarcodeFormat.UNKNOWN
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/settings/SettingsKeys.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/settings/SettingsKeys.kt
new file mode 100644
index 0000000..c79160e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/settings/SettingsKeys.kt
@@ -0,0 +1,9 @@
+package dev.hho.android.data.settings
+
+import androidx.datastore.preferences.core.stringPreferencesKey
+
+object SettingsKeys {
+    val INSTANCE_BASE_URL = stringPreferencesKey("instance_base_url")
+
+    val DEVICE_ID = stringPreferencesKey("device_id")
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/sync/ConflictLogSync.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/ConflictLogSync.kt
new file mode 100644
index 0000000..b65196b
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/ConflictLogSync.kt
@@ -0,0 +1,90 @@
+package dev.hho.android.data.sync
+
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.apiclient.generated.models.SyncConflictLogEntry
+import dev.hho.android.data.room.ConflictOrigin
+import dev.hho.android.data.room.ConflictRecordDao
+import dev.hho.android.data.room.ConflictRecordEntity
+import javax.inject.Inject
+
+data class ConflictLogSyncResult(
+    val fetched: Int,
+    val inserted: Int,
+    val merged: Int,
+    val complete: Boolean,
+)
+
+class ConflictLogSync
+    @Inject
+    constructor(
+        private val api: HhoApiClient,
+        private val conflicts: ConflictRecordDao,
+        private val recorder: SyncRunRecorder,
+    ) {
+        suspend fun sync(
+            pageSize: Int = PAGE_SIZE,
+            maxPages: Int = MAX_PAGES,
+        ): Result<ConflictLogSyncResult> {
+            val watermark = recorder.conflictWatermark()
+            var after: String? = null
+            var newest: Long? = null
+            var fetched = 0
+            var inserted = 0
+            var merged = 0
+            var complete = false
+            var pages = 0
+            while (pages < maxPages) {
+                pages++
+                val page = api.getConflicts(after = after, limit = pageSize).getOrElse { return Result.failure(it) }
+                var reachedKnown = false
+                for (entry in page.conflicts) {
+                    if (watermark != null && entry.detectedAt < watermark) {
+                        reachedKnown = true
+                        break
+                    }
+                    newest = maxOf(newest ?: entry.detectedAt, entry.detectedAt)
+                    fetched++
+                    if (upsert(entry)) inserted++ else merged++
+                }
+                val next = page.nextCursor
+                if (reachedKnown || next == null || next == after) {
+                    complete = true
+                    break
+                }
+                after = next
+            }
+            if (complete) advance(maxOf(newest ?: Long.MIN_VALUE, watermark ?: Long.MIN_VALUE))
+            return Result.success(ConflictLogSyncResult(fetched, inserted, merged, complete))
+        }
+
+        private suspend fun upsert(e: SyncConflictLogEntry): Boolean {
+            val key = e.mutationId ?: (NULL_MUTATION_PREFIX + e.id)
+            val changed = conflicts.mergeServerLog(key, e.entityId, e.fieldName, e.losingClientValue, e.serverValue, e.detectedAt)
+            if (changed > 0) return false
+            conflicts.insertIgnore(
+                ConflictRecordEntity(
+                    mutationId = key,
+                    entityType = e.entityType,
+                    entityId = e.entityId,
+                    fieldName = e.fieldName,
+                    losingValueJson = e.losingClientValue,
+                    serverValueJson = e.serverValue,
+                    detectedAt = e.detectedAt,
+                    origin = ConflictOrigin.SERVER_LOG,
+                ),
+            )
+            return true
+        }
+
+        private suspend fun advance(watermark: Long) {
+            if (watermark == Long.MIN_VALUE) return
+            recorder.advanceConflictWatermark(watermark)
+        }
+
+        companion object {
+            const val PAGE_SIZE: Int = 100
+            const val MAX_PAGES: Int = 25
+
+            const val NULL_MUTATION_PREFIX: String = "server:"
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/sync/FullSyncCoordinator.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/FullSyncCoordinator.kt
new file mode 100644
index 0000000..b8c5989
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/FullSyncCoordinator.kt
@@ -0,0 +1,68 @@
+package dev.hho.android.data.sync
+
+import androidx.room.withTransaction
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.apiclient.SyncPullOutcome
+import dev.hho.android.data.outbox.OutboxOverlay
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.SyncStateEntity
+import kotlinx.coroutines.CancellationException
+import javax.inject.Inject
+import javax.inject.Singleton
+
+private const val FULL_PULL_SINCE = 0L
+
+internal const val DEFAULT_FULL_PULL_PAGE_SIZE = 500
+
+@Singleton
+class FullSyncCoordinator
+    @Inject
+    constructor(
+        private val apiClient: HhoApiClient,
+        private val database: HhoDatabase,
+    ) {
+        suspend fun pullFull(
+            deviceId: String,
+            pageSize: Int = DEFAULT_FULL_PULL_PAGE_SIZE,
+        ): Result<Unit> {
+            val pages = mutableListOf<SyncPullOutcome.Page>()
+            var since = FULL_PULL_SINCE
+
+            while (true) {
+                val outcome =
+                    apiClient.syncPull(deviceId = deviceId, since = since, limit = pageSize)
+                        .getOrElse { return Result.failure(it) }
+                val page =
+                    when (outcome) {
+                        is SyncPullOutcome.Page -> outcome
+                        is SyncPullOutcome.CursorTooOld ->
+                            return Result.failure(UnexpectedCursorTooOldDuringFullPullException())
+                    }
+                pages += page
+                if (!page.hasMore) break
+                since = page.nextWatermark
+            }
+
+            return try {
+                database.withTransaction {
+                    SyncMirrorApplier.clearMirror(database)
+                    for (page in pages) {
+                        SyncMirrorApplier.applyPage(database, page)
+                    }
+                    OutboxOverlay.reapplyPending(database)
+                    val finalWatermark = pages.last().nextWatermark
+                    database.syncStateDao().upsert(
+                        SyncStateEntity(watermark = finalWatermark, lastSyncedAt = System.currentTimeMillis()),
+                    )
+                }
+                Result.success(Unit)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Throwable) {
+                Result.failure(e)
+            }
+        }
+    }
+
+class UnexpectedCursorTooOldDuringFullPullException :
+    IllegalStateException("/sync/pull answered cursor_too_old during a full pull (since: 0) — server/client drift")
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/sync/IncrementalSyncCoordinator.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/IncrementalSyncCoordinator.kt
new file mode 100644
index 0000000..2b7eadf
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/IncrementalSyncCoordinator.kt
@@ -0,0 +1,62 @@
+package dev.hho.android.data.sync
+
+import androidx.room.withTransaction
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.apiclient.SyncPullOutcome
+import dev.hho.android.data.outbox.OutboxOverlay
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.SyncStateEntity
+import kotlinx.coroutines.CancellationException
+import javax.inject.Inject
+import javax.inject.Singleton
+
+internal const val DEFAULT_INCREMENTAL_PULL_PAGE_SIZE = 500
+
+sealed interface IncrementalPullOutcome {
+    data object Applied : IncrementalPullOutcome
+
+    data object CursorTooOld : IncrementalPullOutcome
+}
+
+@Singleton
+class IncrementalSyncCoordinator
+    @Inject
+    constructor(
+        private val apiClient: HhoApiClient,
+        private val database: HhoDatabase,
+    ) {
+        suspend fun pullIncremental(
+            deviceId: String,
+            pageSize: Int = DEFAULT_INCREMENTAL_PULL_PAGE_SIZE,
+        ): Result<IncrementalPullOutcome> {
+            while (true) {
+                val since = database.syncStateDao().get()?.watermark ?: 0L
+
+                val outcome =
+                    apiClient.syncPull(deviceId = deviceId, since = since, limit = pageSize)
+                        .getOrElse { return Result.failure(it) }
+                val page =
+                    when (outcome) {
+                        is SyncPullOutcome.Page -> outcome
+                        is SyncPullOutcome.CursorTooOld ->
+                            return Result.success(IncrementalPullOutcome.CursorTooOld)
+                    }
+
+                try {
+                    database.withTransaction {
+                        SyncMirrorApplier.applyPage(database, page)
+                        OutboxOverlay.reapplyPending(database)
+                        database.syncStateDao().upsert(
+                            SyncStateEntity(watermark = page.nextWatermark, lastSyncedAt = System.currentTimeMillis()),
+                        )
+                    }
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (e: Throwable) {
+                    return Result.failure(e)
+                }
+
+                if (!page.hasMore) return Result.success(IncrementalPullOutcome.Applied)
+            }
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/sync/OutboxSyncer.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/OutboxSyncer.kt
new file mode 100644
index 0000000..5e43352
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/OutboxSyncer.kt
@@ -0,0 +1,181 @@
+package dev.hho.android.data.sync
+
+import androidx.room.withTransaction
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.apiclient.PushMutation
+import dev.hho.android.data.apiclient.SyncPushOutcome
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.outbox.toPushMutation
+import dev.hho.android.data.room.ConflictOrigin
+import dev.hho.android.data.room.ConflictRecordEntity
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.OutboxMutationEntity
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.contentOrNull
+import kotlinx.serialization.json.jsonObject
+
+internal enum class BlockedReason {
+    AUTH,
+
+    UPGRADE_REQUIRED,
+}
+
+internal sealed interface PushPhaseOutcome {
+    data object Drained : PushPhaseOutcome
+
+    data object NeedsReconcile : PushPhaseOutcome
+
+    data class Failed(val cause: ApiError, val reconcilePending: Boolean = false) : PushPhaseOutcome
+
+    data class Blocked(
+        val reason: BlockedReason,
+        val minimumVersion: String? = null,
+        val reconcilePending: Boolean = false,
+    ) : PushPhaseOutcome
+}
+
+internal class OutboxSyncer(
+    private val db: HhoDatabase,
+    private val api: HhoApiClient,
+    private val outbox: OutboxRepository = OutboxRepository(db),
+    private val clock: () -> Long = System::currentTimeMillis,
+) {
+    suspend fun push(deviceId: String): PushPhaseOutcome {
+        outbox.resetInFlightToPending()
+        val run = Run(deviceId)
+        while (true) {
+            val batch = outbox.nextBatch()
+            if (batch.isEmpty()) {
+                return if (run.reconcile) PushPhaseOutcome.NeedsReconcile else PushPhaseOutcome.Drained
+            }
+            run.send(batch)?.let { return it }
+        }
+    }
+
+    private inner class Run(private val deviceId: String) {
+        var reconcile = false
+        private val quarantined = HashSet<String>()
+
+        suspend fun send(allRows: List<OutboxMutationEntity>): PushPhaseOutcome? {
+            val decoded = ArrayList<Pair<OutboxMutationEntity, PushMutation>>(allRows.size)
+            for (row in allRows) {
+                try {
+                    decoded += row to row.toPushMutation()
+                } catch (e: Exception) {
+                    outbox.quarantine(row.mutationId, "Unreadable local edit: ${e::class.simpleName}")
+                }
+            }
+            if (decoded.isEmpty()) return null
+            val rows = decoded.map { it.first }
+            outbox.markInFlight(rows.map { it.mutationId })
+            val outcome = api.syncPush(deviceId, decoded.map { it.second })
+                .getOrElse { return failure(it, rows) }
+            return when (outcome) {
+                is SyncPushOutcome.Success -> handleSuccess(rows, outcome)
+                is SyncPushOutcome.StructuralRejection -> handleRejection(rows, outcome)
+            }
+        }
+
+        private suspend fun handleRejection(rows: List<OutboxMutationEntity>, r: SyncPushOutcome.StructuralRejection): PushPhaseOutcome? {
+            val offender = r.mutationId?.let { id -> rows.firstOrNull { it.mutationId == id } }
+                ?: rows.singleOrNull()
+            if (offender == null) {
+                outbox.resetInFlightToPending()
+                for (row in rows) {
+                    send(listOf(row))?.let { return it }
+                }
+                return null
+            }
+            if (!quarantined.add(offender.mutationId)) {
+                return failure(ApiError.UnexpectedPayload("row ${offender.mutationId} rejected again after quarantine"), rows)
+            }
+            outbox.quarantine(offender.mutationId, r.detail)
+            outbox.resetInFlightToPending()
+            return null
+        }
+
+        private suspend fun handleSuccess(rows: List<OutboxMutationEntity>, out: SyncPushOutcome.Success): PushPhaseOutcome? {
+            var answered = 0
+            val unanswered = ArrayList<OutboxMutationEntity>()
+            for (row in rows) {
+                val applied = out.applied.firstOrNull { it.mutationId == row.mutationId }
+                val skipped = out.skipped.any { it.mutationId == row.mutationId }
+                val conflicts = out.conflicts.filter { it.mutationId == row.mutationId }
+                if (applied == null && !skipped && conflicts.isEmpty()) {
+                    unanswered += row
+                    continue
+                }
+                answered++
+                db.withTransaction {
+                    if (conflicts.isNotEmpty()) recordConflicts(row, conflicts.map { it.fieldName })
+                    if (applied != null) {
+                        stampMirrorVersion(row, applied.version)
+                        outbox.ack(row.mutationId, applied.version)
+                    } else {
+                        outbox.ackSkipped(row.mutationId)
+                    }
+                }
+                if (conflicts.isNotEmpty()) reconcile = true
+            }
+            if (unanswered.isEmpty()) return null
+            unanswered.forEach { outbox.recordAttempt(it.mutationId, "no result in push response") }
+            outbox.resetInFlightToPending()
+            return if (answered == 0) {
+                PushPhaseOutcome.Failed(ApiError.UnexpectedPayload("push response answered none of ${rows.size} mutations"), reconcile)
+            } else {
+                null
+            }
+        }
+
+        private suspend fun failure(error: Throwable, rows: List<OutboxMutationEntity>): PushPhaseOutcome {
+            val e = error as? ApiError ?: ApiError.Unknown(error)
+            rows.forEach { outbox.recordAttempt(it.mutationId, e.message) }
+            outbox.resetInFlightToPending()
+            return when (e) {
+                is ApiError.Unauthorized -> PushPhaseOutcome.Blocked(BlockedReason.AUTH, reconcilePending = reconcile)
+                is ApiError.UpgradeRequired ->
+                    PushPhaseOutcome.Blocked(BlockedReason.UPGRADE_REQUIRED, e.minimumVersion, reconcile)
+                else -> PushPhaseOutcome.Failed(e, reconcile)
+            }
+        }
+    }
+
+    private suspend fun recordConflicts(row: OutboxMutationEntity, fieldNames: List<String>) {
+        val fields: JsonObject = Json.parseToJsonElement(row.fieldsJson).jsonObject
+        val now = clock()
+        for (field in fieldNames) {
+            val losing = if (field == ENTITY_SENTINEL) row.fieldsJson else fields[field]?.toString()
+            db.conflictRecordDao().insertIgnore(
+                ConflictRecordEntity(
+                    mutationId = row.mutationId,
+                    entityType = row.entityType,
+                    entityId = row.entityId,
+                    fieldName = field,
+                    losingValueJson = losing,
+                    serverValueJson = null,
+                    detectedAt = now,
+                    origin = ConflictOrigin.LOCAL_PUSH,
+                ),
+            )
+        }
+    }
+
+    private suspend fun stampMirrorVersion(row: OutboxMutationEntity, version: Long) {
+        when (row.entityType) {
+            "item" -> db.itemDao().getById(row.entityId)?.let { db.itemDao().upsert(it.copy(version = version)) }
+            "purchased_from_block" -> {
+                val itemId = (Json.parseToJsonElement(row.fieldsJson).jsonObject["item_id"] as? JsonPrimitive)?.contentOrNull
+                val dao = db.purchasedFromBlockDao()
+                itemId?.let { dao.getByItemId(it) }?.takeIf { it.id == row.entityId }
+                    ?.let { dao.upsert(it.copy(version = version)) }
+            }
+        }
+    }
+
+    private companion object {
+        const val ENTITY_SENTINEL = "_entity"
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncEngine.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncEngine.kt
new file mode 100644
index 0000000..7225ead
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncEngine.kt
@@ -0,0 +1,197 @@
+package dev.hho.android.data.sync
+
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.HhoDatabase
+import android.util.Log
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import javax.inject.Inject
+import javax.inject.Singleton
+
+sealed interface SyncRunOutcome {
+    sealed interface FullPullReason {
+        data object FirstSync : FullPullReason
+
+        data object CursorTooOldRecovery : FullPullReason
+
+        data object ConflictReconcile : FullPullReason
+    }
+
+    data class FullPullRan(val reason: FullPullReason) : SyncRunOutcome
+
+    data object IncrementalPullRan : SyncRunOutcome
+
+    data object AuthRequired : SyncRunOutcome
+
+    data class UpgradeRequired(val minimumVersion: String?) : SyncRunOutcome
+}
+
+fun interface PostSyncHook {
+    suspend fun onSyncSucceeded()
+}
+
+@Singleton
+class SyncEngine
+    internal constructor(
+        private val fullSyncCoordinator: FullSyncCoordinator,
+        private val incrementalSyncCoordinator: IncrementalSyncCoordinator,
+        private val database: HhoDatabase,
+        private val pushPhase: suspend (deviceId: String) -> PushPhaseOutcome,
+        private val outbox: OutboxRepository,
+        private val hooks: Set<@JvmSuppressWildcards PostSyncHook>,
+        private val recorder: SyncRunRecorder,
+        private val conflictLog: (suspend () -> Unit)?,
+    ) {
+        @Inject
+        internal constructor(
+            fullSyncCoordinator: FullSyncCoordinator,
+            incrementalSyncCoordinator: IncrementalSyncCoordinator,
+            database: HhoDatabase,
+            api: HhoApiClient,
+            outbox: OutboxRepository,
+            hooks: Set<@JvmSuppressWildcards PostSyncHook>,
+            recorder: SyncRunRecorder,
+            conflictLogSync: ConflictLogSync,
+        ) : this(
+            fullSyncCoordinator,
+            incrementalSyncCoordinator,
+            database,
+            OutboxSyncer(database, api, outbox)::push,
+            outbox,
+            hooks,
+            recorder,
+            { conflictLogSync.sync().getOrThrow() },
+        )
+
+        private val singleFlight = Mutex()
+
+        suspend fun sync(deviceId: String): Result<SyncRunOutcome> =
+            singleFlight.withLock { runLocked(deviceId) }
+
+        private suspend fun runLocked(deviceId: String): Result<SyncRunOutcome> {
+            outbox.resetInFlightToPending()
+            val owed = recorder.reconcileOwed()
+
+            when (val push = pushPhase(deviceId)) {
+                is PushPhaseOutcome.Failed -> {
+                    recordStop(push.reconcilePending, push.cause.message)
+                    return Result.failure(push.cause)
+                }
+                is PushPhaseOutcome.Blocked -> {
+                    val (outcome, message) =
+                        when (push.reason) {
+                            BlockedReason.AUTH -> SyncRunOutcome.AuthRequired to "Not authenticated"
+                            BlockedReason.UPGRADE_REQUIRED ->
+                                SyncRunOutcome.UpgradeRequired(push.minimumVersion) to
+                                    "Client too old: server requires at least ${push.minimumVersion}"
+                        }
+                    recordStop(push.reconcilePending, message)
+                    return Result.success(outcome)
+                }
+                PushPhaseOutcome.NeedsReconcile -> {
+                    recorder.recordPushReachedServer()
+                    return pullPhase(deviceId, forceFull = true, debtAlreadyStored = owed)
+                }
+                PushPhaseOutcome.Drained -> {
+                    recorder.recordPushReachedServer()
+                    return pullPhase(deviceId, forceFull = owed, debtAlreadyStored = owed)
+                }
+            }
+        }
+
+        private suspend fun pullPhase(
+            deviceId: String,
+            forceFull: Boolean,
+            debtAlreadyStored: Boolean,
+        ): Result<SyncRunOutcome> {
+            if (forceFull && !debtAlreadyStored) setDebt(true)
+
+            val pulled: Result<SyncRunOutcome> =
+                when {
+                    forceFull -> fullPull(deviceId, SyncRunOutcome.FullPullReason.ConflictReconcile)
+                    database.syncStateDao().get() == null -> fullPull(deviceId, SyncRunOutcome.FullPullReason.FirstSync)
+                    else -> incrementalOrRecover(deviceId)
+                }
+            if (pulled.isFailure) {
+                recordStop(reconcilePending = false, message = pulled.exceptionOrNull()?.message)
+                return pulled
+            }
+            return afterPull().map { pulled.getOrThrow() }
+        }
+
+        private suspend fun incrementalOrRecover(deviceId: String): Result<SyncRunOutcome> {
+            val outcome = incrementalSyncCoordinator.pullIncremental(deviceId).getOrElse { return Result.failure(it) }
+            return when (outcome) {
+                IncrementalPullOutcome.Applied -> Result.success(SyncRunOutcome.IncrementalPullRan)
+                IncrementalPullOutcome.CursorTooOld -> fullPull(deviceId, SyncRunOutcome.FullPullReason.CursorTooOldRecovery)
+            }
+        }
+
+        private suspend fun fullPull(
+            deviceId: String,
+            reason: SyncRunOutcome.FullPullReason,
+        ): Result<SyncRunOutcome> =
+            fullSyncCoordinator.pullFull(deviceId).map {
+                setDebt(false)
+                SyncRunOutcome.FullPullRan(reason)
+            }
+
+        private suspend fun afterPull(): Result<Unit> =
+            try {
+                outbox.releaseHeld(::mirrorVersion)
+                for (hook in hooks) runHook(hook)
+                runConflictLog()
+                recorder.recordSuccess()
+                Result.success(Unit)
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Throwable) {
+                Result.failure(e)
+            }
+
+        private suspend fun runConflictLog() {
+            val fetch = conflictLog ?: return
+            try {
+                fetch()
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Throwable) {
+                Log.w(TAG, "conflict log fetch failed: ${e.javaClass.simpleName}")
+            }
+        }
+
+        private suspend fun runHook(hook: PostSyncHook) {
+            try {
+                hook.onSyncSucceeded()
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Throwable) {
+                Log.w(TAG, "post-sync hook ${hook.javaClass.simpleName} failed: ${e.javaClass.simpleName}")
+            }
+        }
+
+        private suspend fun mirrorVersion(
+            type: String,
+            id: String,
+        ): Long? =
+            when (type) {
+                "item" -> database.itemDao().getById(id)?.version
+                "purchased_from_block" -> database.purchasedFromBlockDao().versionById(id)
+                else -> null
+            }
+
+        private companion object {
+            const val TAG = "SyncEngine"
+        }
+
+        private suspend fun setDebt(owed: Boolean) {
+            if (recorder.reconcileOwed() != owed) recorder.setReconcilePending(owed)
+        }
+
+        private suspend fun recordStop(
+            reconcilePending: Boolean,
+            message: String?,
+        ) = recorder.recordFailure(message, reconcilePending)
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncMirrorApplier.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncMirrorApplier.kt
new file mode 100644
index 0000000..7389ba1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncMirrorApplier.kt
@@ -0,0 +1,114 @@
+package dev.hho.android.data.sync
+
+import dev.hho.android.data.apiclient.MalformedSyncPullResponseException
+import dev.hho.android.data.apiclient.SyncChange
+import dev.hho.android.data.apiclient.SyncPullOutcome
+import dev.hho.android.data.apiclient.UnknownSyncEntityTypeException
+import dev.hho.android.data.apiclient.generated.models.SyncTombstoneEntry
+import dev.hho.android.data.room.AttachmentEntity
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemCustomFieldEntity
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemIdentificationEntity
+import dev.hho.android.data.room.ItemLabelEntity
+import dev.hho.android.data.room.LabelEntity
+import dev.hho.android.data.room.LocationEntity
+import dev.hho.android.data.room.PurchasedFromBlockEntity
+import dev.hho.android.data.room.SoldToBlockEntity
+import dev.hho.android.data.room.StockAdjustmentEntity
+import dev.hho.android.data.room.WarrantyBlockEntity
+import dev.hho.android.data.room.toEntity
+
+internal object SyncMirrorApplier {
+    suspend fun clearMirror(db: HhoDatabase) {
+        db.itemDao().clearAll()
+        db.warrantyBlockDao().clearAll()
+        db.soldToBlockDao().clearAll()
+        db.purchasedFromBlockDao().clearAll()
+        db.itemIdentificationDao().clearAll()
+        db.itemCustomFieldDao().clearAll()
+        db.stockAdjustmentDao().clearAll()
+        db.locationDao().clearAll()
+        db.labelDao().clearAll()
+        db.itemLabelDao().clearAll()
+        db.attachmentDao().clearAll()
+    }
+
+    suspend fun applyPage(
+        db: HhoDatabase,
+        page: SyncPullOutcome.Page,
+    ) {
+        applyChanges(db, page.changes)
+        applyTombstones(db, page.tombstones)
+    }
+
+    private suspend fun applyChanges(
+        db: HhoDatabase,
+        changes: List<SyncChange>,
+    ) {
+        if (changes.isEmpty()) return
+
+        val items = mutableListOf<ItemEntity>()
+        val warrantyBlocks = mutableListOf<WarrantyBlockEntity>()
+        val soldToBlocks = mutableListOf<SoldToBlockEntity>()
+        val purchasedFromBlocks = mutableListOf<PurchasedFromBlockEntity>()
+        val identifications = mutableListOf<ItemIdentificationEntity>()
+        val customFields = mutableListOf<ItemCustomFieldEntity>()
+        val stockAdjustments = mutableListOf<StockAdjustmentEntity>()
+        val locations = mutableListOf<LocationEntity>()
+        val labels = mutableListOf<LabelEntity>()
+        val itemLabels = mutableListOf<ItemLabelEntity>()
+        val attachments = mutableListOf<AttachmentEntity>()
+
+        for (change in changes) {
+            when (change) {
+                is SyncChange.ItemChange -> items += change.toEntity()
+                is SyncChange.WarrantyBlockChange -> warrantyBlocks += change.toEntity()
+                is SyncChange.SoldToBlockChange -> soldToBlocks += change.toEntity()
+                is SyncChange.PurchasedFromBlockChange -> purchasedFromBlocks += change.toEntity()
+                is SyncChange.ItemIdentificationChange -> identifications += change.toEntity()
+                is SyncChange.ItemCustomFieldChange -> customFields += change.toEntity()
+                is SyncChange.StockAdjustmentChange -> stockAdjustments += change.toEntity()
+                is SyncChange.LocationChange -> locations += change.toEntity()
+                is SyncChange.LabelChange -> labels += change.toEntity()
+                is SyncChange.ItemLabelChange -> itemLabels += change.toEntity()
+                is SyncChange.AttachmentChange -> attachments += change.toEntity()
+            }
+        }
+
+        if (items.isNotEmpty()) db.itemDao().upsertAll(items)
+        if (warrantyBlocks.isNotEmpty()) db.warrantyBlockDao().upsertAll(warrantyBlocks)
+        if (soldToBlocks.isNotEmpty()) db.soldToBlockDao().upsertAll(soldToBlocks)
+        if (purchasedFromBlocks.isNotEmpty()) db.purchasedFromBlockDao().upsertAll(purchasedFromBlocks)
+        if (identifications.isNotEmpty()) db.itemIdentificationDao().upsertAll(identifications)
+        if (customFields.isNotEmpty()) db.itemCustomFieldDao().upsertAll(customFields)
+        if (stockAdjustments.isNotEmpty()) db.stockAdjustmentDao().upsertAll(stockAdjustments)
+        if (locations.isNotEmpty()) db.locationDao().upsertAll(locations)
+        if (labels.isNotEmpty()) db.labelDao().upsertAll(labels)
+        if (itemLabels.isNotEmpty()) db.itemLabelDao().upsertAll(itemLabels)
+        if (attachments.isNotEmpty()) db.attachmentDao().upsertAll(attachments)
+    }
+
+    private suspend fun applyTombstones(
+        db: HhoDatabase,
+        tombstones: List<SyncTombstoneEntry>,
+    ) {
+        for (tombstone in tombstones) {
+            val id = tombstone.id ?: throw MalformedSyncPullResponseException("tombstone missing 'id'")
+            when (val entityType = tombstone.entityType) {
+                "item" -> db.itemDao().deleteById(id)
+                "warranty_block" -> db.warrantyBlockDao().deleteById(id)
+                "sold_to_block" -> db.soldToBlockDao().deleteById(id)
+                "purchased_from_block" -> db.purchasedFromBlockDao().deleteById(id)
+                "item_identification" -> db.itemIdentificationDao().deleteById(id)
+                "item_custom_field" -> db.itemCustomFieldDao().deleteById(id)
+                "stock_adjustment" -> db.stockAdjustmentDao().deleteById(id)
+                "location" -> db.locationDao().deleteById(id)
+                "label" -> db.labelDao().deleteById(id)
+                "item_label" -> db.itemLabelDao().deleteById(id)
+                "attachment" -> db.attachmentDao().deleteById(id)
+                else -> throw UnknownSyncEntityTypeException(entityType)
+            }
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncRunRecorder.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncRunRecorder.kt
new file mode 100644
index 0000000..558c2a7
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncRunRecorder.kt
@@ -0,0 +1,50 @@
+package dev.hho.android.data.sync
+
+import dev.hho.android.data.room.SyncRunStateDao
+import dev.hho.android.data.room.SyncRunStateEntity
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class SyncRunRecorder
+    internal constructor(
+        private val dao: SyncRunStateDao,
+        private val clock: () -> Long,
+    ) {
+        @Inject
+        constructor(dao: SyncRunStateDao) : this(dao, System::currentTimeMillis)
+
+        suspend fun reconcileOwed(): Boolean = dao.get()?.reconcilePending == true
+
+        suspend fun setReconcilePending(owed: Boolean) {
+            ensureRow()
+            dao.setReconcilePending(owed)
+        }
+
+        suspend fun recordPushReachedServer() {
+            ensureRow()
+            dao.setLastPushAt(clock())
+        }
+
+        suspend fun recordSuccess() {
+            ensureRow()
+            dao.setRunSucceeded(clock())
+        }
+
+        suspend fun recordFailure(
+            message: String?,
+            reconcileOwed: Boolean = false,
+        ) {
+            ensureRow()
+            dao.setRunFailed(clock(), message ?: "sync failed", reconcileOwed)
+        }
+
+        suspend fun conflictWatermark(): Long? = dao.get()?.conflictCursor?.toLongOrNull()
+
+        suspend fun advanceConflictWatermark(watermark: Long) {
+            ensureRow()
+            dao.setConflictCursor(watermark.toString())
+        }
+
+        private suspend fun ensureRow() = dao.insertIfAbsent(SyncRunStateEntity())
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncScheduler.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncScheduler.kt
new file mode 100644
index 0000000..60b08df
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncScheduler.kt
@@ -0,0 +1,73 @@
+package dev.hho.android.data.sync
+
+import android.content.Context
+import androidx.work.BackoffPolicy
+import androidx.work.Constraints
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequest
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.PeriodicWorkRequest
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkManager
+import androidx.work.WorkRequest
+import dagger.hilt.android.qualifiers.ApplicationContext
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class SyncScheduler
+    @Inject
+    constructor(
+        @ApplicationContext private val context: Context,
+    ) {
+        private val workManager: WorkManager
+            get() = WorkManager.getInstance(context)
+
+        fun schedulePeriodic() {
+            workManager.enqueueUniquePeriodicWork(
+                PERIODIC_WORK_NAME,
+                ExistingPeriodicWorkPolicy.KEEP,
+                buildPeriodicRequest(),
+            )
+        }
+
+        fun syncNow() {
+            workManager.enqueueUniqueWork(
+                ON_DEMAND_WORK_NAME,
+                ExistingWorkPolicy.KEEP,
+                buildOnDemandRequest(),
+            )
+        }
+
+        companion object {
+            const val PERIODIC_WORK_NAME = "dev.hho.android.sync.periodic"
+            const val ON_DEMAND_WORK_NAME = "dev.hho.android.sync.now"
+
+            internal fun buildPeriodicRequest(): PeriodicWorkRequest =
+                PeriodicWorkRequestBuilder<SyncWorker>(
+                    PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS,
+                    TimeUnit.MILLISECONDS,
+                )
+                    .setConstraints(
+                        Constraints.Builder()
+                            .setRequiredNetworkType(NetworkType.CONNECTED)
+                            .setRequiresBatteryNotLow(true)
+                            .build(),
+                    )
+                    .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, WorkRequest.MIN_BACKOFF_MILLIS, TimeUnit.MILLISECONDS)
+                    .build()
+
+            internal fun buildOnDemandRequest(): OneTimeWorkRequest =
+                OneTimeWorkRequestBuilder<SyncWorker>()
+                    .setConstraints(
+                        Constraints.Builder()
+                            .setRequiredNetworkType(NetworkType.CONNECTED)
+                            .build(),
+                    )
+                    .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, WorkRequest.MIN_BACKOFF_MILLIS, TimeUnit.MILLISECONDS)
+                    .build()
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncStatusRepository.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncStatusRepository.kt
new file mode 100644
index 0000000..17d6f0f
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncStatusRepository.kt
@@ -0,0 +1,63 @@
+package dev.hho.android.data.sync
+
+import dev.hho.android.data.room.OutboxDao
+import dev.hho.android.data.room.OutboxState
+import dev.hho.android.data.room.SyncRunStateDao
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import javax.inject.Inject
+import javax.inject.Singleton
+
+interface PhotoQueueStatus {
+    fun observePendingCount(): Flow<Int>
+
+    fun observeFailedCount(): Flow<Int>
+}
+
+data class SyncStatus(
+    val pendingCount: Int = 0,
+    val failedCount: Int = 0,
+    val failedOutboxCount: Int = 0,
+    val failedPhotoCount: Int = 0,
+    val photoQueueDepth: Int = 0,
+    val lastSyncedAt: Long? = null,
+    val lastPushAt: Long? = null,
+    val lastError: String? = null,
+) {
+    val hasProblem: Boolean get() = failedCount > 0 || lastError != null
+}
+
+@Singleton
+class SyncStatusRepository
+    @Inject
+    constructor(
+        private val outbox: OutboxDao,
+        private val photos: PhotoQueueStatus,
+        private val runState: SyncRunStateDao,
+    ) {
+        fun observe(): Flow<SyncStatus> =
+            combine(
+                outbox.observeCount(LIVE),
+                outbox.observeCount(FAILED),
+                photos.observePendingCount(),
+                photos.observeFailedCount(),
+                runState.observe(),
+            ) { pending, failedOutbox, photoDepth, failedPhotos, run ->
+                SyncStatus(
+                    pendingCount = pending,
+                    failedCount = failedOutbox + failedPhotos,
+                    failedOutboxCount = failedOutbox,
+                    failedPhotoCount = failedPhotos,
+                    photoQueueDepth = photoDepth,
+                    lastSyncedAt = run?.takeIf { it.lastError == null }?.lastRunAt,
+                    lastPushAt = run?.lastPushAt,
+                    lastError = run?.lastError,
+                )
+            }.distinctUntilChanged()
+
+        private companion object {
+            val LIVE = listOf(OutboxState.PENDING, OutboxState.IN_FLIGHT, OutboxState.HELD)
+            val FAILED = listOf(OutboxState.FAILED)
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncWorker.kt b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncWorker.kt
new file mode 100644
index 0000000..3626f03
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/data/sync/SyncWorker.kt
@@ -0,0 +1,47 @@
+package dev.hho.android.data.sync
+
+import android.content.Context
+import androidx.hilt.work.HiltWorker
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import dev.hho.android.data.auth.DeviceIdProvider
+import dev.hho.android.domain.AuthRepository
+import dev.hho.android.domain.AuthState
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.flow.first
+
+@HiltWorker
+class SyncWorker
+    @AssistedInject
+    constructor(
+        @Assisted context: Context,
+        @Assisted params: WorkerParameters,
+        private val syncEngine: SyncEngine,
+        private val deviceIdProvider: DeviceIdProvider,
+        private val authRepository: AuthRepository,
+        private val recorder: SyncRunRecorder,
+    ) : CoroutineWorker(context, params) {
+
+        override suspend fun doWork(): Result {
+            if (authRepository.authState.first() != AuthState.LoggedIn) {
+                return Result.success()
+            }
+
+            val deviceId = deviceIdProvider.deviceId()
+            val result =
+                try {
+                    syncEngine.sync(deviceId)
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (e: Throwable) {
+                    recorder.recordFailure(e.javaClass.simpleName)
+                    return Result.retry()
+                }
+            return result.fold(
+                onSuccess = { Result.success() },
+                onFailure = { Result.retry() },
+            )
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/di/AppModule.kt b/android-app/app/src/main/kotlin/dev/hho/android/di/AppModule.kt
new file mode 100644
index 0000000..c2c4c98
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/di/AppModule.kt
@@ -0,0 +1,22 @@
+package dev.hho.android.di
+
+import android.os.Build
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import dev.hho.android.BuildConfig
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+object AppModule {
+
+    @Provides
+    @Singleton
+    fun provideBuildInfo(): BuildInfo = object : BuildInfo {
+        override val applicationId: String = BuildConfig.APPLICATION_ID
+        override val versionName: String = BuildConfig.VERSION_NAME
+        override val minSdk: Int = Build.VERSION_CODES.O
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/di/AuthModule.kt b/android-app/app/src/main/kotlin/dev/hho/android/di/AuthModule.kt
new file mode 100644
index 0000000..20fbe53
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/di/AuthModule.kt
@@ -0,0 +1,48 @@
+package dev.hho.android.di
+
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import dev.hho.android.data.auth.AndroidKeystoreDeviceTokenCipher
+import dev.hho.android.data.auth.AuthRepositoryImpl
+import dev.hho.android.data.auth.DataStoreDeviceIdProvider
+import dev.hho.android.data.auth.DefaultDeviceLabelProvider
+import dev.hho.android.data.auth.DeviceIdProvider
+import dev.hho.android.data.auth.DeviceLabelProvider
+import dev.hho.android.data.auth.DeviceTokenCipher
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.auth.DeviceTokenStore
+import dev.hho.android.data.auth.InstanceScopedDeviceTokenProvider
+import dev.hho.android.data.auth.KeystoreDeviceTokenStore
+import dev.hho.android.domain.AuthRepository
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+abstract class AuthModule {
+
+    @Binds
+    @Singleton
+    abstract fun bindAuthRepository(impl: AuthRepositoryImpl): AuthRepository
+
+    @Binds
+    @Singleton
+    abstract fun bindDeviceTokenProvider(impl: InstanceScopedDeviceTokenProvider): DeviceTokenProvider
+
+    @Binds
+    @Singleton
+    abstract fun bindDeviceTokenStore(impl: KeystoreDeviceTokenStore): DeviceTokenStore
+
+    @Binds
+    @Singleton
+    abstract fun bindDeviceTokenCipher(impl: AndroidKeystoreDeviceTokenCipher): DeviceTokenCipher
+
+    @Binds
+    @Singleton
+    abstract fun bindDeviceLabelProvider(impl: DefaultDeviceLabelProvider): DeviceLabelProvider
+
+    @Binds
+    @Singleton
+    abstract fun bindDeviceIdProvider(impl: DataStoreDeviceIdProvider): DeviceIdProvider
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/di/BuildInfo.kt b/android-app/app/src/main/kotlin/dev/hho/android/di/BuildInfo.kt
new file mode 100644
index 0000000..810f742
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/di/BuildInfo.kt
@@ -0,0 +1,7 @@
+package dev.hho.android.di
+
+interface BuildInfo {
+    val applicationId: String
+    val versionName: String
+    val minSdk: Int
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/di/DataStoreModule.kt b/android-app/app/src/main/kotlin/dev/hho/android/di/DataStoreModule.kt
new file mode 100644
index 0000000..a361ef0
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/di/DataStoreModule.kt
@@ -0,0 +1,40 @@
+package dev.hho.android.di
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.preferencesDataStoreFile
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+private const val SETTINGS_DATASTORE_FILE_NAME = "hho_settings.preferences_pb"
+private const val DEVICE_TOKEN_DATASTORE_FILE_NAME = "hho_device_token.preferences_pb"
+
+@Module
+@InstallIn(SingletonComponent::class)
+object DataStoreModule {
+
+    @Provides
+    @Singleton
+    fun provideSettingsDataStore(
+        @ApplicationContext context: Context,
+    ): DataStore<Preferences> =
+        PreferenceDataStoreFactory.create(
+            produceFile = { context.preferencesDataStoreFile(SETTINGS_DATASTORE_FILE_NAME) },
+        )
+
+    @Provides
+    @Singleton
+    @DeviceTokenDataStore
+    fun provideDeviceTokenDataStore(
+        @ApplicationContext context: Context,
+    ): DataStore<Preferences> =
+        PreferenceDataStoreFactory.create(
+            produceFile = { context.preferencesDataStoreFile(DEVICE_TOKEN_DATASTORE_FILE_NAME) },
+        )
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/di/DeviceTokenDataStore.kt b/android-app/app/src/main/kotlin/dev/hho/android/di/DeviceTokenDataStore.kt
new file mode 100644
index 0000000..685eb40
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/di/DeviceTokenDataStore.kt
@@ -0,0 +1,7 @@
+package dev.hho.android.di
+
+import javax.inject.Qualifier
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class DeviceTokenDataStore
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/di/NetworkModule.kt b/android-app/app/src/main/kotlin/dev/hho/android/di/NetworkModule.kt
new file mode 100644
index 0000000..c3caca8
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/di/NetworkModule.kt
@@ -0,0 +1,42 @@
+package dev.hho.android.di
+
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import okhttp3.OkHttpClient
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+object NetworkModule {
+
+    @Provides
+    @Singleton
+    fun provideOkHttpClient(
+        baseUrlInterceptor: BaseUrlInterceptor,
+        authHeaderInterceptor: AuthHeaderInterceptor,
+        clientVersionInterceptor: ClientVersionInterceptor,
+    ): OkHttpClient =
+        OkHttpClient.Builder()
+            .addInterceptor(baseUrlInterceptor)
+            .addInterceptor(authHeaderInterceptor)
+            .addInterceptor(clientVersionInterceptor)
+            .build()
+
+    @Provides
+    @Singleton
+    @ProbeHttpClient
+    fun provideProbeOkHttpClient(
+        sharedOkHttpClient: OkHttpClient,
+        clientVersionInterceptor: ClientVersionInterceptor,
+    ): OkHttpClient {
+        val builder = sharedOkHttpClient.newBuilder()
+        builder.interceptors().clear()
+        builder.interceptors().add(clientVersionInterceptor)
+        return builder.build()
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/di/OutboxModule.kt b/android-app/app/src/main/kotlin/dev/hho/android/di/OutboxModule.kt
new file mode 100644
index 0000000..8c9116c
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/di/OutboxModule.kt
@@ -0,0 +1,24 @@
+package dev.hho.android.di
+
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.HhoDatabase
+import javax.inject.Singleton
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal object OutboxModule {
+
+    @Provides
+    @Singleton
+    fun provideUuidV7Generator(): UuidV7Generator = UuidV7Generator()
+
+    @Provides
+    @Singleton
+    fun provideOutboxRepository(db: HhoDatabase, ids: UuidV7Generator): OutboxRepository =
+        OutboxRepository(db, ids)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/di/PhotoCaptureModule.kt b/android-app/app/src/main/kotlin/dev/hho/android/di/PhotoCaptureModule.kt
new file mode 100644
index 0000000..4345cb3
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/di/PhotoCaptureModule.kt
@@ -0,0 +1,17 @@
+package dev.hho.android.di
+
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.android.components.ViewModelComponent
+import dagger.hilt.android.scopes.ViewModelScoped
+import dev.hho.android.data.photoqueue.CameraXPhotoCapture
+import dev.hho.android.data.photoqueue.PhotoCapture
+
+@Module
+@InstallIn(ViewModelComponent::class)
+internal abstract class PhotoCaptureModule {
+    @Binds
+    @ViewModelScoped
+    abstract fun bindPhotoCapture(impl: CameraXPhotoCapture): PhotoCapture
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/di/PhotoSyncHookModule.kt b/android-app/app/src/main/kotlin/dev/hho/android/di/PhotoSyncHookModule.kt
new file mode 100644
index 0000000..7179f4d
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/di/PhotoSyncHookModule.kt
@@ -0,0 +1,25 @@
+package dev.hho.android.di
+
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import dagger.multibindings.Multibinds
+import dev.hho.android.data.photoqueue.PhotoPostSyncHook
+import dev.hho.android.data.photoqueue.PhotoQueueStatusSource
+import dev.hho.android.data.sync.PhotoQueueStatus
+import dev.hho.android.data.sync.PostSyncHook
+
+@Module
+@InstallIn(SingletonComponent::class)
+internal abstract class PhotoSyncHookModule {
+    @Binds
+    @dagger.multibindings.IntoSet
+    abstract fun bindPhotoHook(hook: PhotoPostSyncHook): PostSyncHook
+
+    @Binds
+    abstract fun bindPhotoStatus(source: PhotoQueueStatusSource): PhotoQueueStatus
+
+    @Multibinds
+    abstract fun postSyncHooks(): Set<@JvmSuppressWildcards PostSyncHook>
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/di/ProbeHttpClient.kt b/android-app/app/src/main/kotlin/dev/hho/android/di/ProbeHttpClient.kt
new file mode 100644
index 0000000..c6e9cd1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/di/ProbeHttpClient.kt
@@ -0,0 +1,7 @@
+package dev.hho.android.di
+
+import javax.inject.Qualifier
+
+@Qualifier
+@Retention(AnnotationRetention.BINARY)
+annotation class ProbeHttpClient
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/di/RoomModule.kt b/android-app/app/src/main/kotlin/dev/hho/android/di/RoomModule.kt
new file mode 100644
index 0000000..46a8571
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/di/RoomModule.kt
@@ -0,0 +1,97 @@
+package dev.hho.android.di
+
+import android.content.Context
+import androidx.room.Room
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import dev.hho.android.data.room.AttachmentDao
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemCustomFieldDao
+import dev.hho.android.data.room.ItemDao
+import dev.hho.android.data.room.ItemIdentificationDao
+import dev.hho.android.data.room.ItemLabelDao
+import dev.hho.android.data.room.LabelDao
+import dev.hho.android.data.room.LocationDao
+import dev.hho.android.data.room.MIGRATION_1_2
+import dev.hho.android.data.room.ConflictRecordDao
+import dev.hho.android.data.room.OutboxDao
+import dev.hho.android.data.room.PhotoQueueDao
+import dev.hho.android.data.room.ReceivingDao
+import dev.hho.android.data.room.SyncRunStateDao
+import dev.hho.android.data.room.PurchasedFromBlockDao
+import dev.hho.android.data.room.SoldToBlockDao
+import dev.hho.android.data.room.StockAdjustmentDao
+import dev.hho.android.data.room.SyncStateDao
+import dev.hho.android.data.room.WarrantyBlockDao
+import javax.inject.Singleton
+
+private const val DATABASE_NAME = "hho.db"
+
+@Module
+@InstallIn(SingletonComponent::class)
+object RoomModule {
+
+    @Provides
+    @Singleton
+    fun provideHhoDatabase(
+        @ApplicationContext context: Context,
+    ): HhoDatabase = Room.databaseBuilder(context, HhoDatabase::class.java, DATABASE_NAME)
+            .addMigrations(MIGRATION_1_2)
+            .build()
+
+    @Provides
+    fun provideItemDao(database: HhoDatabase): ItemDao = database.itemDao()
+
+    @Provides
+    fun provideWarrantyBlockDao(database: HhoDatabase): WarrantyBlockDao = database.warrantyBlockDao()
+
+    @Provides
+    fun provideSoldToBlockDao(database: HhoDatabase): SoldToBlockDao = database.soldToBlockDao()
+
+    @Provides
+    fun providePurchasedFromBlockDao(database: HhoDatabase): PurchasedFromBlockDao =
+        database.purchasedFromBlockDao()
+
+    @Provides
+    fun provideItemIdentificationDao(database: HhoDatabase): ItemIdentificationDao =
+        database.itemIdentificationDao()
+
+    @Provides
+    fun provideItemCustomFieldDao(database: HhoDatabase): ItemCustomFieldDao = database.itemCustomFieldDao()
+
+    @Provides
+    fun provideStockAdjustmentDao(database: HhoDatabase): StockAdjustmentDao = database.stockAdjustmentDao()
+
+    @Provides
+    fun provideLocationDao(database: HhoDatabase): LocationDao = database.locationDao()
+
+    @Provides
+    fun provideLabelDao(database: HhoDatabase): LabelDao = database.labelDao()
+
+    @Provides
+    fun provideItemLabelDao(database: HhoDatabase): ItemLabelDao = database.itemLabelDao()
+
+    @Provides
+    fun provideAttachmentDao(database: HhoDatabase): AttachmentDao = database.attachmentDao()
+
+    @Provides
+    fun provideSyncStateDao(database: HhoDatabase): SyncStateDao = database.syncStateDao()
+
+    @Provides
+    fun provideOutboxDao(database: HhoDatabase): OutboxDao = database.outboxDao()
+
+    @Provides
+    fun provideReceivingDao(database: HhoDatabase): ReceivingDao = database.receivingDao()
+
+    @Provides
+    fun providePhotoQueueDao(database: HhoDatabase): PhotoQueueDao = database.photoQueueDao()
+
+    @Provides
+    fun provideConflictRecordDao(database: HhoDatabase): ConflictRecordDao = database.conflictRecordDao()
+
+    @Provides
+    fun provideSyncRunStateDao(database: HhoDatabase): SyncRunStateDao = database.syncRunStateDao()
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/domain/AuthRepository.kt b/android-app/app/src/main/kotlin/dev/hho/android/domain/AuthRepository.kt
new file mode 100644
index 0000000..270a68b
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/domain/AuthRepository.kt
@@ -0,0 +1,17 @@
+package dev.hho.android.domain
+
+import kotlinx.coroutines.flow.Flow
+
+interface AuthRepository {
+    val authState: Flow<AuthState>
+
+    suspend fun login(username: String, password: String): Result<Unit>
+
+    suspend fun logout()
+}
+
+sealed interface AuthState {
+    data object LoggedOut : AuthState
+
+    data object LoggedIn : AuthState
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/domain/EditRepository.kt b/android-app/app/src/main/kotlin/dev/hho/android/domain/EditRepository.kt
new file mode 100644
index 0000000..eca563d
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/domain/EditRepository.kt
@@ -0,0 +1,243 @@
+package dev.hho.android.domain
+
+import androidx.room.withTransaction
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.outbox.LocalMutation
+import dev.hho.android.data.outbox.OptimisticApplier
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.sync.SyncScheduler
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.flow.first
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import java.time.LocalDate
+import javax.inject.Inject
+
+internal sealed interface EditError {
+    data class Invalid(val field: String, val message: String) : EditError
+
+    data class NotFound(val kind: String, val id: String) : EditError
+
+    data class StorageFailed(val cause: Throwable) : EditError
+}
+
+internal sealed interface EditResult<out T> {
+    data class Success<T>(val value: T) : EditResult<T>
+
+    data class Failure(val error: EditError) : EditResult<Nothing>
+}
+
+internal class EditRepository(
+    private val db: HhoDatabase,
+    private val outbox: OutboxRepository,
+    private val ids: UuidV7Generator,
+    private val syncNow: () -> Unit,
+) {
+    @Inject
+    constructor(
+        db: HhoDatabase,
+        outbox: OutboxRepository,
+        ids: UuidV7Generator,
+        scheduler: SyncScheduler,
+    ) : this(db, outbox, ids, scheduler::syncNow)
+
+    suspend fun createItem(name: String, description: String? = null, locationId: String? = null): EditResult<String> =
+        write { createItem(name, description, locationId) }
+
+    suspend fun editItem(itemId: String, name: String? = null, description: String? = null): EditResult<Unit> =
+        write { updateItem(itemId, name, description) }
+
+    suspend fun moveItem(itemId: String, locationId: String?): EditResult<Unit> =
+        write { updateItem(itemId, setLocation = true, locationId = locationId) }
+
+    suspend fun adjustStock(itemId: String, delta: Long, reason: String? = null, note: String? = null): EditResult<String> =
+        write { adjustStock(itemId, delta, reason, note) }
+
+    suspend fun attachLabel(itemId: String, labelId: String): EditResult<String> =
+        write {
+            db.itemDao().getById(itemId) ?: return@write notFound("item", itemId)
+            db.labelDao().getById(labelId) ?: return@write notFound("label", labelId)
+            db.itemLabelDao().observeByItemId(itemId).first().firstOrNull { it.labelId == labelId }
+                ?.let { return@write EditResult.Success(it.id) }
+            val edgeId = ids.generate()
+            val fields = JsonObject(mapOf("item_id" to JsonPrimitive(itemId), "label_id" to JsonPrimitive(labelId)))
+            commit(LocalMutation("item_label", edgeId, UPSERT, 0, fields))
+            EditResult.Success(edgeId)
+        }
+
+    suspend fun detachLabel(itemId: String, labelId: String): EditResult<Unit> =
+        write {
+            val edge = db.itemLabelDao().observeByItemId(itemId).first().firstOrNull { it.labelId == labelId }
+                ?: return@write notFound("item_label", "$itemId/$labelId")
+            val fields = JsonObject(mapOf("item_id" to JsonPrimitive(itemId), "label_id" to JsonPrimitive(labelId)))
+            commit(LocalMutation("item_label", edge.id, "delete", 0, fields))
+            EditResult.Success(Unit)
+        }
+
+    suspend fun addIdentification(itemId: String, kind: String, value: String): EditResult<String> =
+        write { addIdentification(itemId, kind, value) }
+
+    suspend fun stampPurchase(
+        itemId: String,
+        vendor: String? = null,
+        purchasedOn: LocalDate? = null,
+        purchasePriceMinor: Long? = null,
+        orderReference: String? = null,
+        notes: String? = null,
+    ): EditResult<String> =
+        write { stampPurchase(itemId, vendor, purchasedOn, purchasePriceMinor, orderReference, notes) }
+
+    internal suspend fun <T> batch(body: suspend EditTx.() -> EditResult<T>): EditResult<T> {
+        val tx = EditTx()
+        val result = try {
+            db.withTransaction {
+                val r = tx.body()
+                if (r is EditResult.Failure) throw BatchAborted(r)
+                r
+            }
+        } catch (e: BatchAborted) {
+            return e.failure
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            return EditResult.Failure(EditError.StorageFailed(e))
+        }
+        if (tx.wrote) triggerSync()
+        return result
+    }
+
+    private class BatchAborted(val failure: EditResult.Failure) : RuntimeException(null, null, false, false)
+
+    internal inner class EditTx {
+        var wrote = false
+            private set
+
+        suspend fun createItem(name: String, description: String? = null, locationId: String? = null): EditResult<String> {
+            if (name.isBlank()) return invalid("name", "name must not be blank")
+            if (locationId != null && db.locationDao().getById(locationId) == null) return notFound("location", locationId)
+            val id = ids.generate()
+            val fields = buildMap<String, JsonElement> {
+                put("name", JsonPrimitive(name.trim()))
+                description?.let { put("description", JsonPrimitive(it)) }
+                locationId?.let { put("location_id", JsonPrimitive(it)) }
+            }
+            commit(LocalMutation("item", id, UPSERT, 0, JsonObject(fields)))
+            return EditResult.Success(id)
+        }
+
+        suspend fun updateItem(
+            itemId: String,
+            name: String? = null,
+            description: String? = null,
+            setLocation: Boolean = false,
+            locationId: String? = null,
+        ): EditResult<Unit> {
+            if (name == null && description == null && !setLocation) return invalid("name", "nothing to change")
+            if (name != null && name.isBlank()) return invalid("name", "name must not be blank")
+            val item = db.itemDao().getById(itemId) ?: return notFound("item", itemId)
+            if (setLocation && locationId != null && db.locationDao().getById(locationId) == null) {
+                return notFound("location", locationId)
+            }
+            val fields = buildMap<String, JsonElement> {
+                name?.let { put("name", JsonPrimitive(it.trim())) }
+                description?.let { put("description", JsonPrimitive(it)) }
+                if (setLocation) put("location_id", locationId?.let(::JsonPrimitive) ?: JsonNull)
+            }
+            commit(LocalMutation("item", itemId, UPSERT, item.version ?: 0, JsonObject(fields)))
+            return EditResult.Success(Unit)
+        }
+
+        suspend fun addIdentification(itemId: String, kind: String, value: String): EditResult<String> {
+            if (kind !in IDENTIFICATION_KINDS) return invalid("kind", "kind must be one of $IDENTIFICATION_KINDS")
+            if (value.isBlank()) return invalid("value", "value must not be blank")
+            db.itemDao().getById(itemId) ?: return notFound("item", itemId)
+            val id = ids.generate()
+            val fields = JsonObject(
+                mapOf("item_id" to JsonPrimitive(itemId), "kind" to JsonPrimitive(kind), "value" to JsonPrimitive(value.trim())),
+            )
+            commit(LocalMutation("item_identification", id, UPSERT, 0, fields))
+            return EditResult.Success(id)
+        }
+
+        suspend fun adjustStock(itemId: String, delta: Long, reason: String? = null, note: String? = null): EditResult<String> {
+            if (delta == 0L) return invalid("delta", "delta must not be zero")
+            db.itemDao().getById(itemId) ?: return notFound("item", itemId)
+            val id = ids.generate()
+            val fields = buildMap<String, JsonElement> {
+                put("item_id", JsonPrimitive(itemId))
+                put("delta", JsonPrimitive(delta))
+                reason?.let { put("reason", JsonPrimitive(it)) }
+                note?.let { put("note", JsonPrimitive(it)) }
+            }
+            commit(LocalMutation("stock_adjustment", id, UPSERT, 0, JsonObject(fields)))
+            return EditResult.Success(id)
+        }
+
+        suspend fun stampPurchase(
+            itemId: String,
+            vendor: String? = null,
+            purchasedOn: LocalDate? = null,
+            purchasePriceMinor: Long? = null,
+            orderReference: String? = null,
+            notes: String? = null,
+        ): EditResult<String> {
+            if (vendor == null && purchasedOn == null && purchasePriceMinor == null && orderReference == null && notes == null) {
+                return invalid("purchase", "nothing to record")
+            }
+            if (purchasePriceMinor != null && purchasePriceMinor < 0) return invalid("purchase_price_minor", "must not be negative")
+            db.itemDao().getById(itemId) ?: return notFound("item", itemId)
+            val existing = db.purchasedFromBlockDao().getByItemId(itemId)
+            val fields = buildMap<String, JsonElement> {
+                put("item_id", JsonPrimitive(itemId))
+                vendor?.let { put("vendor", JsonPrimitive(it)) }
+                purchasedOn?.let { put("purchased_on", JsonPrimitive(it.toString())) }
+                purchasePriceMinor?.let { put("purchase_price_minor", JsonPrimitive(it)) }
+                orderReference?.let { put("order_reference", JsonPrimitive(it)) }
+                notes?.let { put("notes", JsonPrimitive(it)) }
+            }
+            val id = existing?.id ?: ids.generate()
+            commit(LocalMutation("purchased_from_block", id, UPSERT, existing?.version ?: 0, JsonObject(fields)))
+            return EditResult.Success(id)
+        }
+
+        suspend fun commit(m: LocalMutation) {
+            OptimisticApplier.apply(db, m)
+            outbox.enqueue(m)
+            wrote = true
+        }
+    }
+
+    private fun <T> invalid(field: String, message: String): EditResult<T> =
+        EditResult.Failure(EditError.Invalid(field, message))
+
+    private fun <T> notFound(kind: String, id: String): EditResult<T> =
+        EditResult.Failure(EditError.NotFound(kind, id))
+
+    private suspend fun <T> write(body: suspend EditTx.() -> EditResult<T>): EditResult<T> {
+        val tx = EditTx()
+        val result = try {
+            db.withTransaction { tx.body() }
+        } catch (e: CancellationException) {
+            throw e
+        } catch (e: Exception) {
+            return EditResult.Failure(EditError.StorageFailed(e))
+        }
+        if (tx.wrote && result is EditResult.Success) triggerSync()
+        return result
+    }
+
+    private fun triggerSync() {
+        try {
+            syncNow()
+        } catch (_: Exception) {
+        }
+    }
+
+    private companion object {
+        const val UPSERT = "upsert"
+        val IDENTIFICATION_KINDS = setOf("serial", "model", "asset_tag", "barcode", "other")
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/domain/ReceivingCheckIn.kt b/android-app/app/src/main/kotlin/dev/hho/android/domain/ReceivingCheckIn.kt
new file mode 100644
index 0000000..d5a56ef
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/domain/ReceivingCheckIn.kt
@@ -0,0 +1,64 @@
+package dev.hho.android.domain
+
+import dev.hho.android.data.receiving.ReceivingException
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ReceivingStatus
+import javax.inject.Inject
+
+internal sealed interface CheckInResult {
+    data class Completed(val lines: Int) : CheckInResult
+
+    data object AlreadyCompleted : CheckInResult
+
+    data class Failed(val error: EditError) : CheckInResult
+}
+
+internal class ReceivingCheckIn(
+    private val db: HhoDatabase,
+    private val edits: EditRepository,
+    private val clock: () -> Long,
+) {
+    @Inject
+    constructor(db: HhoDatabase, edits: EditRepository) : this(db, edits, System::currentTimeMillis)
+
+    suspend fun checkIn(sessionId: String): CheckInResult {
+        val result = edits.batch { checkInLines(sessionId) }
+        return when (result) {
+            is EditResult.Success -> result.value
+            is EditResult.Failure -> {
+                val cause = (result.error as? EditError.StorageFailed)?.cause
+                if (cause is ReceivingException) throw cause
+                CheckInResult.Failed(result.error)
+            }
+        }
+    }
+
+    private suspend fun EditRepository.EditTx.checkInLines(sessionId: String): EditResult<CheckInResult> {
+        val dao = db.receivingDao()
+        val session = dao.getSession(sessionId) ?: throw ReceivingException.SessionNotFound(sessionId)
+        when (session.status) {
+            ReceivingStatus.COMPLETED -> return EditResult.Success(CheckInResult.AlreadyCompleted)
+            ReceivingStatus.OPEN -> Unit
+            else -> throw ReceivingException.SessionNotOpen(sessionId, session.status)
+        }
+        var adjustments = 0
+        for (line in dao.getLines(sessionId).filter { it.receivedQty > 0 }) {
+            val adj = adjustStock(line.itemId, line.receivedQty.toLong(), RECEIVING_REASON, session.orderReference)
+            if (adj is EditResult.Failure) return adj
+            val stamp = stampPurchase(
+                line.itemId,
+                vendor = session.vendor,
+                purchasedOn = session.purchasedOn,
+                orderReference = session.orderReference,
+            )
+            if (stamp is EditResult.Failure) return stamp
+            adjustments++
+        }
+        dao.updateSession(session.copy(status = ReceivingStatus.COMPLETED, completedAt = clock()))
+        return EditResult.Success(CheckInResult.Completed(adjustments))
+    }
+
+    private companion object {
+        const val RECEIVING_REASON = "receiving"
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/HhoApp.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/HhoApp.kt
new file mode 100644
index 0000000..374be18
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/HhoApp.kt
@@ -0,0 +1,163 @@
+package dev.hho.android.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import dev.hho.android.ui.connect.ConnectScreen
+import dev.hho.android.ui.deeplink.DeepLinkNotFoundScreen
+import dev.hho.android.ui.deeplink.DeepLinkResolution
+import dev.hho.android.ui.deeplink.DeepLinkViewModel
+import dev.hho.android.ui.deeplink.ItemDeepLink
+import dev.hho.android.ui.home.HomeScreen
+import dev.hho.android.ui.items.ItemDetailScreen
+import dev.hho.android.ui.items.ItemFormScreen
+import dev.hho.android.ui.items.ItemListScreen
+import dev.hho.android.ui.login.LoginScreen
+import dev.hho.android.ui.photos.PhotoCaptureScreen
+import dev.hho.android.ui.receiving.ReceivingScreen
+import dev.hho.android.ui.scan.ScanScreen
+import dev.hho.android.ui.syncstatus.ConflictLogScreen
+import dev.hho.android.ui.syncstatus.SyncProblemViewModel
+import dev.hho.android.ui.syncstatus.SyncStatusScreen
+
+@Composable
+fun HhoApp(
+    pendingDeepLink: ItemDeepLink? = null,
+    onDeepLinkHandled: () -> Unit = {},
+    deepLinkViewModel: DeepLinkViewModel = hiltViewModel(),
+) {
+    var destination by rememberSaveable { mutableStateOf(AppDestination.Connect) }
+    var selectedItemId by rememberSaveable { mutableStateOf<String?>(null) }
+    var formItemId by rememberSaveable { mutableStateOf<String?>(null) }
+    var formPrefillKind by rememberSaveable { mutableStateOf<String?>(null) }
+    var formPrefillValue by rememberSaveable { mutableStateOf<String?>(null) }
+    LaunchedEffect(pendingDeepLink, destination) {
+        val link = pendingDeepLink ?: return@LaunchedEffect
+        if (destination == AppDestination.Connect || destination == AppDestination.Login) {
+            return@LaunchedEffect
+        }
+        when (val resolution = deepLinkViewModel.resolve(link)) {
+            is DeepLinkResolution.Found -> {
+                selectedItemId = resolution.itemId
+                destination = AppDestination.ItemDetail
+            }
+            is DeepLinkResolution.NotFound -> destination = AppDestination.DeepLinkNotFound
+        }
+        onDeepLinkHandled()
+    }
+    when (destination) {
+        AppDestination.Connect ->
+            ConnectScreen(onConnected = { destination = AppDestination.Login })
+        AppDestination.Login ->
+            LoginScreen(onLoggedIn = { destination = AppDestination.Home })
+        AppDestination.Home -> {
+            val syncProblem by hiltViewModel<SyncProblemViewModel>().hasProblem.collectAsState()
+            HomeScreen(
+                onViewItems = { destination = AppDestination.ItemList },
+                onReceiveDelivery = { destination = AppDestination.Receiving },
+                onSyncStatus = { destination = AppDestination.SyncStatus },
+                syncProblem = syncProblem,
+            )
+        }
+        AppDestination.SyncStatus ->
+            SyncStatusScreen(
+                onBack = { destination = AppDestination.Home },
+                onConflictLog = { destination = AppDestination.ConflictLog },
+            )
+        AppDestination.ConflictLog ->
+            ConflictLogScreen(onBack = { destination = AppDestination.SyncStatus })
+        AppDestination.Receiving ->
+            ReceivingScreen(
+                onBack = { destination = AppDestination.Home },
+                onCheckedIn = { destination = AppDestination.Home },
+            )
+        AppDestination.ItemList ->
+            ItemListScreen(
+                onScan = { destination = AppDestination.Scan },
+                onNewItem = {
+                    formItemId = null
+                    formPrefillKind = null
+                    formPrefillValue = null
+                    destination = AppDestination.ItemForm
+                },
+                onItemClick = { id ->
+                    selectedItemId = id
+                    destination = AppDestination.ItemDetail
+                },
+            )
+        AppDestination.ItemDetail ->
+            ItemDetailScreen(
+                itemId = requireNotNull(selectedItemId) {
+                    "AppDestination.ItemDetail reached with no selectedItemId set"
+                },
+                onBack = {
+                    selectedItemId = null
+                    destination = AppDestination.ItemList
+                },
+                onAddPhoto = { destination = AppDestination.PhotoCapture },
+                onEdit = {
+                    formItemId = selectedItemId
+                    formPrefillKind = null
+                    formPrefillValue = null
+                    destination = AppDestination.ItemForm
+                },
+            )
+        AppDestination.PhotoCapture ->
+            PhotoCaptureScreen(
+                itemId = requireNotNull(selectedItemId) {
+                    "AppDestination.PhotoCapture reached with no selectedItemId set"
+                },
+                onDone = { destination = AppDestination.ItemDetail },
+                onCancel = { destination = AppDestination.ItemDetail },
+            )
+        AppDestination.ItemForm ->
+            ItemFormScreen(
+                itemId = formItemId,
+                prefillIdentifierKind = formPrefillKind,
+                prefillIdentifierValue = formPrefillValue,
+                onSaved = { id ->
+                    selectedItemId = id
+                    destination = AppDestination.ItemDetail
+                },
+                onCancel = {
+                    destination = if (formItemId != null) AppDestination.ItemDetail else AppDestination.ItemList
+                },
+            )
+        AppDestination.Scan ->
+            ScanScreen(
+                onViewItem = { id ->
+                    selectedItemId = id
+                    destination = AppDestination.ItemDetail
+                },
+                onCreateItem = { kind, value ->
+                    formItemId = null
+                    formPrefillKind = kind
+                    formPrefillValue = value
+                    destination = AppDestination.ItemForm
+                },
+                onBack = { destination = AppDestination.ItemList },
+            )
+        AppDestination.DeepLinkNotFound ->
+            DeepLinkNotFoundScreen(onBack = { destination = AppDestination.ItemList })
+    }
+}
+
+private enum class AppDestination {
+    Connect,
+    Login,
+    Home,
+    ItemList,
+    ItemDetail,
+    ItemForm,
+    PhotoCapture,
+    Scan,
+    Receiving,
+    SyncStatus,
+    ConflictLog,
+    DeepLinkNotFound,
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/ScaffoldScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/ScaffoldScreen.kt
new file mode 100644
index 0000000..467eea6
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/ScaffoldScreen.kt
@@ -0,0 +1,49 @@
+package dev.hho.android.ui
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+
+@Composable
+fun ScaffoldScreen(
+    viewModel: ScaffoldViewModel = hiltViewModel(),
+) {
+    ScaffoldScreenContent(state = viewModel.state)
+}
+
+@Composable
+private fun ScaffoldScreenContent(
+    state: ScaffoldUiState,
+    modifier: Modifier = Modifier,
+) {
+    Scaffold(modifier = modifier.fillMaxSize()) { innerPadding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(innerPadding)
+                .padding(24.dp),
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            Text(
+                text = "HHO",
+                style = MaterialTheme.typography.headlineMedium,
+            )
+            Text(
+                text = "Scaffold only — no features yet.",
+                style = MaterialTheme.typography.bodyMedium,
+            )
+            Text(
+                text = "${state.applicationId} ${state.versionName} (minSdk ${state.minSdk})",
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/ScaffoldViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/ScaffoldViewModel.kt
new file mode 100644
index 0000000..0ff92c1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/ScaffoldViewModel.kt
@@ -0,0 +1,24 @@
+package dev.hho.android.ui
+
+import androidx.lifecycle.ViewModel
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.di.BuildInfo
+import javax.inject.Inject
+
+@HiltViewModel
+class ScaffoldViewModel @Inject constructor(
+    private val buildInfo: BuildInfo,
+) : ViewModel() {
+
+    val state: ScaffoldUiState = ScaffoldUiState(
+        applicationId = buildInfo.applicationId,
+        versionName = buildInfo.versionName,
+        minSdk = buildInfo.minSdk,
+    )
+}
+
+data class ScaffoldUiState(
+    val applicationId: String,
+    val versionName: String,
+    val minSdk: Int,
+)
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/connect/ConnectScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/connect/ConnectScreen.kt
new file mode 100644
index 0000000..7985b3d
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/connect/ConnectScreen.kt
@@ -0,0 +1,92 @@
+package dev.hho.android.ui.connect
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+
+@Composable
+fun ConnectScreen(
+    onConnected: () -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: ConnectViewModel = hiltViewModel(),
+) {
+    val uiState by viewModel.uiState.collectAsState()
+
+    LaunchedEffect(Unit) {
+        viewModel.connected.collect { onConnected() }
+    }
+
+    ConnectScreenContent(
+        uiState = uiState,
+        onUrlChanged = viewModel::onUrlChanged,
+        onConnectClicked = viewModel::onConnectClicked,
+        modifier = modifier,
+    )
+}
+
+@Composable
+private fun ConnectScreenContent(
+    uiState: ConnectUiState,
+    onUrlChanged: (String) -> Unit,
+    onConnectClicked: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier
+            .fillMaxSize()
+            .padding(24.dp),
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        Text(
+            text = "Connect to your HHO instance",
+            style = MaterialTheme.typography.headlineSmall,
+        )
+        Text(
+            text = "Enter the address of your self-hosted server, e.g. https://hho.example.com " +
+                "or http://192.168.1.10:7745.",
+            style = MaterialTheme.typography.bodyMedium,
+        )
+        OutlinedTextField(
+            value = uiState.urlInput,
+            onValueChange = onUrlChanged,
+            modifier = Modifier.fillMaxWidth(),
+            label = { Text("Instance URL") },
+            singleLine = true,
+            isError = uiState.errorMessage != null,
+            enabled = !uiState.isChecking,
+        )
+        if (uiState.errorMessage != null) {
+            Text(
+                text = uiState.errorMessage,
+                color = MaterialTheme.colorScheme.error,
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+        Button(
+            onClick = onConnectClicked,
+            enabled = !uiState.isChecking && uiState.urlInput.isNotBlank(),
+        ) {
+            if (uiState.isChecking) {
+                CircularProgressIndicator(
+                    modifier = Modifier.padding(end = 8.dp),
+                    color = MaterialTheme.colorScheme.onPrimary,
+                )
+            }
+            Text(if (uiState.isChecking) "Connecting…" else "Connect")
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/connect/ConnectViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/connect/ConnectViewModel.kt
new file mode 100644
index 0000000..870686a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/connect/ConnectViewModel.kt
@@ -0,0 +1,113 @@
+package dev.hho.android.ui.connect
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.network.InstanceUrlNormalization
+import dev.hho.android.data.network.InstanceUrlNormalizer
+import dev.hho.android.data.settings.SettingsKeys
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+@HiltViewModel
+class ConnectViewModel
+    @Inject
+    constructor(
+        private val settingsDataStore: DataStore<Preferences>,
+        private val hhoApiClient: HhoApiClient,
+    ) : ViewModel() {
+
+        private val _uiState = MutableStateFlow(ConnectUiState())
+        val uiState: StateFlow<ConnectUiState> = _uiState.asStateFlow()
+
+        private val _connected = Channel<Unit>(Channel.BUFFERED)
+        val connected: Flow<Unit> = _connected.receiveAsFlow()
+
+        init {
+            viewModelScope.launch { prefillStoredUrl() }
+        }
+
+        internal suspend fun prefillStoredUrl() {
+            val stored = settingsDataStore.data.map { it[SettingsKeys.INSTANCE_BASE_URL] }.first()
+            if (!stored.isNullOrBlank()) {
+                _uiState.update { it.copy(urlInput = stored) }
+            }
+        }
+
+        fun onUrlChanged(value: String) {
+            _uiState.update { it.copy(urlInput = value, errorMessage = null) }
+        }
+
+        fun onConnectClicked() {
+            if (_uiState.value.isChecking) return
+            viewModelScope.launch { connect(_uiState.value.urlInput) }
+        }
+
+        internal suspend fun connect(candidate: String) {
+            _uiState.update { it.copy(isChecking = true, errorMessage = null) }
+            when (val normalized = InstanceUrlNormalizer.normalize(candidate)) {
+                is InstanceUrlNormalization.Invalid -> {
+                    _uiState.update { it.copy(isChecking = false, errorMessage = normalized.reason) }
+                }
+                is InstanceUrlNormalization.Valid -> {
+                    hhoApiClient.probeInstance(normalized.url).fold(
+                        onSuccess = {
+                            settingsDataStore.edit { prefs ->
+                                prefs[SettingsKeys.INSTANCE_BASE_URL] = normalized.url.toString()
+                            }
+                            _uiState.update { it.copy(isChecking = false) }
+                            _connected.send(Unit)
+                        },
+                        onFailure = { error ->
+                            _uiState.update {
+                                it.copy(isChecking = false, errorMessage = connectErrorMessage(error))
+                            }
+                        },
+                    )
+                }
+            }
+        }
+    }
+
+data class ConnectUiState(
+    val urlInput: String = "",
+    val isChecking: Boolean = false,
+    val errorMessage: String? = null,
+)
+
+private fun connectErrorMessage(error: Throwable): String {
+    val apiError = error as? ApiError
+        ?: return "Couldn't connect. Check the URL and try again."
+    return when (apiError) {
+        is ApiError.NoInstanceConfigured ->
+            "Enter an instance URL."
+        is ApiError.UpgradeRequired ->
+            "This app is too old for that server (it requires client version " +
+                "${apiError.minimumVersion} or newer). Update the app and try again."
+        is ApiError.NotFound ->
+            "No HHO server answered at that address. If it's behind a reverse-proxy " +
+                "subpath, make sure the path is included, e.g. https://example.com/hho."
+        is ApiError.UnexpectedPayload ->
+            "That address answered, but it doesn't look like an HHO server."
+        is ApiError.Network ->
+            "Couldn't reach that address. Check the URL and that this device can reach the server."
+        is ApiError.Unauthorized ->
+            "That server rejected the request unexpectedly. Check the URL."
+        is ApiError.Conflict, is ApiError.Validation, is ApiError.Server, is ApiError.Unknown ->
+            "That server answered unexpectedly. Check the URL and try again."
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/deeplink/DeepLink.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/deeplink/DeepLink.kt
new file mode 100644
index 0000000..b1dc072
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/deeplink/DeepLink.kt
@@ -0,0 +1,36 @@
+package dev.hho.android.ui.deeplink
+
+import java.net.URI
+import java.net.URISyntaxException
+import java.util.Locale
+
+sealed interface ItemDeepLink {
+    data class ById(val itemId: String) : ItemDeepLink
+
+    data class ByShortCode(val shortCode: String) : ItemDeepLink
+}
+
+private val UUID_SHAPE =
+    Regex("[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}")
+
+private const val MAX_TOKEN_LENGTH = 128
+
+fun parseItemDeepLink(uri: String?): ItemDeepLink? {
+    if (uri.isNullOrBlank()) return null
+    val parsed = try {
+        URI(uri)
+    } catch (_: URISyntaxException) {
+        return null
+    }
+    val scheme = parsed.scheme?.lowercase(Locale.ROOT)
+    if ((scheme != "http" && scheme != "https") || parsed.host.isNullOrEmpty()) return null
+    val segments = (parsed.path ?: return null).removeSuffix("/").split('/')
+    if (segments.size != 3 || segments[0].isNotEmpty() || segments[1] != "i") return null
+    val token = segments[2]
+    if (token.isEmpty() || token.length > MAX_TOKEN_LENGTH || token.any { it.isWhitespace() }) return null
+    return if (UUID_SHAPE.matches(token)) {
+        ItemDeepLink.ById(token.lowercase(Locale.ROOT))
+    } else {
+        ItemDeepLink.ByShortCode(token)
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/deeplink/DeepLinkNotFoundScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/deeplink/DeepLinkNotFoundScreen.kt
new file mode 100644
index 0000000..b2a39a2
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/deeplink/DeepLinkNotFoundScreen.kt
@@ -0,0 +1,30 @@
+package dev.hho.android.ui.deeplink
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun DeepLinkNotFoundScreen(onBack: () -> Unit) {
+    Column(
+        modifier = Modifier.fillMaxSize().padding(24.dp),
+        verticalArrangement = Arrangement.spacedBy(16.dp, Alignment.CenterVertically),
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        Text("Item not found", style = MaterialTheme.typography.headlineSmall)
+        Text(
+            "This link does not match any item synced to this device. It may belong to another " +
+                "household, have been deleted, or not have synced yet.",
+            style = MaterialTheme.typography.bodyMedium,
+        )
+        Button(onClick = onBack) { Text("Back to items") }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/deeplink/DeepLinkResolver.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/deeplink/DeepLinkResolver.kt
new file mode 100644
index 0000000..e243d94
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/deeplink/DeepLinkResolver.kt
@@ -0,0 +1,23 @@
+package dev.hho.android.ui.deeplink
+
+import dev.hho.android.data.room.ItemDao
+import kotlinx.coroutines.flow.first
+import javax.inject.Inject
+
+sealed interface DeepLinkResolution {
+    data class Found(val itemId: String) : DeepLinkResolution
+
+    data class NotFound(val link: ItemDeepLink) : DeepLinkResolution
+}
+
+class DeepLinkResolver @Inject constructor(private val itemDao: ItemDao) {
+
+    suspend fun resolve(link: ItemDeepLink): DeepLinkResolution {
+        val id = when (link) {
+            is ItemDeepLink.ById -> itemDao.getById(link.itemId)?.id
+            is ItemDeepLink.ByShortCode ->
+                itemDao.observeAll().first().firstOrNull { it.shortCode == link.shortCode }?.id
+        }
+        return id?.let { DeepLinkResolution.Found(it) } ?: DeepLinkResolution.NotFound(link)
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/deeplink/DeepLinkViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/deeplink/DeepLinkViewModel.kt
new file mode 100644
index 0000000..644a7e2
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/deeplink/DeepLinkViewModel.kt
@@ -0,0 +1,12 @@
+package dev.hho.android.ui.deeplink
+
+import androidx.lifecycle.ViewModel
+import dagger.hilt.android.lifecycle.HiltViewModel
+import javax.inject.Inject
+
+@HiltViewModel
+class DeepLinkViewModel @Inject constructor(
+    private val resolver: DeepLinkResolver,
+) : ViewModel() {
+    suspend fun resolve(link: ItemDeepLink): DeepLinkResolution = resolver.resolve(link)
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/home/HomeScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/home/HomeScreen.kt
new file mode 100644
index 0000000..a930d09
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/home/HomeScreen.kt
@@ -0,0 +1,42 @@
+package dev.hho.android.ui.home
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun HomeScreen(
+    onViewItems: () -> Unit,
+    onReceiveDelivery: () -> Unit,
+    onSyncStatus: () -> Unit,
+    modifier: Modifier = Modifier,
+    syncProblem: Boolean = false,
+) {
+    Column(
+        modifier = modifier
+            .fillMaxSize()
+            .padding(24.dp),
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        Text(
+            text = "Logged in.",
+            style = MaterialTheme.typography.bodyMedium,
+        )
+        Button(onClick = onViewItems) {
+            Text("View items")
+        }
+        Button(onClick = onReceiveDelivery) {
+            Text("Receive delivery")
+        }
+        Button(onClick = onSyncStatus) {
+            Text(if (syncProblem) "Sync status (!)" else "Sync status")
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/items/AdjustStockDialog.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/AdjustStockDialog.kt
new file mode 100644
index 0000000..1dc88ad
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/AdjustStockDialog.kt
@@ -0,0 +1,119 @@
+package dev.hho.android.ui.items
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.unit.dp
+
+internal val ADJUST_REASON_PRESETS = listOf("Used", "Restocked", "Lost", "Correction")
+
+@Composable
+fun AdjustStockDialog(
+    state: AdjustStockState,
+    onSubmit: (delta: Long?, reason: String, note: String) -> Unit,
+    onDismiss: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    var deltaText by rememberSaveable { mutableStateOf("1") }
+    var reason by rememberSaveable { mutableStateOf("") }
+    var note by rememberSaveable { mutableStateOf("") }
+
+    LaunchedEffect(state.completed) {
+        if (state.completed) onDismiss()
+    }
+
+    AlertDialog(
+        modifier = modifier,
+        onDismissRequest = { if (!state.submitting) onDismiss() },
+        title = { Text("Adjust quantity") },
+        text = {
+            Column(
+                modifier = Modifier.verticalScroll(rememberScrollState()),
+                verticalArrangement = Arrangement.spacedBy(12.dp),
+            ) {
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                    OutlinedButton(
+                        onClick = { deltaText = step(deltaText, -1) },
+                        enabled = !state.submitting,
+                    ) { Text("-1") }
+                    OutlinedTextField(
+                        value = deltaText,
+                        onValueChange = { deltaText = it },
+                        label = { Text("Change (+/-)") },
+                        singleLine = true,
+                        enabled = !state.submitting,
+                        isError = state.deltaError != null,
+                        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
+                        modifier = Modifier.weight(1f),
+                    )
+                    OutlinedButton(
+                        onClick = { deltaText = step(deltaText, 1) },
+                        enabled = !state.submitting,
+                    ) { Text("+1") }
+                }
+                state.deltaError?.let { ErrorLine(it) }
+                Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                    ADJUST_REASON_PRESETS.forEach { preset ->
+                        FilterChip(
+                            selected = reason == preset,
+                            onClick = { reason = preset },
+                            enabled = !state.submitting,
+                            label = { Text(preset) },
+                        )
+                    }
+                }
+                OutlinedTextField(
+                    value = reason,
+                    onValueChange = { reason = it },
+                    label = { Text("Reason (optional)") },
+                    singleLine = true,
+                    enabled = !state.submitting,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+                OutlinedTextField(
+                    value = note,
+                    onValueChange = { note = it },
+                    label = { Text("Note (optional)") },
+                    enabled = !state.submitting,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+                state.generalError?.let { ErrorLine(it) }
+            }
+        },
+        confirmButton = {
+            TextButton(
+                onClick = { onSubmit(deltaText.trim().toLongOrNull(), reason, note) },
+                enabled = !state.submitting,
+            ) { Text(if (state.submitting) "Saving..." else "Confirm") }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss, enabled = !state.submitting) { Text("Cancel") }
+        },
+    )
+}
+
+@Composable
+private fun ErrorLine(message: String) {
+    Text(text = message, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+}
+
+internal fun step(text: String, by: Long): String = ((text.trim().toLongOrNull() ?: 0L) + by).toString()
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemDetailScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemDetailScreen.kt
new file mode 100644
index 0000000..002a796
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemDetailScreen.kt
@@ -0,0 +1,330 @@
+package dev.hho.android.ui.items
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import dev.hho.android.ui.photos.ItemPhotoBadgeViewModel
+import dev.hho.android.ui.photos.PhotoBadge
+
+private const val UNKNOWN_TYPED_VALUE_PLACEHOLDER = "(unrenderable value)"
+
+@Composable
+internal fun ItemDetailScreen(
+    itemId: String,
+    onBack: () -> Unit,
+    modifier: Modifier = Modifier,
+    onEdit: () -> Unit = {},
+    onAddPhoto: () -> Unit = {},
+    viewModel: ItemDetailViewModel = hiltViewModel(),
+    stockViewModel: StockActionsViewModel = hiltViewModel(),
+    editViewModel: ItemEditActionsViewModel = hiltViewModel(),
+    photoBadgeViewModel: ItemPhotoBadgeViewModel = hiltViewModel(),
+) {
+    LaunchedEffect(itemId) {
+        viewModel.loadItem(itemId)
+        editViewModel.load(itemId)
+        photoBadgeViewModel.load(itemId)
+    }
+    val uiState by viewModel.uiState.collectAsState()
+    val stockState by stockViewModel.state.collectAsState()
+    val editState by editViewModel.state.collectAsState()
+    val editOptions by editViewModel.options.collectAsState()
+    val photoBadge by photoBadgeViewModel.badge.collectAsState()
+    var adjusting by remember { mutableStateOf(false) }
+    var movingLocation by remember { mutableStateOf(false) }
+    var editingLabels by remember { mutableStateOf(false) }
+    ItemDetailScreenContent(
+        uiState = uiState,
+        onBack = onBack,
+        onEdit = onEdit,
+        onAddPhoto = onAddPhoto,
+        photoBadge = photoBadge,
+        onAdjustQuantity = {
+            stockViewModel.reset()
+            adjusting = true
+        },
+        onMoveLocation = {
+            editViewModel.reset()
+            movingLocation = true
+        },
+        onEditLabels = {
+            editViewModel.reset()
+            editingLabels = true
+        },
+        modifier = modifier,
+    )
+    if (movingLocation) {
+        LocationPicker(
+            options = editOptions,
+            state = editState,
+            onSelect = { locationId -> editViewModel.move(itemId, locationId) },
+            onDismiss = {
+                movingLocation = false
+                editViewModel.reset()
+            },
+        )
+    }
+    if (editingLabels) {
+        LabelEditor(
+            options = editOptions,
+            state = editState,
+            onAttach = { labelId -> editViewModel.attach(itemId, labelId) },
+            onDetach = { labelId -> editViewModel.detach(itemId, labelId) },
+            onDismiss = {
+                editingLabels = false
+                editViewModel.reset()
+            },
+        )
+    }
+    if (adjusting) {
+        AdjustStockDialog(
+            state = stockState,
+            onSubmit = { delta, reason, note -> stockViewModel.submit(itemId, delta, reason, note) },
+            onDismiss = {
+                adjusting = false
+                stockViewModel.reset()
+            },
+        )
+    }
+}
+
+@Composable
+private fun ItemDetailScreenContent(
+    uiState: ItemDetailUiState,
+    onBack: () -> Unit,
+    onEdit: () -> Unit,
+    onAddPhoto: () -> Unit,
+    photoBadge: PhotoBadge,
+    onAdjustQuantity: () -> Unit,
+    onMoveLocation: () -> Unit,
+    onEditLabels: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier
+            .fillMaxSize()
+            .padding(24.dp),
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
+            TextButton(onClick = onBack) {
+                Text("Back")
+            }
+            if (uiState is ItemDetailUiState.Data) {
+                TextButton(onClick = onEdit) { Text("Edit") }
+            }
+        }
+        when (uiState) {
+            is ItemDetailUiState.Loading ->
+                Box(modifier = Modifier.fillMaxWidth(), contentAlignment = Alignment.Center) {
+                    CircularProgressIndicator()
+                }
+
+            is ItemDetailUiState.NotFound ->
+                Text(
+                    text = "This item couldn't be found. It may have been deleted, or this " +
+                        "device hasn't synced it yet.",
+                    style = MaterialTheme.typography.bodyMedium,
+                )
+
+            is ItemDetailUiState.Data ->
+                ItemDetailBody(
+                    item = uiState.item,
+                    onAddPhoto = onAddPhoto,
+                    photoBadge = photoBadge,
+                    onAdjustQuantity = onAdjustQuantity,
+                    onMoveLocation = onMoveLocation,
+                    onEditLabels = onEditLabels,
+                    modifier = Modifier
+                        .weight(1f)
+                        .verticalScroll(rememberScrollState()),
+                )
+        }
+    }
+}
+
+@Composable
+private fun ItemDetailBody(
+    item: ItemDetailData,
+    onAddPhoto: () -> Unit,
+    photoBadge: PhotoBadge,
+    onAdjustQuantity: () -> Unit,
+    onMoveLocation: () -> Unit,
+    onEditLabels: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier.fillMaxWidth(),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        Text(text = item.name, style = MaterialTheme.typography.headlineSmall)
+        item.description?.let { description ->
+            Text(text = description, style = MaterialTheme.typography.bodyMedium)
+        }
+        item.quantity?.let { quantity ->
+            Text(text = "Quantity: $quantity", style = MaterialTheme.typography.bodyMedium)
+        }
+        OutlinedButton(onClick = onAdjustQuantity) { Text("Adjust quantity") }
+        item.shortCode?.let { shortCode ->
+            Text(text = "Short code: $shortCode", style = MaterialTheme.typography.bodyMedium)
+        }
+        item.locationName?.let { locationName ->
+            Text(text = "Location: $locationName", style = MaterialTheme.typography.bodyMedium)
+        }
+        if (item.labelNames.isNotEmpty()) {
+            Text(text = "Labels: ${item.labelNames.joinToString(", ")}", style = MaterialTheme.typography.bodyMedium)
+        }
+        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            OutlinedButton(onClick = onMoveLocation) { Text("Move location") }
+            OutlinedButton(onClick = onEditLabels) { Text("Edit labels") }
+        }
+        OutlinedButton(onClick = onAddPhoto) { Text("Add photo") }
+        photoBadge.summary()?.let { summary ->
+            Text(
+                text = summary,
+                style = MaterialTheme.typography.bodySmall,
+                color = if (photoBadge.failed > 0) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+
+        HorizontalDivider(modifier = Modifier.padding(vertical = 8.dp))
+
+        item.warranty?.let { warranty -> WarrantySection(warranty) }
+        item.soldTo?.let { soldTo -> SoldToSection(soldTo) }
+        item.purchasedFrom?.let { purchasedFrom -> PurchasedFromSection(purchasedFrom) }
+        if (item.identifiers.isNotEmpty()) {
+            IdentifiersSection(item.identifiers)
+        }
+        if (item.customFields.isNotEmpty()) {
+            CustomFieldsSection(item.customFields)
+        }
+        if (item.stockAdjustments.isNotEmpty()) {
+            StockHistorySection(item.stockAdjustments)
+        }
+    }
+}
+
+@Composable
+private fun DetailSection(
+    title: String,
+    modifier: Modifier = Modifier,
+    content: @Composable () -> Unit,
+) {
+    Column(
+        modifier = modifier.fillMaxWidth(),
+        verticalArrangement = Arrangement.spacedBy(4.dp),
+    ) {
+        Text(text = title, style = MaterialTheme.typography.titleMedium)
+        content()
+    }
+}
+
+@Composable
+private fun WarrantySection(warranty: WarrantyBlockData) {
+    DetailSection(title = "Warranty") {
+        Text(
+            text = if (warranty.isLifetime) "Lifetime" else "Limited",
+            style = MaterialTheme.typography.bodyMedium,
+        )
+        warranty.holder?.let { Text("Holder: $it", style = MaterialTheme.typography.bodyMedium) }
+        warranty.provider?.let { Text("Provider: $it", style = MaterialTheme.typography.bodyMedium) }
+        warranty.startsOn?.let { Text("Starts: $it", style = MaterialTheme.typography.bodyMedium) }
+        warranty.expiresOn?.let { Text("Expires: $it", style = MaterialTheme.typography.bodyMedium) }
+        warranty.notes?.let { Text("Notes: $it", style = MaterialTheme.typography.bodyMedium) }
+    }
+}
+
+@Composable
+private fun SoldToSection(soldTo: SoldToBlockData) {
+    DetailSection(title = "Sold to") {
+        Text(text = "Sale price (minor units): ${soldTo.salePriceMinor}", style = MaterialTheme.typography.bodyMedium)
+        soldTo.buyerName?.let { Text("Buyer: $it", style = MaterialTheme.typography.bodyMedium) }
+        soldTo.soldOn?.let { Text("Sold on: $it", style = MaterialTheme.typography.bodyMedium) }
+        soldTo.notes?.let { Text("Notes: $it", style = MaterialTheme.typography.bodyMedium) }
+    }
+}
+
+@Composable
+private fun PurchasedFromSection(purchasedFrom: PurchasedFromBlockData) {
+    DetailSection(title = "Purchased from") {
+        Text(
+            text = "Purchase price (minor units): ${purchasedFrom.purchasePriceMinor}",
+            style = MaterialTheme.typography.bodyMedium,
+        )
+        purchasedFrom.vendor?.let { Text("Vendor: $it", style = MaterialTheme.typography.bodyMedium) }
+        purchasedFrom.purchasedOn?.let { Text("Purchased on: $it", style = MaterialTheme.typography.bodyMedium) }
+        purchasedFrom.orderReference?.let { Text("Order reference: $it", style = MaterialTheme.typography.bodyMedium) }
+        purchasedFrom.notes?.let { Text("Notes: $it", style = MaterialTheme.typography.bodyMedium) }
+    }
+}
+
+@Composable
+private fun IdentifiersSection(identifiers: List<IdentifierData>) {
+    DetailSection(title = "Identifiers") {
+        identifiers.forEach { identifier ->
+            Text(
+                text = "${identifier.kind}: ${identifier.value}",
+                style = MaterialTheme.typography.bodyMedium,
+            )
+        }
+    }
+}
+
+@Composable
+private fun CustomFieldsSection(customFields: List<CustomFieldData>) {
+    DetailSection(title = "Custom fields") {
+        customFields.forEach { field ->
+            Text(
+                text = "${field.name}: ${field.value.render()}",
+                style = MaterialTheme.typography.bodyMedium,
+            )
+        }
+    }
+}
+
+@Composable
+private fun StockHistorySection(stockAdjustments: List<StockAdjustmentData>) {
+    DetailSection(title = "Stock history") {
+        stockAdjustments.forEach { adjustment ->
+            val sign = if (adjustment.delta >= 0) "+" else ""
+            val reasonSuffix = adjustment.reason?.let { " ($it)" }.orEmpty()
+            Text(
+                text = "$sign${adjustment.delta} → ${adjustment.resultingQuantity}$reasonSuffix",
+                style = MaterialTheme.typography.bodyMedium,
+            )
+            adjustment.note?.let { Text("Note: $it", style = MaterialTheme.typography.bodySmall) }
+        }
+    }
+}
+
+private fun CustomFieldValue?.render(): String =
+    when (this) {
+        is CustomFieldValue.Text -> value
+        is CustomFieldValue.Number -> value.toPlainString()
+        is CustomFieldValue.Bool -> if (value) "Yes" else "No"
+        is CustomFieldValue.Date -> value.toString()
+        null -> UNKNOWN_TYPED_VALUE_PLACEHOLDER
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemDetailViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemDetailViewModel.kt
new file mode 100644
index 0000000..1e32272
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemDetailViewModel.kt
@@ -0,0 +1,291 @@
+package dev.hho.android.ui.items
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.outbox.OutboxOverlay
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemCustomFieldDao
+import dev.hho.android.data.room.ItemCustomFieldEntity
+import dev.hho.android.data.room.ItemDao
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemIdentificationDao
+import dev.hho.android.data.room.ItemIdentificationEntity
+import dev.hho.android.data.room.ItemLabelDao
+import dev.hho.android.data.room.ItemLabelEntity
+import dev.hho.android.data.room.LabelDao
+import dev.hho.android.data.room.LabelEntity
+import dev.hho.android.data.room.LocationDao
+import dev.hho.android.data.room.LocationEntity
+import dev.hho.android.data.room.PurchasedFromBlockDao
+import dev.hho.android.data.room.PurchasedFromBlockEntity
+import dev.hho.android.data.room.SoldToBlockDao
+import dev.hho.android.data.room.SoldToBlockEntity
+import dev.hho.android.data.room.StockAdjustmentDao
+import dev.hho.android.data.room.StockAdjustmentEntity
+import dev.hho.android.data.room.WarrantyBlockDao
+import dev.hho.android.data.room.WarrantyBlockEntity
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.stateIn
+import java.math.BigDecimal
+import java.time.LocalDate
+import javax.inject.Inject
+
+@HiltViewModel
+class ItemDetailViewModel
+    @Inject
+    constructor(
+        private val itemDao: ItemDao,
+        private val itemLabelDao: ItemLabelDao,
+        private val labelDao: LabelDao,
+        private val locationDao: LocationDao,
+        private val warrantyBlockDao: WarrantyBlockDao,
+        private val soldToBlockDao: SoldToBlockDao,
+        private val purchasedFromBlockDao: PurchasedFromBlockDao,
+        private val itemIdentificationDao: ItemIdentificationDao,
+        private val itemCustomFieldDao: ItemCustomFieldDao,
+        private val stockAdjustmentDao: StockAdjustmentDao,
+        private val db: HhoDatabase,
+    ) : ViewModel() {
+
+        private val itemIdFlow = MutableStateFlow<String?>(null)
+
+        @OptIn(ExperimentalCoroutinesApi::class)
+        val uiState: StateFlow<ItemDetailUiState> =
+            itemIdFlow
+                .filterNotNull()
+                .distinctUntilChanged()
+                .flatMapLatest(::observeItem)
+                .stateIn(
+                    scope = viewModelScope,
+                    started = SharingStarted.WhileSubscribed(STOP_TIMEOUT_MILLIS),
+                    initialValue = ItemDetailUiState.Loading,
+                )
+
+        fun loadItem(id: String) {
+            itemIdFlow.value = id
+        }
+
+        private fun observeItem(id: String): Flow<ItemDetailUiState> {
+            val core =
+                combine(
+                    itemDao.observeById(id),
+                    itemLabelDao.observeByItemId(id),
+                    labelDao.observeAll(),
+                    locationDao.observeAll(),
+                    OutboxOverlay.observeDerivedQuantity(db, id),
+                ) { item, assignments, labels, locations, derivedQuantity ->
+                    CoreDetails(item, assignments, labels, locations, derivedQuantity)
+                }
+
+            val blocks =
+                combine(
+                    warrantyBlockDao.observeByItemId(id),
+                    soldToBlockDao.observeByItemId(id),
+                    purchasedFromBlockDao.observeByItemId(id),
+                ) { warranty, soldTo, purchasedFrom -> BlockDetails(warranty, soldTo, purchasedFrom) }
+
+            val lists =
+                combine(
+                    itemIdentificationDao.observeByItemId(id),
+                    itemCustomFieldDao.observeByItemId(id),
+                    stockAdjustmentDao.observeByItemId(id),
+                ) { identifiers, customFields, stockAdjustments ->
+                    ListDetails(identifiers, customFields, stockAdjustments)
+                }
+
+            return combine(core, blocks, lists) { coreDetails, blockDetails, listDetails ->
+                toUiState(coreDetails, blockDetails, listDetails)
+            }
+        }
+
+        private fun toUiState(
+            core: CoreDetails,
+            blocks: BlockDetails,
+            lists: ListDetails,
+        ): ItemDetailUiState {
+            val item = core.item ?: return ItemDetailUiState.NotFound
+
+            val labelNames = core.assignments.mapNotNull { assignment ->
+                core.labels.firstOrNull { it.id == assignment.labelId }?.name
+            }
+            val locationName = item.locationId?.let { locationId ->
+                core.locations.firstOrNull { it.id == locationId }?.name
+            }
+
+            return ItemDetailUiState.Data(
+                ItemDetailData(
+                    id = item.id,
+                    name = item.name,
+                    description = item.description,
+                    quantity = core.derivedQuantity?.takeUnless { item.quantity == null && it == 0L },
+                    shortCode = item.shortCode,
+                    locationName = locationName,
+                    labelNames = labelNames,
+                    warranty = blocks.warranty?.toData(),
+                    soldTo = blocks.soldTo?.toData(),
+                    purchasedFrom = blocks.purchasedFrom?.toData(),
+                    identifiers = lists.identifiers.map { it.toData() },
+                    customFields = lists.customFields.map { it.toData() },
+                    stockAdjustments = lists.stockAdjustments.map { it.toData() },
+                ),
+            )
+        }
+
+        private data class CoreDetails(
+            val item: ItemEntity?,
+            val assignments: List<ItemLabelEntity>,
+            val labels: List<LabelEntity>,
+            val locations: List<LocationEntity>,
+            val derivedQuantity: Long?,
+        )
+
+        private data class BlockDetails(
+            val warranty: WarrantyBlockEntity?,
+            val soldTo: SoldToBlockEntity?,
+            val purchasedFrom: PurchasedFromBlockEntity?,
+        )
+
+        private data class ListDetails(
+            val identifiers: List<ItemIdentificationEntity>,
+            val customFields: List<ItemCustomFieldEntity>,
+            val stockAdjustments: List<StockAdjustmentEntity>,
+        )
+    }
+
+private fun WarrantyBlockEntity.toData() =
+    WarrantyBlockData(
+        isLifetime = isLifetime,
+        holder = holder,
+        provider = provider,
+        startsOn = startsOn,
+        expiresOn = expiresOn,
+        notes = notes,
+    )
+
+private fun SoldToBlockEntity.toData() =
+    SoldToBlockData(
+        salePriceMinor = salePriceMinor,
+        buyerName = buyerName,
+        soldOn = soldOn,
+        notes = notes,
+    )
+
+private fun PurchasedFromBlockEntity.toData() =
+    PurchasedFromBlockData(
+        purchasePriceMinor = purchasePriceMinor,
+        vendor = vendor,
+        purchasedOn = purchasedOn,
+        orderReference = orderReference,
+        notes = notes,
+    )
+
+private fun ItemIdentificationEntity.toData() =
+    IdentifierData(kind = kind, value = value)
+
+private fun StockAdjustmentEntity.toData() =
+    StockAdjustmentData(
+        delta = delta,
+        resultingQuantity = resultingQuantity,
+        reason = reason,
+        note = note,
+        createdAt = createdAt,
+    )
+
+private fun ItemCustomFieldEntity.toData(): CustomFieldData =
+    CustomFieldData(
+        name = name,
+        value = when (fieldType) {
+            "text" -> textValue?.let(CustomFieldValue::Text)
+            "number" -> numberValue?.let(CustomFieldValue::Number)
+            "boolean" -> boolValue?.let(CustomFieldValue::Bool)
+            "date" -> dateValue?.let(CustomFieldValue::Date)
+            else -> null
+        },
+    )
+
+private const val STOP_TIMEOUT_MILLIS = 5_000L
+
+sealed interface ItemDetailUiState {
+    data object Loading : ItemDetailUiState
+
+    data object NotFound : ItemDetailUiState
+
+    data class Data(val item: ItemDetailData) : ItemDetailUiState
+}
+
+data class ItemDetailData(
+    val id: String,
+    val name: String,
+    val description: String?,
+    val quantity: Long?,
+    val shortCode: String?,
+    val locationName: String?,
+    val labelNames: List<String>,
+    val warranty: WarrantyBlockData?,
+    val soldTo: SoldToBlockData?,
+    val purchasedFrom: PurchasedFromBlockData?,
+    val identifiers: List<IdentifierData>,
+    val customFields: List<CustomFieldData>,
+    val stockAdjustments: List<StockAdjustmentData>,
+)
+
+data class WarrantyBlockData(
+    val isLifetime: Boolean,
+    val holder: String?,
+    val provider: String?,
+    val startsOn: LocalDate?,
+    val expiresOn: LocalDate?,
+    val notes: String?,
+)
+
+data class SoldToBlockData(
+    val salePriceMinor: Long,
+    val buyerName: String?,
+    val soldOn: LocalDate?,
+    val notes: String?,
+)
+
+data class PurchasedFromBlockData(
+    val purchasePriceMinor: Long,
+    val vendor: String?,
+    val purchasedOn: LocalDate?,
+    val orderReference: String?,
+    val notes: String?,
+)
+
+data class IdentifierData(
+    val kind: String,
+    val value: String,
+)
+
+data class CustomFieldData(
+    val name: String,
+    val value: CustomFieldValue?,
+)
+
+sealed interface CustomFieldValue {
+    data class Text(val value: String) : CustomFieldValue
+
+    data class Number(val value: BigDecimal) : CustomFieldValue
+
+    data class Bool(val value: Boolean) : CustomFieldValue
+
+    data class Date(val value: LocalDate) : CustomFieldValue
+}
+
+data class StockAdjustmentData(
+    val delta: Long,
+    val resultingQuantity: Long,
+    val reason: String?,
+    val note: String?,
+    val createdAt: Long?,
+)
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemEditActionsViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemEditActionsViewModel.kt
new file mode 100644
index 0000000..0ad7d6d
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemEditActionsViewModel.kt
@@ -0,0 +1,150 @@
+package dev.hho.android.ui.items
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.room.ItemDao
+import dev.hho.android.data.room.ItemLabelDao
+import dev.hho.android.data.room.LabelDao
+import dev.hho.android.data.room.LabelEntity
+import dev.hho.android.data.room.LocationDao
+import dev.hho.android.data.room.LocationEntity
+import dev.hho.android.domain.EditError
+import dev.hho.android.domain.EditRepository
+import dev.hho.android.domain.EditResult
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+internal data class LocationOption(val id: String, val path: String)
+
+internal data class LabelOption(val id: String, val name: String, val color: String)
+
+internal data class ItemEditOptions(
+    val locations: List<LocationOption> = emptyList(),
+    val currentLocationId: String? = null,
+    val attachedLabels: List<LabelOption> = emptyList(),
+    val availableLabels: List<LabelOption> = emptyList(),
+)
+
+internal data class ItemEditState(
+    val submitting: Boolean = false,
+    val error: String? = null,
+    val completed: Boolean = false,
+)
+
+@HiltViewModel
+internal class ItemEditActionsViewModel
+    @Inject
+    constructor(
+        private val edits: EditRepository,
+        private val itemDao: ItemDao,
+        private val itemLabelDao: ItemLabelDao,
+        private val labelDao: LabelDao,
+        private val locationDao: LocationDao,
+    ) : ViewModel() {
+
+        private val itemIdFlow = MutableStateFlow<String?>(null)
+        private val _state = MutableStateFlow(ItemEditState())
+        val state: StateFlow<ItemEditState> = _state.asStateFlow()
+
+        @OptIn(ExperimentalCoroutinesApi::class)
+        val options: StateFlow<ItemEditOptions> =
+            itemIdFlow
+                .filterNotNull()
+                .distinctUntilChanged()
+                .flatMapLatest(::observeOptions)
+                .stateIn(viewModelScope, SharingStarted.WhileSubscribed(STOP_TIMEOUT_MILLIS), ItemEditOptions())
+
+        fun load(itemId: String) {
+            itemIdFlow.value = itemId
+        }
+
+        fun move(itemId: String, locationId: String?) =
+            run(closeOnSuccess = true) { edits.moveItem(itemId, locationId) }
+
+        fun attach(itemId: String, labelId: String) =
+            run { edits.attachLabel(itemId, labelId) }
+
+        fun detach(itemId: String, labelId: String) =
+            run { edits.detachLabel(itemId, labelId) }
+
+        fun reset() {
+            if (!_state.value.submitting) _state.value = ItemEditState()
+        }
+
+        private fun run(closeOnSuccess: Boolean = false, action: suspend () -> EditResult<*>) {
+            if (_state.value.submitting) return
+            _state.value = ItemEditState(submitting = true)
+            viewModelScope.launch {
+                val result = action()
+                _state.update {
+                    when (result) {
+                        is EditResult.Success -> ItemEditState(completed = closeOnSuccess)
+                        is EditResult.Failure -> ItemEditState(error = message(result.error))
+                    }
+                }
+            }
+        }
+
+        private fun message(error: EditError): String =
+            when (error) {
+                is EditError.NotFound -> when (error.kind) {
+                    "location" -> "That location is no longer on this device."
+                    "label", "item_label" -> "That label is no longer on this device."
+                    else -> "This item is no longer on this device."
+                }
+                is EditError.Invalid -> error.message
+                is EditError.StorageFailed -> "Couldn't save the change. Please try again."
+            }
+
+        private fun observeOptions(itemId: String): Flow<ItemEditOptions> =
+            combine(
+                itemDao.observeById(itemId),
+                itemLabelDao.observeByItemId(itemId),
+                labelDao.observeAll(),
+                locationDao.observeAll(),
+            ) { item, edges, labels, locations ->
+                val attachedIds = edges.mapTo(HashSet()) { it.labelId }
+                val (attached, available) = labels.map { it.toOption() }.partition { it.id in attachedIds }
+                ItemEditOptions(
+                    locations = locationOptions(locations),
+                    currentLocationId = item?.locationId,
+                    attachedLabels = attached,
+                    availableLabels = available,
+                )
+            }
+
+        private companion object {
+            const val STOP_TIMEOUT_MILLIS = 5_000L
+        }
+    }
+
+private fun LabelEntity.toOption() = LabelOption(id, name, color)
+
+internal fun locationOptions(locations: List<LocationEntity>): List<LocationOption> {
+    val byId = locations.associateBy { it.id }
+    return locations
+        .map { location ->
+            val names = ArrayDeque<String>()
+            val seen = HashSet<String>()
+            var cursor: LocationEntity? = location
+            while (cursor != null && seen.add(cursor.id)) {
+                names.addFirst(cursor.name)
+                cursor = cursor.parentId?.let(byId::get)
+            }
+            LocationOption(location.id, names.joinToString(" / "))
+        }
+        .sortedBy { it.path.lowercase() }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemFormScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemFormScreen.kt
new file mode 100644
index 0000000..b9769d9
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemFormScreen.kt
@@ -0,0 +1,158 @@
+package dev.hho.android.ui.items
+
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+
+@Composable
+internal fun ItemFormScreen(
+    itemId: String?,
+    onSaved: (itemId: String) -> Unit,
+    onCancel: () -> Unit,
+    modifier: Modifier = Modifier,
+    prefillIdentifierKind: String? = null,
+    prefillIdentifierValue: String? = null,
+    viewModel: ItemFormViewModel = hiltViewModel(),
+) {
+    LaunchedEffect(itemId) { viewModel.start(itemId, prefillIdentifierKind, prefillIdentifierValue) }
+    val state by viewModel.state.collectAsState()
+    val locations by viewModel.locations.collectAsState()
+    LaunchedEffect(state.savedItemId) { state.savedItemId?.let(onSaved) }
+    ItemFormContent(
+        state = state,
+        locations = locations,
+        onNameChange = viewModel::onNameChange,
+        onDescriptionChange = viewModel::onDescriptionChange,
+        onLocationChange = viewModel::onLocationChange,
+        onKindChange = viewModel::onIdentifierKindChange,
+        onIdentifierChange = viewModel::onIdentifierValueChange,
+        onSubmit = viewModel::submit,
+        onCancel = onCancel,
+        modifier = modifier,
+    )
+}
+
+@Composable
+private fun ItemFormContent(
+    state: ItemFormState,
+    locations: List<LocationOption>,
+    onNameChange: (String) -> Unit,
+    onDescriptionChange: (String) -> Unit,
+    onLocationChange: (String?) -> Unit,
+    onKindChange: (String) -> Unit,
+    onIdentifierChange: (String) -> Unit,
+    onSubmit: () -> Unit,
+    onCancel: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    var pickingLocation by remember { mutableStateOf(false) }
+    Column(
+        modifier = modifier
+            .fillMaxSize()
+            .padding(24.dp),
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        TextButton(onClick = onCancel, enabled = !state.submitting) { Text("Cancel") }
+        Text(if (state.isEdit) "Edit item" else "New item", style = MaterialTheme.typography.headlineSmall)
+        when {
+            state.loading -> CircularProgressIndicator()
+            state.notFound -> Text("This item couldn't be found. It may have been deleted, or this device hasn't synced it yet.")
+            else -> Column(
+                modifier = Modifier
+                    .weight(1f)
+                    .verticalScroll(rememberScrollState()),
+                verticalArrangement = Arrangement.spacedBy(12.dp),
+            ) {
+                OutlinedTextField(
+                    value = state.name,
+                    onValueChange = onNameChange,
+                    label = { Text("Name (required)") },
+                    isError = state.nameError != null,
+                    supportingText = state.nameError?.let { { Text(it) } },
+                    singleLine = true,
+                    enabled = !state.submitting,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+                OutlinedTextField(
+                    value = state.description,
+                    onValueChange = onDescriptionChange,
+                    label = { Text("Description") },
+                    enabled = !state.submitting,
+                    minLines = 2,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+                val locationName = locations.firstOrNull { it.id == state.locationId }?.path ?: "No location"
+                OutlinedButton(onClick = { pickingLocation = true }, enabled = !state.submitting) {
+                    Text("Location: $locationName")
+                }
+                if (!state.isEdit) {
+                    Text("Identifier (optional)", style = MaterialTheme.typography.titleSmall)
+                    Row(
+                        modifier = Modifier.horizontalScroll(rememberScrollState()),
+                        horizontalArrangement = Arrangement.spacedBy(8.dp),
+                    ) {
+                        ITEM_FORM_IDENTIFICATION_KINDS.forEach { kind ->
+                            FilterChip(
+                                selected = state.identifierKind == kind,
+                                onClick = { onKindChange(kind) },
+                                enabled = !state.submitting,
+                                label = { Text(kind.replace('_', ' ')) },
+                            )
+                        }
+                    }
+                    OutlinedTextField(
+                        value = state.identifierValue,
+                        onValueChange = onIdentifierChange,
+                        label = { Text("Identifier value") },
+                        isError = state.identifierError != null,
+                        supportingText = state.identifierError?.let { { Text(it) } },
+                        singleLine = true,
+                        enabled = !state.submitting,
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                }
+                state.error?.let { Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall) }
+                Button(onClick = onSubmit, enabled = !state.submitting) {
+                    Text(if (state.submitting) "Saving..." else if (state.isEdit) "Save" else "Create")
+                }
+            }
+        }
+    }
+    if (pickingLocation) {
+        LocationPicker(
+            options = ItemEditOptions(locations = locations, currentLocationId = state.locationId),
+            state = ItemEditState(),
+            onSelect = {
+                onLocationChange(it)
+                pickingLocation = false
+            },
+            onDismiss = { pickingLocation = false },
+            title = "Choose location",
+            confirmLabel = "Choose",
+        )
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemFormViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemFormViewModel.kt
new file mode 100644
index 0000000..f1a7168
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemFormViewModel.kt
@@ -0,0 +1,174 @@
+package dev.hho.android.ui.items
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.room.ItemDao
+import dev.hho.android.data.room.LocationDao
+import dev.hho.android.domain.EditError
+import dev.hho.android.domain.EditRepository
+import dev.hho.android.domain.EditResult
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+internal val ITEM_FORM_IDENTIFICATION_KINDS: List<String> = listOf("serial", "model", "asset_tag", "barcode", "other")
+
+internal const val ITEM_FORM_DEFAULT_KIND = "barcode"
+
+internal data class ItemFormState(
+    val itemId: String? = null,
+    val loading: Boolean = false,
+    val notFound: Boolean = false,
+    val name: String = "",
+    val description: String = "",
+    val locationId: String? = null,
+    val identifierKind: String = ITEM_FORM_DEFAULT_KIND,
+    val identifierValue: String = "",
+    val nameError: String? = null,
+    val identifierError: String? = null,
+    val error: String? = null,
+    val submitting: Boolean = false,
+    val savedItemId: String? = null,
+) {
+    val isEdit: Boolean get() = itemId != null
+}
+
+@HiltViewModel
+internal class ItemFormViewModel
+    @Inject
+    constructor(
+        private val edits: EditRepository,
+        private val itemDao: ItemDao,
+        locationDao: LocationDao,
+    ) : ViewModel() {
+
+        private val _state = MutableStateFlow(ItemFormState())
+        val state: StateFlow<ItemFormState> = _state.asStateFlow()
+
+        val locations: StateFlow<List<LocationOption>> =
+            locationDao.observeAll()
+                .map(::locationOptions)
+                .stateIn(viewModelScope, SharingStarted.WhileSubscribed(STOP_TIMEOUT_MILLIS), emptyList())
+
+        private var started = false
+        private var original: OriginalItem? = null
+
+        private data class OriginalItem(val name: String, val description: String?, val locationId: String?)
+
+        fun start(itemId: String?, prefillKind: String? = null, prefillValue: String? = null) {
+            if (started) return
+            started = true
+            if (itemId == null) {
+                _state.value = ItemFormState(
+                    identifierKind = prefillKind?.takeIf { it in ITEM_FORM_IDENTIFICATION_KINDS }
+                        ?: if (prefillKind == null) ITEM_FORM_DEFAULT_KIND else "other",
+                    identifierValue = prefillValue.orEmpty(),
+                )
+                return
+            }
+            _state.value = ItemFormState(itemId = itemId, loading = true)
+            viewModelScope.launch {
+                val item = itemDao.getById(itemId)
+                if (item == null) {
+                    _state.value = ItemFormState(itemId = itemId, notFound = true)
+                } else {
+                    original = OriginalItem(item.name, item.description, item.locationId)
+                    _state.value = ItemFormState(
+                        itemId = itemId,
+                        name = item.name,
+                        description = item.description.orEmpty(),
+                        locationId = item.locationId,
+                    )
+                }
+            }
+        }
+
+        fun onNameChange(value: String) = _state.update { it.copy(name = value, nameError = null, error = null) }
+
+        fun onDescriptionChange(value: String) = _state.update { it.copy(description = value, error = null) }
+
+        fun onLocationChange(locationId: String?) = _state.update { it.copy(locationId = locationId, error = null) }
+
+        fun onIdentifierKindChange(kind: String) = _state.update { it.copy(identifierKind = kind, identifierError = null, error = null) }
+
+        fun onIdentifierValueChange(value: String) = _state.update { it.copy(identifierValue = value, identifierError = null, error = null) }
+
+        fun submit() {
+            val s = _state.value
+            if (s.submitting || s.loading || s.notFound || s.savedItemId != null) return
+            val nameError = if (s.name.isBlank()) "Name is required." else null
+            val identifier = s.identifierValue.trim()
+            val identifierError = when {
+                s.isEdit || identifier.isEmpty() -> null
+                s.identifierKind !in ITEM_FORM_IDENTIFICATION_KINDS -> "Choose an identifier type."
+                else -> null
+            }
+            if (nameError != null || identifierError != null) {
+                _state.update { it.copy(nameError = nameError, identifierError = identifierError, error = null) }
+                return
+            }
+            _state.update { it.copy(submitting = true, nameError = null, identifierError = null, error = null) }
+            viewModelScope.launch {
+                val result = if (s.itemId == null) create(s, identifier) else edit(s.itemId, s)
+                _state.update {
+                    when (result) {
+                        is EditResult.Success -> it.copy(submitting = false, savedItemId = result.value)
+                        is EditResult.Failure -> failed(it, result.error)
+                    }
+                }
+            }
+        }
+
+        private suspend fun create(s: ItemFormState, identifier: String): EditResult<String> =
+            edits.batch {
+                val created = createItem(s.name, s.description.trim().ifEmpty { null }, s.locationId)
+                if (created is EditResult.Success && identifier.isNotEmpty()) {
+                    val ident = addIdentification(created.value, s.identifierKind, identifier)
+                    if (ident is EditResult.Failure) return@batch ident
+                }
+                created
+            }
+
+        private suspend fun edit(itemId: String, s: ItemFormState): EditResult<String> {
+            val o = original ?: return EditResult.Failure(EditError.NotFound("item", itemId))
+            val name = s.name.trim().takeIf { it != o.name }
+            val description = s.description.takeIf { it.trim() != o.description.orEmpty().trim() }?.trim()
+            val moved = s.locationId != o.locationId
+            if (name == null && description == null && !moved) return EditResult.Success(itemId)
+            return when (
+                val r = edits.batch {
+                    updateItem(itemId, name, description, setLocation = moved, locationId = s.locationId)
+                }
+            ) {
+                is EditResult.Success -> EditResult.Success(itemId)
+                is EditResult.Failure -> r
+            }
+        }
+
+        private fun failed(s: ItemFormState, error: EditError): ItemFormState =
+            when {
+                error is EditError.Invalid && error.field == "name" -> s.copy(submitting = false, nameError = "Name is required.")
+                error is EditError.Invalid && (error.field == "kind" || error.field == "value") ->
+                    s.copy(submitting = false, identifierError = error.message)
+                error is EditError.Invalid -> s.copy(submitting = false, error = error.message)
+                error is EditError.NotFound -> s.copy(
+                    submitting = false,
+                    error = when (error.kind) {
+                        "location" -> "That location is no longer on this device."
+                        else -> "This item is no longer on this device."
+                    },
+                )
+                else -> s.copy(submitting = false, error = "Couldn't save the item. Please try again.")
+            }
+
+        private companion object {
+            const val STOP_TIMEOUT_MILLIS = 5_000L
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemListScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemListScreen.kt
new file mode 100644
index 0000000..2fb7572
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemListScreen.kt
@@ -0,0 +1,161 @@
+package dev.hho.android.ui.items
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+
+@Composable
+fun ItemListScreen(
+    onItemClick: (String) -> Unit,
+    onScan: () -> Unit = {},
+    onNewItem: () -> Unit = {},
+    modifier: Modifier = Modifier,
+    viewModel: ItemListViewModel = hiltViewModel(),
+) {
+    val uiState by viewModel.uiState.collectAsState()
+    val query by viewModel.queryState.collectAsState()
+    ItemListScreenContent(
+        uiState = uiState,
+        query = query,
+        onQueryChange = viewModel::onQueryChange,
+        onItemClick = onItemClick,
+        onScan = onScan,
+        onNewItem = onNewItem,
+        modifier = modifier,
+    )
+}
+
+@Composable
+private fun ItemListScreenContent(
+    uiState: ItemListUiState,
+    query: String,
+    onQueryChange: (String) -> Unit,
+    onItemClick: (String) -> Unit,
+    onScan: () -> Unit,
+    onNewItem: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(modifier = modifier.fillMaxSize()) {
+        Row(
+            modifier = Modifier.padding(horizontal = 24.dp, vertical = 8.dp),
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            OutlinedButton(onClick = onScan) {
+                Text("Scan barcode or QR label")
+            }
+            Button(onClick = onNewItem) { Text("New item") }
+        }
+        OutlinedTextField(
+            value = query,
+            onValueChange = onQueryChange,
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 24.dp, vertical = 12.dp),
+            label = { Text("Search items, short codes, or scanned values") },
+            singleLine = true,
+        )
+        ItemListBody(uiState = uiState, onItemClick = onItemClick, modifier = Modifier.fillMaxSize())
+    }
+}
+
+@Composable
+private fun ItemListBody(
+    uiState: ItemListUiState,
+    onItemClick: (String) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    when (uiState) {
+        is ItemListUiState.Loading ->
+            Box(modifier = modifier) {
+                CircularProgressIndicator(modifier = Modifier.align(Alignment.Center))
+            }
+
+        is ItemListUiState.Empty ->
+            Box(modifier = modifier) {
+                Text(
+                    text = "Nothing has synced to this device yet. Items will appear here once " +
+                        "this device finishes its first sync with your instance.",
+                    modifier = Modifier
+                        .align(Alignment.Center)
+                        .padding(24.dp),
+                    style = MaterialTheme.typography.bodyMedium,
+                )
+            }
+
+        is ItemListUiState.NoMatches ->
+            Box(modifier = modifier) {
+                Text(
+                    text = "No items, short codes, or scanned values match \"${uiState.query}\".",
+                    modifier = Modifier
+                        .align(Alignment.Center)
+                        .padding(24.dp),
+                    style = MaterialTheme.typography.bodyMedium,
+                )
+            }
+
+        is ItemListUiState.Data ->
+            LazyColumn(modifier = modifier) {
+                items(items = uiState.items, key = { it.id }) { row ->
+                    ItemRowContent(row = row, onClick = { onItemClick(row.id) })
+                    HorizontalDivider()
+                }
+            }
+    }
+}
+
+@Composable
+private fun ItemRowContent(
+    row: ItemRow,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick)
+            .padding(horizontal = 24.dp, vertical = 16.dp),
+        verticalArrangement = Arrangement.spacedBy(4.dp),
+    ) {
+        Text(text = row.name, style = MaterialTheme.typography.titleMedium)
+        val subtitle = itemRowSubtitle(row)
+        if (subtitle.isNotEmpty()) {
+            Text(
+                text = subtitle,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+    }
+}
+
+private fun itemRowSubtitle(row: ItemRow): String =
+    buildString {
+        if (row.quantity != null) {
+            append("Qty ${row.quantity}")
+        }
+        if (row.shortCode != null) {
+            if (isNotEmpty()) append(" · ")
+            append(row.shortCode)
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemListViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemListViewModel.kt
new file mode 100644
index 0000000..57fc873
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/ItemListViewModel.kt
@@ -0,0 +1,84 @@
+package dev.hho.android.ui.items
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.items.ItemSearch
+import dev.hho.android.data.outbox.PendingDeltas
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemDao
+import dev.hho.android.data.room.ItemEntity
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import javax.inject.Inject
+
+@HiltViewModel
+class ItemListViewModel
+    @Inject
+    constructor(
+        private val itemSearch: ItemSearch,
+        private val db: HhoDatabase,
+    ) : ViewModel() {
+
+        private val query = MutableStateFlow("")
+
+        val queryState: StateFlow<String> = query.asStateFlow()
+
+        @OptIn(ExperimentalCoroutinesApi::class)
+        val uiState: StateFlow<ItemListUiState> =
+            query
+                .flatMapLatest { currentQuery ->
+                    combine(itemSearch.results(currentQuery), PendingDeltas.observe(db)) { entities, deltas ->
+                        entities.toUiState(currentQuery, deltas)
+                    }
+                }
+                .stateIn(
+                    scope = viewModelScope,
+                    started = SharingStarted.WhileSubscribed(STOP_TIMEOUT_MILLIS),
+                    initialValue = ItemListUiState.Loading,
+                )
+
+        fun onQueryChange(newQuery: String) {
+            query.value = newQuery
+        }
+    }
+
+private fun List<ItemEntity>.toUiState(currentQuery: String, deltas: Map<String, Long>): ItemListUiState = when {
+    isNotEmpty() -> ItemListUiState.Data(map { it.toRow(deltas[it.id] ?: 0L) })
+    currentQuery.isBlank() -> ItemListUiState.Empty
+    else -> ItemListUiState.NoMatches(currentQuery)
+}
+
+private const val STOP_TIMEOUT_MILLIS = 5_000L
+
+data class ItemRow(
+    val id: String,
+    val name: String,
+    val quantity: Long?,
+    val shortCode: String?,
+)
+
+private fun ItemEntity.toRow(pendingDelta: Long): ItemRow =
+    ItemRow(
+        id = id,
+        name = name,
+        quantity = if (quantity == null && pendingDelta == 0L) null else (quantity ?: 0L) + pendingDelta,
+        shortCode = shortCode,
+    )
+
+sealed interface ItemListUiState {
+    data object Loading : ItemListUiState
+
+    data object Empty : ItemListUiState
+
+    data class NoMatches(val query: String) : ItemListUiState
+
+    data class Data(val items: List<ItemRow>) : ItemListUiState
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/items/LabelEditor.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/LabelEditor.kt
new file mode 100644
index 0000000..23152cb
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/LabelEditor.kt
@@ -0,0 +1,75 @@
+package dev.hho.android.ui.items
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.AssistChip
+import androidx.compose.material3.InputChip
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+internal fun LabelEditor(
+    options: ItemEditOptions,
+    state: ItemEditState,
+    onAttach: (labelId: String) -> Unit,
+    onDetach: (labelId: String) -> Unit,
+    onDismiss: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    AlertDialog(
+        modifier = modifier,
+        onDismissRequest = onDismiss,
+        title = { Text("Edit labels") },
+        text = {
+            Column(
+                modifier = Modifier.verticalScroll(rememberScrollState()),
+                verticalArrangement = Arrangement.spacedBy(12.dp),
+            ) {
+                Text("Attached", style = MaterialTheme.typography.titleSmall)
+                if (options.attachedLabels.isEmpty()) {
+                    Text("No labels attached.", style = MaterialTheme.typography.bodySmall)
+                } else {
+                    FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                        options.attachedLabels.forEach { label ->
+                            InputChip(
+                                selected = true,
+                                onClick = { onDetach(label.id) },
+                                enabled = !state.submitting,
+                                label = { Text(label.name) },
+                                trailingIcon = { Text("x") },
+                            )
+                        }
+                    }
+                }
+                Text("Add a label", style = MaterialTheme.typography.titleSmall)
+                if (options.availableLabels.isEmpty()) {
+                    Text("No other labels available.", style = MaterialTheme.typography.bodySmall)
+                } else {
+                    FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                        options.availableLabels.forEach { label ->
+                            AssistChip(
+                                onClick = { onAttach(label.id) },
+                                enabled = !state.submitting,
+                                label = { Text("+ ${label.name}") },
+                            )
+                        }
+                    }
+                }
+                state.error?.let {
+                    Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+                }
+            }
+        },
+        confirmButton = { TextButton(onClick = onDismiss) { Text("Done") } },
+    )
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/items/LocationPicker.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/LocationPicker.kt
new file mode 100644
index 0000000..82babe1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/LocationPicker.kt
@@ -0,0 +1,104 @@
+package dev.hho.android.ui.items
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.foundation.layout.Row
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+
+internal fun filterLocations(options: List<LocationOption>, query: String): List<LocationOption> {
+    val needle = query.trim()
+    return if (needle.isEmpty()) options else options.filter { it.path.contains(needle, ignoreCase = true) }
+}
+
+@Composable
+internal fun LocationPicker(
+    options: ItemEditOptions,
+    state: ItemEditState,
+    onSelect: (locationId: String?) -> Unit,
+    onDismiss: () -> Unit,
+    modifier: Modifier = Modifier,
+    title: String = "Move to location",
+    confirmLabel: String = "Move",
+) {
+    var query by rememberSaveable { mutableStateOf("") }
+    var selected by rememberSaveable { mutableStateOf<String?>(options.currentLocationId) }
+
+    LaunchedEffect(state.completed) {
+        if (state.completed) onDismiss()
+    }
+    val visible = filterLocations(options.locations, query)
+
+    AlertDialog(
+        modifier = modifier,
+        onDismissRequest = { if (!state.submitting) onDismiss() },
+        title = { Text(title) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                OutlinedTextField(
+                    value = query,
+                    onValueChange = { query = it },
+                    label = { Text("Search locations") },
+                    singleLine = true,
+                    enabled = !state.submitting,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+                LazyColumn(modifier = Modifier.heightIn(max = 320.dp)) {
+                    item(key = "none") {
+                        LocationRow("No location", selected == null, !state.submitting) { selected = null }
+                    }
+                    items(visible, key = { it.id }) { option ->
+                        LocationRow(option.path, selected == option.id, !state.submitting) { selected = option.id }
+                    }
+                }
+                if (visible.isEmpty() && query.isNotBlank()) {
+                    Text("No locations match.", style = MaterialTheme.typography.bodySmall)
+                }
+                state.error?.let {
+                    Text(it, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+                }
+            }
+        },
+        confirmButton = {
+            TextButton(onClick = { onSelect(selected) }, enabled = !state.submitting) {
+                Text(if (state.submitting) "Saving..." else confirmLabel)
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss, enabled = !state.submitting) { Text("Cancel") }
+        },
+    )
+}
+
+@Composable
+private fun LocationRow(text: String, selected: Boolean, enabled: Boolean, onClick: () -> Unit) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(enabled = enabled, onClick = onClick)
+            .padding(vertical = 2.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        RadioButton(selected = selected, onClick = null, enabled = enabled)
+        Text(text, modifier = Modifier.padding(start = 8.dp), style = MaterialTheme.typography.bodyMedium)
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/items/StockActionsViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/StockActionsViewModel.kt
new file mode 100644
index 0000000..92b9e71
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/items/StockActionsViewModel.kt
@@ -0,0 +1,71 @@
+package dev.hho.android.ui.items
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.domain.EditError
+import dev.hho.android.domain.EditRepository
+import dev.hho.android.domain.EditResult
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+@HiltViewModel
+internal class StockActionsViewModel
+    @Inject
+    constructor(
+        private val edits: EditRepository,
+    ) : ViewModel() {
+
+        private val _state = MutableStateFlow(AdjustStockState())
+        val state: StateFlow<AdjustStockState> = _state.asStateFlow()
+
+        fun submit(itemId: String, delta: Long?, reason: String, note: String) {
+            if (_state.value.submitting) return
+            if (delta == null) {
+                _state.value = AdjustStockState(deltaError = "Enter a whole number, for example 3 or -2.")
+                return
+            }
+            _state.value = AdjustStockState(submitting = true)
+            viewModelScope.launch {
+                val result = edits.adjustStock(
+                    itemId = itemId,
+                    delta = delta,
+                    reason = reason.trim().ifEmpty { null },
+                    note = note.trim().ifEmpty { null },
+                )
+                _state.update { toState(result) }
+            }
+        }
+
+        fun reset() {
+            if (!_state.value.submitting) _state.value = AdjustStockState()
+        }
+
+        private fun toState(result: EditResult<String>): AdjustStockState =
+            when (result) {
+                is EditResult.Success -> AdjustStockState(completed = true)
+                is EditResult.Failure -> when (val error = result.error) {
+                    is EditError.Invalid ->
+                        if (error.field == "delta") {
+                            AdjustStockState(deltaError = "The change must not be zero.")
+                        } else {
+                            AdjustStockState(generalError = error.message)
+                        }
+                    is EditError.NotFound ->
+                        AdjustStockState(generalError = "This item is no longer on this device.")
+                    is EditError.StorageFailed ->
+                        AdjustStockState(generalError = "Couldn't save the change. Please try again.")
+                }
+            }
+    }
+
+data class AdjustStockState(
+    val submitting: Boolean = false,
+    val deltaError: String? = null,
+    val generalError: String? = null,
+    val completed: Boolean = false,
+)
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/login/LoginScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/login/LoginScreen.kt
new file mode 100644
index 0000000..3d3dba2
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/login/LoginScreen.kt
@@ -0,0 +1,103 @@
+package dev.hho.android.ui.login
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.text.input.PasswordVisualTransformation
+import androidx.compose.ui.unit.dp
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+
+@Composable
+fun LoginScreen(
+    onLoggedIn: () -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: LoginViewModel = hiltViewModel(),
+) {
+    val uiState by viewModel.uiState.collectAsState()
+
+    LaunchedEffect(Unit) {
+        viewModel.loggedIn.collect { onLoggedIn() }
+    }
+
+    LoginScreenContent(
+        uiState = uiState,
+        onUsernameChanged = viewModel::onUsernameChanged,
+        onPasswordChanged = viewModel::onPasswordChanged,
+        onSubmitClicked = viewModel::onSubmitClicked,
+        modifier = modifier,
+    )
+}
+
+@Composable
+private fun LoginScreenContent(
+    uiState: LoginUiState,
+    onUsernameChanged: (String) -> Unit,
+    onPasswordChanged: (String) -> Unit,
+    onSubmitClicked: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier
+            .fillMaxSize()
+            .padding(24.dp),
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        Text(
+            text = "Log in",
+            style = MaterialTheme.typography.headlineSmall,
+        )
+        OutlinedTextField(
+            value = uiState.username,
+            onValueChange = onUsernameChanged,
+            modifier = Modifier.fillMaxWidth(),
+            label = { Text("Username") },
+            singleLine = true,
+            isError = uiState.errorMessage != null,
+            enabled = !uiState.isLoading,
+        )
+        OutlinedTextField(
+            value = uiState.password,
+            onValueChange = onPasswordChanged,
+            modifier = Modifier.fillMaxWidth(),
+            label = { Text("Password") },
+            singleLine = true,
+            isError = uiState.errorMessage != null,
+            enabled = !uiState.isLoading,
+            visualTransformation = PasswordVisualTransformation(),
+            keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Password),
+        )
+        if (uiState.errorMessage != null) {
+            Text(
+                text = uiState.errorMessage,
+                color = MaterialTheme.colorScheme.error,
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+        Button(
+            onClick = onSubmitClicked,
+            enabled = !uiState.isLoading && uiState.username.isNotBlank() && uiState.password.isNotBlank(),
+        ) {
+            if (uiState.isLoading) {
+                CircularProgressIndicator(
+                    modifier = Modifier.padding(end = 8.dp),
+                    color = MaterialTheme.colorScheme.onPrimary,
+                )
+            }
+            Text(if (uiState.isLoading) "Logging in…" else "Log in")
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/login/LoginViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/login/LoginViewModel.kt
new file mode 100644
index 0000000..634e130
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/login/LoginViewModel.kt
@@ -0,0 +1,90 @@
+package dev.hho.android.ui.login
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.domain.AuthRepository
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+@HiltViewModel
+class LoginViewModel
+    @Inject
+    constructor(
+        private val authRepository: AuthRepository,
+    ) : ViewModel() {
+        private val _uiState = MutableStateFlow(LoginUiState())
+        val uiState: StateFlow<LoginUiState> = _uiState.asStateFlow()
+
+        private val _loggedIn = Channel<Unit>(Channel.BUFFERED)
+        val loggedIn: Flow<Unit> = _loggedIn.receiveAsFlow()
+
+        fun onUsernameChanged(value: String) {
+            _uiState.update { it.copy(username = value, errorMessage = null) }
+        }
+
+        fun onPasswordChanged(value: String) {
+            _uiState.update { it.copy(password = value, errorMessage = null) }
+        }
+
+        fun onSubmitClicked() {
+            val current = _uiState.value
+            if (current.isLoading) return
+            viewModelScope.launch { submit(current.username, current.password) }
+        }
+
+        internal suspend fun submit(
+            username: String,
+            password: String,
+        ) {
+            _uiState.update { it.copy(isLoading = true, errorMessage = null, password = "") }
+            authRepository.login(username, password).fold(
+                onSuccess = {
+                    _uiState.update { it.copy(isLoading = false) }
+                    _loggedIn.send(Unit)
+                },
+                onFailure = { error ->
+                    _uiState.update { it.copy(isLoading = false, errorMessage = loginErrorMessage(error)) }
+                },
+            )
+        }
+    }
+
+data class LoginUiState(
+    val username: String = "",
+    val password: String = "",
+    val isLoading: Boolean = false,
+    val errorMessage: String? = null,
+)
+
+private fun loginErrorMessage(error: Throwable): String {
+    val apiError = error as? ApiError
+        ?: return "Couldn't log in. Try again."
+    return when (apiError) {
+        is ApiError.Unauthorized ->
+            "Incorrect username or password."
+        is ApiError.Validation ->
+            if (apiError.status == 429) {
+                "Too many login attempts. Wait a moment and try again."
+            } else {
+                "That server rejected the request. Check your details and try again."
+            }
+        is ApiError.NoInstanceConfigured ->
+            "Connect to an instance first."
+        is ApiError.UpgradeRequired ->
+            "This app is too old for that server (it requires client version " +
+                "${apiError.minimumVersion} or newer). Update the app and try again."
+        is ApiError.Network ->
+            "Couldn't reach the server. Check your connection and try again."
+        is ApiError.NotFound, is ApiError.Conflict, is ApiError.Server, is ApiError.Unknown, is ApiError.UnexpectedPayload ->
+            "That server answered unexpectedly. Try again."
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/photos/PhotoCaptureScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/photos/PhotoCaptureScreen.kt
new file mode 100644
index 0000000..839f8ea
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/photos/PhotoCaptureScreen.kt
@@ -0,0 +1,70 @@
+package dev.hho.android.ui.photos
+
+import androidx.camera.view.PreviewView
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import dev.hho.android.ui.scan.CameraPermissionDenied
+import dev.hho.android.ui.scan.rememberCameraPermission
+
+@Composable
+internal fun PhotoCaptureScreen(
+    itemId: String,
+    onDone: () -> Unit,
+    onCancel: () -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: PhotoCaptureViewModel = hiltViewModel(),
+) {
+    val permission = rememberCameraPermission()
+    val state by viewModel.state.collectAsState()
+    LaunchedEffect(state.done) { if (state.done) onDone() }
+    if (!permission.granted) {
+        CameraPermissionDenied(
+            onRetry = permission.request,
+            onOpenSettings = permission.openSettings,
+            modifier = modifier,
+        )
+        TextButton(onClick = onCancel) { Text("Cancel") }
+        return
+    }
+    val context = LocalContext.current
+    val lifecycleOwner = LocalLifecycleOwner.current
+    val previewView = remember { PreviewView(context) }
+    LaunchedEffect(previewView) {
+        try {
+            viewModel.capture.bind(lifecycleOwner, previewView.surfaceProvider)
+        } catch (e: Exception) {
+            viewModel.cameraFailed()
+        }
+    }
+    Column(modifier = modifier.fillMaxSize()) {
+        TextButton(onClick = onCancel, modifier = Modifier.padding(8.dp)) { Text("Cancel") }
+        state.error?.let {
+            Text(it, modifier = Modifier.padding(16.dp), color = MaterialTheme.colorScheme.error)
+        }
+        AndroidView(factory = { previewView }, modifier = Modifier.weight(1f).fillMaxWidth())
+        Button(
+            onClick = { viewModel.shoot(itemId) },
+            enabled = !state.submitting,
+            modifier = Modifier.fillMaxWidth().padding(16.dp),
+        ) {
+            Text(if (state.submitting) "Saving..." else "Take photo")
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/photos/PhotoCaptureViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/photos/PhotoCaptureViewModel.kt
new file mode 100644
index 0000000..8c5f118
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/photos/PhotoCaptureViewModel.kt
@@ -0,0 +1,126 @@
+package dev.hho.android.ui.photos
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.photoqueue.PhotoCapture
+import dev.hho.android.data.photoqueue.PhotoQueueRepository
+import dev.hho.android.data.photoqueue.PhotoScheduler
+import dev.hho.android.data.room.PhotoQueueEntryEntity
+import dev.hho.android.data.room.PhotoState
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+internal data class PhotoCaptureUiState(
+    val submitting: Boolean = false,
+    val done: Boolean = false,
+    val error: String? = null,
+)
+
+@HiltViewModel
+internal class PhotoCaptureViewModel
+    internal constructor(
+        val capture: PhotoCapture,
+        private val queue: PhotoQueueRepository,
+        private val schedule: () -> Unit,
+    ) : ViewModel() {
+        @Inject
+        constructor(
+            capture: PhotoCapture,
+            queue: PhotoQueueRepository,
+            scheduler: PhotoScheduler,
+        ) : this(capture, queue, scheduler::schedule)
+
+        private val _state = MutableStateFlow(PhotoCaptureUiState())
+        val state: StateFlow<PhotoCaptureUiState> = _state.asStateFlow()
+
+        fun shoot(itemId: String) {
+            var claimed = false
+            _state.update {
+                claimed = !it.submitting && !it.done
+                if (claimed) it.copy(submitting = true, error = null) else it
+            }
+            if (!claimed) return
+            viewModelScope.launch {
+                var temp: java.io.File? = null
+                try {
+                    temp = capture.capture()
+                    queue.enqueue(itemId, temp)
+                    schedule()
+                    _state.update { it.copy(submitting = false, done = true) }
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (e: Exception) {
+                    _state.update {
+                        it.copy(submitting = false, error = "Couldn't save the photo. Try again.")
+                    }
+                } finally {
+                    temp?.delete()
+                }
+            }
+        }
+
+        fun cameraFailed() {
+            _state.update { it.copy(error = "The camera could not be started on this device.") }
+        }
+
+        override fun onCleared() {
+            capture.unbind()
+        }
+    }
+
+internal data class PhotoBadge(
+    val queued: Int = 0,
+    val uploading: Int = 0,
+    val failed: Int = 0,
+) {
+    fun summary(): String? {
+        val parts =
+            listOfNotNull(
+                queued.takeIf { it > 0 }?.let { "$it queued" },
+                uploading.takeIf { it > 0 }?.let { "$it uploading" },
+                failed.takeIf { it > 0 }?.let { "$it failed" },
+            )
+        return parts.takeIf { it.isNotEmpty() }?.joinToString(", ", prefix = "Photos: ")
+    }
+
+    companion object {
+        fun from(entries: List<PhotoQueueEntryEntity>) =
+            PhotoBadge(
+                queued = entries.count { it.state == PhotoState.QUEUED || it.state == PhotoState.WAITING_PARENT },
+                uploading = entries.count { it.state == PhotoState.UPLOADING },
+                failed = entries.count { it.state == PhotoState.FAILED },
+            )
+    }
+}
+
+@HiltViewModel
+internal class ItemPhotoBadgeViewModel
+    @Inject
+    constructor(
+        private val queue: PhotoQueueRepository,
+    ) : ViewModel() {
+        private val itemId = MutableStateFlow<String?>(null)
+
+        @kotlin.OptIn(kotlinx.coroutines.ExperimentalCoroutinesApi::class)
+        val badge: StateFlow<PhotoBadge> =
+            itemId
+                .flatMapLatest { id ->
+                    if (id == null) flowOf(emptyList()) else queue.observeEntriesForItem(id)
+                }.map { PhotoBadge.from(it) }
+                .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), PhotoBadge())
+
+        fun load(id: String) {
+            itemId.value = id
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/receiving/ReceivingScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/receiving/ReceivingScreen.kt
new file mode 100644
index 0000000..98621e1
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/receiving/ReceivingScreen.kt
@@ -0,0 +1,392 @@
+package dev.hho.android.ui.receiving
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.unit.dp
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import dev.hho.android.data.receiving.DiscrepancySummary
+import dev.hho.android.data.receiving.LineStatus
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ReceivingSessionEntity
+import dev.hho.android.ui.scan.CameraPermissionDenied
+import dev.hho.android.ui.scan.ScanCameraPreview
+import dev.hho.android.ui.scan.rememberCameraPermission
+
+@Composable
+internal fun ReceivingScreen(
+    onBack: () -> Unit,
+    onCheckedIn: () -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: ReceivingViewModel = hiltViewModel(),
+) {
+    DisposableEffect(viewModel) { onDispose { viewModel.showSessions() } }
+    val mode by viewModel.mode.collectAsState()
+    Column(modifier = modifier.fillMaxSize().padding(16.dp)) {
+        when (mode) {
+            ReceivingMode.Sessions -> SessionList(viewModel, onBack)
+            ReceivingMode.Header -> HeaderForm(viewModel)
+            is ReceivingMode.Session -> SessionPage(viewModel, onCheckedIn)
+        }
+    }
+}
+
+@Composable
+private fun SessionList(viewModel: ReceivingViewModel, onBack: () -> Unit) {
+    val sessions by viewModel.openSessions.collectAsState()
+    Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+        OutlinedButton(onClick = onBack) { Text("Back") }
+        Button(onClick = viewModel::newSession) { Text("New") }
+    }
+    Text("Receive delivery", style = MaterialTheme.typography.titleLarge, modifier = Modifier.padding(vertical = 12.dp))
+    if (sessions.isEmpty()) {
+        Text("No open deliveries. Tap New to start one.", style = MaterialTheme.typography.bodyMedium)
+    }
+    LazyColumn(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        items(sessions, key = { it.id }) { session ->
+            Column(
+                Modifier.fillMaxWidth().clickable { viewModel.openSession(session.id) }.padding(vertical = 8.dp),
+            ) {
+                Text(session.vendor, style = MaterialTheme.typography.titleMedium)
+                Text(session.subtitle(), style = MaterialTheme.typography.bodySmall)
+            }
+        }
+    }
+}
+
+private fun ReceivingSessionEntity.subtitle(): String =
+    listOfNotNull(orderReference, purchasedOn?.toString()).joinToString(" - ").ifEmpty { "No order reference" }
+
+@Composable
+private fun HeaderForm(viewModel: ReceivingViewModel) {
+    val state by viewModel.header.collectAsState()
+    var vendor by rememberSaveable { mutableStateOf("") }
+    var order by rememberSaveable { mutableStateOf("") }
+    var date by rememberSaveable { mutableStateOf("") }
+    Text("New delivery", style = MaterialTheme.typography.titleLarge)
+    Column(verticalArrangement = Arrangement.spacedBy(12.dp), modifier = Modifier.padding(top = 12.dp)) {
+        OutlinedTextField(
+            value = vendor,
+            onValueChange = { vendor = it },
+            label = { Text("Vendor (required)") },
+            isError = state.vendorError != null,
+            supportingText = state.vendorError?.let { { Text(it) } },
+            singleLine = true,
+            modifier = Modifier.fillMaxWidth(),
+        )
+        OutlinedTextField(
+            value = order,
+            onValueChange = { order = it },
+            label = { Text("Order reference") },
+            singleLine = true,
+            modifier = Modifier.fillMaxWidth(),
+        )
+        OutlinedTextField(
+            value = date,
+            onValueChange = { date = it },
+            label = { Text("Purchased on (YYYY-MM-DD)") },
+            isError = state.dateError != null,
+            supportingText = state.dateError?.let { { Text(it) } },
+            singleLine = true,
+            keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
+            modifier = Modifier.fillMaxWidth(),
+        )
+        Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+            OutlinedButton(onClick = viewModel::showSessions) { Text("Cancel") }
+            Button(
+                onClick = { viewModel.createSession(vendor, order, date) },
+                enabled = !state.submitting,
+            ) { Text("Start receiving") }
+        }
+    }
+}
+
+@Composable
+private fun ColumnScope.SessionPage(viewModel: ReceivingViewModel, onCheckedIn: () -> Unit) {
+    val state = viewModel.session.collectAsState().value
+    if (state == null) {
+        Text("This delivery is no longer available.")
+        OutlinedButton(onClick = viewModel::showSessions) { Text("Back") }
+        return
+    }
+    val latestOnCheckedIn by rememberUpdatedState(onCheckedIn)
+    LaunchedEffect(state.checkedIn) { if (state.checkedIn) latestOnCheckedIn() }
+    var editing by rememberSaveable { mutableStateOf<String?>(null) }
+    val camera = rememberCameraPermission()
+
+    Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+        OutlinedButton(onClick = viewModel::showSessions) { Text("Back") }
+        if (state.isOpen) {
+            Button(onClick = viewModel::openPicker) { Text("Add expected") }
+            if (state.scanning) {
+                OutlinedButton(onClick = { viewModel.setScanning(false) }) { Text("Stop scan") }
+            } else {
+                Button(onClick = { viewModel.setScanning(true) }) { Text("Scan") }
+            }
+        }
+    }
+    Text(state.session.vendor, style = MaterialTheme.typography.titleLarge, modifier = Modifier.padding(top = 8.dp))
+    Text(state.session.subtitle() + " - " + state.session.status.lowercase(), style = MaterialTheme.typography.bodySmall)
+    SummaryBlock(state.summary)
+    if (state.isOpen && state.scanning) {
+        if (camera.granted) {
+            ScanCameraPreview(
+                isPaused = { viewModel.paused },
+                onBarcodes = viewModel::onBarcodes,
+                modifier = Modifier.fillMaxWidth().height(220.dp),
+            )
+        } else {
+            CameraPermissionDenied(onRetry = camera.request, onOpenSettings = camera.openSettings)
+        }
+    }
+    state.message?.let { Text(it, style = MaterialTheme.typography.bodyMedium, modifier = Modifier.padding(vertical = 4.dp)) }
+    state.checkInError?.let {
+        Text(it, color = MaterialTheme.colorScheme.error, modifier = Modifier.padding(vertical = 4.dp))
+    }
+    LazyColumn(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        items(state.lines, key = { it.itemId }) { line ->
+            LineRow(
+                line = line,
+                editable = state.isOpen,
+                onIncrement = { viewModel.increment(line.itemId) },
+                onDecrement = { viewModel.decrement(line.itemId) },
+                onEdit = { editing = line.itemId },
+            )
+        }
+    }
+    if (state.isOpen) {
+        Row(horizontalArrangement = Arrangement.spacedBy(12.dp), modifier = Modifier.navigationBarsPadding()) {
+            Button(onClick = viewModel::requestCheckIn, enabled = !state.submitting) { Text("Check in") }
+            OutlinedButton(onClick = viewModel::requestCancel) { Text("Cancel session") }
+        }
+    }
+
+    if (state.pickerOpen) ItemPicker(viewModel, state)
+    editing?.let { id ->
+        state.lines.firstOrNull { it.itemId == id }?.let { line ->
+            EditLineDialog(
+                line = line,
+                onSave = { received, expected ->
+                    received?.let { viewModel.setReceived(id, it) }
+                    if (expected != null && line.discrepancy.expectedQty != null) viewModel.setExpected(id, expected)
+                    editing = null
+                },
+                onDismiss = { editing = null },
+            )
+        }
+    }
+    state.pendingUnexpected?.let { pending ->
+        AlertDialog(
+            onDismissRequest = viewModel::dismissUnexpected,
+            title = { Text("Add ${pending.name} as unexpected?") },
+            text = { Text("It is not on this delivery's expected list. It will be counted and checked in anyway.") },
+            confirmButton = { Button(onClick = viewModel::confirmUnexpected) { Text("Add") } },
+            dismissButton = { TextButton(onClick = viewModel::dismissUnexpected) { Text("Skip") } },
+        )
+    }
+    state.choices?.let { choices ->
+        AlertDialog(
+            onDismissRequest = viewModel::dismissChoices,
+            title = { Text("${choices.size} items match") },
+            text = {
+                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                    choices.forEach { item ->
+                        OutlinedButton(onClick = { viewModel.choose(item.id) }, modifier = Modifier.fillMaxWidth()) {
+                            Text(item.name)
+                        }
+                    }
+                }
+            },
+            confirmButton = {},
+            dismissButton = { TextButton(onClick = viewModel::dismissChoices) { Text("Keep scanning") } },
+        )
+    }
+    if (state.confirmingCheckIn) {
+        AlertDialog(
+            onDismissRequest = viewModel::dismissCheckIn,
+            title = { Text("Check in this delivery?") },
+            text = {
+                Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                    SummaryBlock(state.summary)
+                    Text(
+                        if (state.summary.totalReceived == 0) {
+                            "Nothing has been counted yet."
+                        } else {
+                            "Counted quantities are added to stock and the vendor is recorded on each item."
+                        },
+                        style = MaterialTheme.typography.bodySmall,
+                    )
+                }
+            },
+            confirmButton = {
+                Button(onClick = viewModel::confirmCheckIn, enabled = !state.submitting && state.summary.totalReceived > 0) {
+                    Text("Check in")
+                }
+            },
+            dismissButton = { TextButton(onClick = viewModel::dismissCheckIn) { Text("Keep counting") } },
+        )
+    }
+    if (state.confirmingCancel) {
+        AlertDialog(
+            onDismissRequest = viewModel::dismissCancel,
+            title = { Text("Cancel this session?") },
+            text = { Text("Nothing is added to stock. The counts stay on this device but the delivery closes.") },
+            confirmButton = { Button(onClick = viewModel::confirmCancel) { Text("Cancel session") } },
+            dismissButton = { TextButton(onClick = viewModel::dismissCancel) { Text("Keep") } },
+        )
+    }
+}
+
+@Composable
+private fun SummaryBlock(summary: DiscrepancySummary) {
+    Column(Modifier.padding(vertical = 8.dp)) {
+        Text(
+            "Received ${summary.totalReceived} of ${summary.totalExpected} expected",
+            style = MaterialTheme.typography.titleSmall,
+        )
+        Text(
+            "Matched ${summary.matchedCount}  Short ${summary.shortLines.size}  " +
+                "Over ${summary.overLines.size}  Unexpected ${summary.unexpectedLines.size}",
+            style = MaterialTheme.typography.bodySmall,
+        )
+    }
+}
+
+@Composable
+private fun LineRow(
+    line: ReceivingLineUi,
+    editable: Boolean,
+    onIncrement: () -> Unit,
+    onDecrement: () -> Unit,
+    onEdit: () -> Unit,
+) {
+    val d = line.discrepancy
+    Column(Modifier.fillMaxWidth()) {
+        Text(line.name, style = MaterialTheme.typography.titleMedium)
+        Text(
+            "Expected ${d.expectedQty ?: "-"} / received ${d.receivedQty} (${d.status.label()})",
+            style = MaterialTheme.typography.bodySmall,
+        )
+        if (editable) {
+            Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+                OutlinedButton(onClick = onDecrement, enabled = d.receivedQty > 0) { Text("-1") }
+                OutlinedButton(onClick = onIncrement) { Text("+1") }
+                TextButton(onClick = onEdit) { Text("Edit") }
+            }
+        }
+    }
+}
+
+private fun LineStatus.label(): String =
+    when (this) {
+        LineStatus.MATCHED -> "matched"
+        LineStatus.SHORT -> "short"
+        LineStatus.OVER -> "over"
+        LineStatus.UNEXPECTED -> "unexpected"
+    }
+
+@Composable
+private fun EditLineDialog(
+    line: ReceivingLineUi,
+    onSave: (received: Int?, expected: Int?) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    var received by remember { mutableStateOf(line.discrepancy.receivedQty.toString()) }
+    var expected by remember { mutableStateOf(line.discrepancy.expectedQty?.toString().orEmpty()) }
+    val receivedValue = received.trim().toIntOrNull()?.takeIf { it >= 0 }
+    val expectedValue = expected.trim().toIntOrNull()?.takeIf { it >= 1 }
+    val hasExpected = line.discrepancy.expectedQty != null
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(line.name) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                OutlinedTextField(
+                    value = received,
+                    onValueChange = { received = it },
+                    label = { Text("Received") },
+                    isError = receivedValue == null,
+                    singleLine = true,
+                    keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
+                )
+                if (hasExpected) {
+                    OutlinedTextField(
+                        value = expected,
+                        onValueChange = { expected = it },
+                        label = { Text("Expected") },
+                        isError = expectedValue == null,
+                        singleLine = true,
+                        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number),
+                    )
+                }
+            }
+        },
+        confirmButton = {
+            Button(
+                onClick = { onSave(receivedValue, expectedValue) },
+                enabled = receivedValue != null && (!hasExpected || expectedValue != null),
+            ) { Text("Save") }
+        },
+        dismissButton = { TextButton(onClick = onDismiss) { Text("Cancel") } },
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun ItemPicker(viewModel: ReceivingViewModel, state: ReceivingSessionUiState) {
+    val query by viewModel.query.collectAsState()
+    val results by viewModel.pickerResults.collectAsState()
+    ModalBottomSheet(onDismissRequest = viewModel::closePicker) {
+        Column(Modifier.fillMaxWidth().navigationBarsPadding().padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            OutlinedTextField(
+                value = query,
+                onValueChange = viewModel::setQuery,
+                label = { Text("Search items") },
+                singleLine = true,
+                modifier = Modifier.fillMaxWidth(),
+            )
+            state.message?.let { Text(it, style = MaterialTheme.typography.bodySmall) }
+            LazyColumn(Modifier.height(320.dp)) {
+                items(results, key = ItemEntity::id) { item ->
+                    val expected = state.lines.firstOrNull { it.itemId == item.id }?.discrepancy?.expectedQty
+                    Column(Modifier.fillMaxWidth().clickable { viewModel.addExpected(item) }.padding(vertical = 8.dp)) {
+                        Text(item.name, style = MaterialTheme.typography.titleMedium)
+                        if (expected != null) Text("Expected: $expected", style = MaterialTheme.typography.bodySmall)
+                    }
+                }
+            }
+            Button(onClick = viewModel::closePicker, modifier = Modifier.fillMaxWidth()) { Text("Done") }
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/receiving/ReceivingViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/receiving/ReceivingViewModel.kt
new file mode 100644
index 0000000..71ab41a
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/receiving/ReceivingViewModel.kt
@@ -0,0 +1,397 @@
+package dev.hho.android.ui.receiving
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.items.ItemSearch
+import dev.hho.android.data.receiving.DiscrepancySummary
+import dev.hho.android.data.receiving.LineDiscrepancy
+import dev.hho.android.data.receiving.ReceivingException
+import dev.hho.android.data.receiving.ReceivingRepository
+import dev.hho.android.data.receiving.ScanOutcome
+import dev.hho.android.data.receiving.toDiscrepancy
+import dev.hho.android.data.room.ItemDao
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ReceivingSessionEntity
+import dev.hho.android.data.room.ReceivingStatus
+import dev.hho.android.data.scanner.DecodedBarcode
+import dev.hho.android.domain.CheckInResult
+import dev.hho.android.domain.EditError
+import dev.hho.android.domain.ReceivingCheckIn
+import dev.hho.android.ui.scan.ScanResolution
+import dev.hho.android.ui.scan.ScanResolver
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import java.time.LocalDate
+import java.time.format.DateTimeParseException
+import javax.inject.Inject
+
+internal sealed interface ReceivingMode {
+    data object Sessions : ReceivingMode
+
+    data object Header : ReceivingMode
+
+    data class Session(val id: String) : ReceivingMode
+}
+
+internal data class HeaderState(
+    val vendorError: String? = null,
+    val dateError: String? = null,
+    val submitting: Boolean = false,
+)
+
+internal data class PendingItem(val itemId: String, val name: String)
+
+internal data class ReceivingLineUi(val name: String, val discrepancy: LineDiscrepancy) {
+    val itemId: String get() = discrepancy.itemId
+}
+
+internal data class ReceivingSessionUiState(
+    val session: ReceivingSessionEntity,
+    val lines: List<ReceivingLineUi>,
+    val summary: DiscrepancySummary,
+    val scanning: Boolean = false,
+    val pickerOpen: Boolean = false,
+    val pendingUnexpected: PendingItem? = null,
+    val choices: List<ItemEntity>? = null,
+    val confirmingCheckIn: Boolean = false,
+    val confirmingCancel: Boolean = false,
+    val submitting: Boolean = false,
+    val message: String? = null,
+    val checkInError: String? = null,
+    val checkedIn: Boolean = false,
+) {
+    val isOpen: Boolean get() = session.status == ReceivingStatus.OPEN
+}
+
+private data class Transient(
+    val message: String? = null,
+    val scanning: Boolean = false,
+    val pickerOpen: Boolean = false,
+    val pendingUnexpected: PendingItem? = null,
+    val choices: List<ItemEntity>? = null,
+    val confirmingCheckIn: Boolean = false,
+    val confirmingCancel: Boolean = false,
+    val submitting: Boolean = false,
+    val checkInError: String? = null,
+    val checkedIn: Boolean = false,
+)
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@HiltViewModel
+internal class ReceivingViewModel
+    @Inject
+    constructor(
+        private val repo: ReceivingRepository,
+        private val checkIn: ReceivingCheckIn,
+        private val resolver: ScanResolver,
+        private val itemSearch: ItemSearch,
+        private val itemDao: ItemDao,
+    ) : ViewModel() {
+        internal var nowMillis: () -> Long = System::currentTimeMillis
+
+        private val _mode = MutableStateFlow<ReceivingMode>(ReceivingMode.Sessions)
+        val mode: StateFlow<ReceivingMode> = _mode.asStateFlow()
+
+        private val _header = MutableStateFlow(HeaderState())
+        val header: StateFlow<HeaderState> = _header.asStateFlow()
+
+        private val transient = MutableStateFlow(Transient())
+
+        val openSessions: StateFlow<List<ReceivingSessionEntity>> =
+            repo.observeOpenSessions().stateIn(viewModelScope, SharingStarted.Eagerly, emptyList())
+
+        val session: StateFlow<ReceivingSessionUiState?> =
+            _mode.flatMapLatest { mode ->
+                if (mode is ReceivingMode.Session) sessionFlow(mode.id) else flowOf(null)
+            }.stateIn(viewModelScope, SharingStarted.Eagerly, null)
+
+        private val _query = MutableStateFlow("")
+        val query: StateFlow<String> = _query.asStateFlow()
+
+        val pickerResults: StateFlow<List<ItemEntity>> =
+            _query.flatMapLatest { itemSearch.results(it) }
+                .map { it.take(PICKER_LIMIT) }
+                .stateIn(viewModelScope, SharingStarted.Eagerly, emptyList())
+
+        @Volatile private var resolving = false
+        @Volatile private var lastSeenValue: String? = null
+        private var lastSeenAt = 0L
+
+        private val sessionId: String? get() = (_mode.value as? ReceivingMode.Session)?.id
+
+        private fun sessionFlow(id: String) =
+            combine(repo.observeSession(id), repo.observeLines(id), transient) { session, lines, t ->
+                session?.let {
+                    val named = lines.map { line ->
+                        ReceivingLineUi(itemDao.getById(line.itemId)?.name ?: line.itemId, line.toDiscrepancy())
+                    }
+                    ReceivingSessionUiState(
+                        session = it,
+                        lines = named,
+                        summary = DiscrepancySummary(named.map { l -> l.discrepancy }),
+                        scanning = t.scanning,
+                        pickerOpen = t.pickerOpen,
+                        pendingUnexpected = t.pendingUnexpected,
+                        choices = t.choices,
+                        confirmingCheckIn = t.confirmingCheckIn,
+                        confirmingCancel = t.confirmingCancel,
+                        submitting = t.submitting,
+                        message = t.message,
+                        checkInError = t.checkInError,
+                        checkedIn = t.checkedIn,
+                    )
+                }
+            }
+
+        val paused: Boolean
+            get() = resolving || transient.value.let {
+                !it.scanning || it.pendingUnexpected != null || it.choices != null || it.pickerOpen ||
+                    it.confirmingCheckIn || it.confirmingCancel || it.submitting
+            }
+
+        fun showSessions() {
+            resetScan()
+            transient.value = Transient()
+            _header.value = HeaderState()
+            _query.value = ""
+            _mode.value = ReceivingMode.Sessions
+        }
+
+        fun newSession() {
+            _header.value = HeaderState()
+            _mode.value = ReceivingMode.Header
+        }
+
+        fun openSession(id: String) {
+            resetScan()
+            transient.value = Transient()
+            _query.value = ""
+            _mode.value = ReceivingMode.Session(id)
+        }
+
+        fun createSession(vendor: String, orderReference: String, purchasedOn: String) {
+            if (_header.value.submitting) return
+            val vendorError = if (vendor.isBlank()) "Enter the vendor." else null
+            var date: LocalDate? = null
+            var dateError: String? = null
+            if (purchasedOn.isNotBlank()) {
+                try {
+                    date = LocalDate.parse(purchasedOn.trim())
+                } catch (e: DateTimeParseException) {
+                    dateError = "Use the format YYYY-MM-DD, for example 2026-03-04."
+                }
+            }
+            if (vendorError != null || dateError != null) {
+                _header.value = HeaderState(vendorError = vendorError, dateError = dateError)
+                return
+            }
+            _header.value = HeaderState(submitting = true)
+            viewModelScope.launch {
+                try {
+                    val created = repo.startSession(vendor, orderReference.ifBlank { null }, date)
+                    _header.value = HeaderState()
+                    openSession(created.id)
+                } catch (e: ReceivingException) {
+                    _header.value = HeaderState(vendorError = e.message)
+                }
+            }
+        }
+
+        fun setQuery(query: String) {
+            _query.value = query
+        }
+
+        fun openPicker() = transient.update { it.copy(pickerOpen = true, message = null) }
+
+        fun closePicker() {
+            _query.value = ""
+            transient.update { it.copy(pickerOpen = false) }
+        }
+
+        fun addExpected(item: ItemEntity) {
+            val id = sessionId ?: return
+            val existing = session.value?.lines?.firstOrNull { it.itemId == item.id }
+            if (existing?.discrepancy?.expectedQty != null) {
+                say("${item.name} is already on the expected list.")
+                return
+            }
+            guarded {
+                repo.addExpected(id, item.id, 1)
+                say("Added ${item.name}.")
+            }
+        }
+
+        fun setReceived(itemId: String, quantity: Int) {
+            val id = sessionId ?: return
+            guarded { repo.setReceived(id, itemId, quantity) }
+        }
+
+        fun setExpected(itemId: String, quantity: Int) {
+            val id = sessionId ?: return
+            guarded { repo.addExpected(id, itemId, quantity) }
+        }
+
+        fun increment(itemId: String) = adjustReceived(itemId, +1)
+
+        fun decrement(itemId: String) = adjustReceived(itemId, -1)
+
+        private fun adjustReceived(itemId: String, by: Int) {
+            val id = sessionId ?: return
+            guarded { repo.adjustReceived(id, itemId, by) }
+        }
+
+        fun setScanning(on: Boolean) {
+            if (!on) resetScan()
+            transient.update { it.copy(scanning = on, message = null) }
+        }
+
+        fun onBarcodes(barcodes: List<DecodedBarcode>) {
+            val value = barcodes.firstOrNull()?.value ?: return
+            val id = sessionId ?: return
+            if (paused) return
+            val now = nowMillis()
+            val repeat = value == lastSeenValue && now - lastSeenAt < REPEAT_SUPPRESSION_MILLIS
+            lastSeenValue = value
+            lastSeenAt = now
+            if (repeat) return
+            resolving = true
+            viewModelScope.launch {
+                try {
+                    when (val resolution = resolver.resolve(value)) {
+                        is ScanResolution.Single -> record(id, resolution.item)
+                        is ScanResolution.Multiple -> transient.update { it.copy(choices = resolution.items) }
+                        is ScanResolution.NoMatch -> say("No item found for ${resolution.value}.")
+                    }
+                } finally {
+                    resolving = false
+                }
+            }
+        }
+
+        fun choose(itemId: String) {
+            val id = sessionId ?: return
+            val item = transient.value.choices?.firstOrNull { it.id == itemId } ?: return
+            transient.update { it.copy(choices = null) }
+            viewModelScope.launch { record(id, item) }
+        }
+
+        fun dismissChoices() {
+            lastSeenAt = nowMillis()
+            transient.update { it.copy(choices = null) }
+        }
+
+        fun confirmUnexpected() {
+            val id = sessionId ?: return
+            val pending = transient.value.pendingUnexpected ?: return
+            transient.update { it.copy(pendingUnexpected = null) }
+            guarded {
+                repo.confirmUnexpected(id, pending.itemId)
+                say("Added ${pending.name} as unexpected.")
+            }
+        }
+
+        fun dismissUnexpected() {
+            lastSeenAt = nowMillis()
+            transient.update { it.copy(pendingUnexpected = null) }
+        }
+
+        private suspend fun record(sessionId: String, item: ItemEntity) {
+            try {
+                when (val outcome = repo.recordScan(sessionId, item.id)) {
+                    is ScanOutcome.Counted ->
+                        say("Counted ${item.name}: ${outcome.line.receivedQty} received.")
+                    is ScanOutcome.Unexpected ->
+                        transient.update { it.copy(pendingUnexpected = PendingItem(item.id, item.name)) }
+                }
+            } catch (e: ReceivingException) {
+                say(e.message ?: "Could not record the scan.")
+            }
+        }
+
+        private fun resetScan() {
+            lastSeenValue = null
+            lastSeenAt = 0L
+        }
+
+        fun requestCheckIn() = transient.update { it.copy(confirmingCheckIn = true, checkInError = null) }
+
+        fun dismissCheckIn() = transient.update { if (it.submitting) it else it.copy(confirmingCheckIn = false) }
+
+        fun confirmCheckIn() {
+            val id = sessionId ?: return
+            var started = false
+            transient.update {
+                started = !it.submitting
+                if (started) it.copy(submitting = true, checkInError = null) else it
+            }
+            if (!started) return
+            viewModelScope.launch {
+                var ok = false
+                val error: String? = try {
+                    when (val result = checkIn.checkIn(id)) {
+                        is CheckInResult.Completed -> { ok = true; null }
+                        is CheckInResult.AlreadyCompleted -> "This delivery was already checked in."
+                        is CheckInResult.Failed ->
+                            "Check-in failed and nothing was changed: ${describe(result.error)} " +
+                                "Fix the lines and try again."
+                    }
+                } catch (e: ReceivingException) {
+                    e.message ?: "Check-in was refused."
+                }
+                transient.update {
+                    it.copy(submitting = false, confirmingCheckIn = false, checkedIn = ok, checkInError = error)
+                }
+            }
+        }
+
+        private fun describe(error: EditError): String =
+            when (error) {
+                is EditError.Invalid -> error.message
+                is EditError.NotFound -> "an item is no longer on this device."
+                is EditError.StorageFailed -> "the device could not save the change."
+            }
+
+        fun requestCancel() = transient.update { it.copy(confirmingCancel = true) }
+
+        fun dismissCancel() = transient.update { it.copy(confirmingCancel = false) }
+
+        fun confirmCancel() {
+            val id = sessionId ?: return
+            viewModelScope.launch {
+                try {
+                    repo.cancel(id)
+                    showSessions()
+                } catch (e: ReceivingException) {
+                    transient.update { it.copy(confirmingCancel = false, message = e.message) }
+                }
+            }
+        }
+
+        private fun say(message: String) = transient.update { it.copy(message = message) }
+
+        private fun guarded(block: suspend () -> Unit) {
+            viewModelScope.launch {
+                try {
+                    block()
+                } catch (e: ReceivingException) {
+                    say(e.message ?: "The change was refused.")
+                }
+            }
+        }
+
+        companion object {
+            const val REPEAT_SUPPRESSION_MILLIS = 3_000L
+            const val PICKER_LIMIT = 50
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/PausableBarcodeScanner.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/PausableBarcodeScanner.kt
new file mode 100644
index 0000000..023b639
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/PausableBarcodeScanner.kt
@@ -0,0 +1,15 @@
+package dev.hho.android.ui.scan
+
+import androidx.camera.core.ImageProxy
+import dev.hho.android.data.scanner.BarcodeScanner
+import dev.hho.android.data.scanner.DecodedBarcode
+
+class PausableBarcodeScanner(
+    private val delegate: BarcodeScanner,
+    private val isPaused: () -> Boolean,
+) : BarcodeScanner {
+    override suspend fun scan(imageProxy: ImageProxy): List<DecodedBarcode> =
+        if (isPaused()) emptyList() else delegate.scan(imageProxy)
+
+    override fun close() = Unit
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/ScanCamera.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/ScanCamera.kt
new file mode 100644
index 0000000..d18d44d
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/ScanCamera.kt
@@ -0,0 +1,131 @@
+package dev.hho.android.ui.scan
+
+import android.Manifest
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.provider.Settings
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.camera.view.PreviewView
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.content.ContextCompat
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.scanner.BarcodeCameraSession
+import dev.hho.android.data.scanner.BarcodeScanner
+import dev.hho.android.data.scanner.DecodedBarcode
+import javax.inject.Inject
+
+@HiltViewModel
+class ScanCameraViewModel
+    @Inject
+    constructor(
+        val session: BarcodeCameraSession,
+        val scanner: BarcodeScanner,
+    ) : ViewModel()
+
+internal class CameraPermission(
+    val granted: Boolean,
+    val request: () -> Unit,
+    val openSettings: () -> Unit,
+)
+
+@Composable
+internal fun rememberCameraPermission(): CameraPermission {
+    val context = LocalContext.current
+    var granted by remember { mutableStateOf(context.hasCameraPermission()) }
+    val launcher =
+        rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { granted = it }
+    LaunchedEffect(Unit) { if (!granted) launcher.launch(Manifest.permission.CAMERA) }
+    return CameraPermission(
+        granted = granted,
+        request = { launcher.launch(Manifest.permission.CAMERA) },
+        openSettings = { context.openAppSettings() },
+    )
+}
+
+@Composable
+internal fun ScanCameraPreview(
+    isPaused: () -> Boolean,
+    onBarcodes: (List<DecodedBarcode>) -> Unit,
+    modifier: Modifier = Modifier,
+    cameraViewModel: ScanCameraViewModel = hiltViewModel(),
+) {
+    val context = LocalContext.current
+    val lifecycleOwner = LocalLifecycleOwner.current
+    val scope = rememberCoroutineScope()
+    val previewView = remember { PreviewView(context) }
+    var cameraError by remember { mutableStateOf<String?>(null) }
+    DisposableEffect(lifecycleOwner) { onDispose { cameraViewModel.session.stop() } }
+    LaunchedEffect(previewView) {
+        try {
+            cameraViewModel.session.start(
+                lifecycleOwner = lifecycleOwner,
+                scanner = PausableBarcodeScanner(cameraViewModel.scanner, isPaused),
+                analyzerScope = scope,
+                previewSurfaceProvider = previewView.surfaceProvider,
+                onBarcodesDetected = onBarcodes,
+                onScanError = { cameraError = "Scanning hit a problem; point the camera at the code again." },
+            )
+        } catch (failure: Exception) {
+            cameraError = "The camera could not be started on this device."
+        }
+    }
+    Column(modifier = modifier) {
+        cameraError?.let { Text(it, modifier = Modifier.padding(16.dp), color = MaterialTheme.colorScheme.error) }
+        AndroidView(factory = { previewView }, modifier = Modifier.fillMaxSize())
+    }
+}
+
+@Composable
+internal fun CameraPermissionDenied(
+    onRetry: () -> Unit,
+    onOpenSettings: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier.padding(24.dp),
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+    ) {
+        Text(
+            text = "Camera access is needed to scan barcodes and QR labels. Nothing is recorded or " +
+                "uploaded; frames are decoded on this device. You can still find items with search.",
+            style = MaterialTheme.typography.bodyMedium,
+        )
+        Button(onClick = onRetry) { Text("Grant camera access") }
+        OutlinedButton(onClick = onOpenSettings) { Text("Open app settings") }
+    }
+}
+
+private fun Context.hasCameraPermission(): Boolean =
+    ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
+
+private fun Context.openAppSettings() {
+    startActivity(
+        Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.fromParts("package", packageName, null))
+            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK),
+    )
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/ScanResolver.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/ScanResolver.kt
new file mode 100644
index 0000000..48f8e69
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/ScanResolver.kt
@@ -0,0 +1,43 @@
+package dev.hho.android.ui.scan
+
+import dev.hho.android.data.items.ItemSearch
+import dev.hho.android.data.room.ItemDao
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.ui.deeplink.DeepLinkResolution
+import dev.hho.android.ui.deeplink.DeepLinkResolver
+import dev.hho.android.ui.deeplink.parseItemDeepLink
+import javax.inject.Inject
+
+sealed interface ScanResolution {
+    data class Single(val item: ItemEntity) : ScanResolution
+
+    data class Multiple(val items: List<ItemEntity>) : ScanResolution
+
+    data class NoMatch(val value: String) : ScanResolution
+}
+
+class ScanResolver
+    @Inject
+    constructor(
+        private val deepLinks: DeepLinkResolver,
+        private val itemSearch: ItemSearch,
+        private val itemDao: ItemDao,
+    ) {
+        suspend fun resolve(value: String): ScanResolution {
+            val link = parseItemDeepLink(value)
+            val matches =
+                if (link != null) {
+                    when (val resolution = deepLinks.resolve(link)) {
+                        is DeepLinkResolution.Found -> listOfNotNull(itemDao.getById(resolution.itemId))
+                        is DeepLinkResolution.NotFound -> emptyList()
+                    }
+                } else {
+                    itemSearch.findByIdentifierValue(value)
+                }
+            return when (matches.size) {
+                0 -> ScanResolution.NoMatch(value)
+                1 -> ScanResolution.Single(matches.single())
+                else -> ScanResolution.Multiple(matches)
+            }
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/ScanScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/ScanScreen.kt
new file mode 100644
index 0000000..0f6bb3e
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/ScanScreen.kt
@@ -0,0 +1,150 @@
+package dev.hho.android.ui.scan
+
+import androidx.camera.view.PreviewView
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+import dev.hho.android.ui.items.AdjustStockDialog
+import dev.hho.android.ui.items.StockActionsViewModel
+
+@Composable
+internal fun ScanScreen(
+    onViewItem: (String) -> Unit,
+    onCreateItem: (prefillKind: String, prefillValue: String) -> Unit,
+    onBack: () -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: ScanViewModel = hiltViewModel(),
+    cameraViewModel: ScanCameraViewModel = hiltViewModel(),
+    stockViewModel: StockActionsViewModel = hiltViewModel(),
+) {
+    val camera = rememberCameraPermission()
+
+    val state by viewModel.uiState.collectAsState()
+    val stockState by stockViewModel.state.collectAsState()
+    var adjustingItemId by rememberSaveable { mutableStateOf<String?>(null) }
+    val latestOnCreateItem by rememberUpdatedState(onCreateItem)
+    LaunchedEffect(viewModel) {
+        viewModel.events.collect { event ->
+            when (event) {
+                is ScanEvent.CreateItem ->
+                    latestOnCreateItem(event.prefillIdentifierKind, event.prefillIdentifierValue)
+            }
+        }
+    }
+    Column(modifier = modifier.fillMaxSize()) {
+        OutlinedButton(onClick = onBack, modifier = Modifier.padding(8.dp)) { Text("Back") }
+        if (camera.granted) {
+            ScanCameraPreview(
+                isPaused = { viewModel.paused },
+                onBarcodes = viewModel::onBarcodes,
+                modifier = Modifier.fillMaxSize(),
+                cameraViewModel = cameraViewModel,
+            )
+        } else {
+            CameraPermissionDenied(
+                onRetry = camera.request,
+                onOpenSettings = camera.openSettings,
+                modifier = Modifier.fillMaxSize(),
+            )
+        }
+    }
+    (state as? ScanUiState.Sheet)?.let { sheet ->
+        ScanActionSheet(
+            sheet = sheet,
+            onViewItem = { id ->
+                viewModel.dismissSheet()
+                onViewItem(id)
+            },
+            onAdjust = { id ->
+                stockViewModel.reset()
+                adjustingItemId = id
+            },
+            onCreate = viewModel::createItem,
+            onChoose = viewModel::choose,
+            onDismiss = viewModel::dismissSheet,
+        )
+    }
+    adjustingItemId?.let { id ->
+        AdjustStockDialog(
+            state = stockState,
+            onSubmit = { delta, reason, note -> stockViewModel.submit(id, delta, reason, note) },
+            onDismiss = {
+                val saved = stockState.completed
+                adjustingItemId = null
+                stockViewModel.reset()
+                if (saved) viewModel.dismissSheet()
+            },
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun ScanActionSheet(
+    sheet: ScanUiState.Sheet,
+    onViewItem: (String) -> Unit,
+    onAdjust: (String) -> Unit,
+    onCreate: () -> Unit,
+    onChoose: (String) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    ModalBottomSheet(onDismissRequest = onDismiss) {
+        Column(
+            modifier = Modifier.fillMaxWidth().navigationBarsPadding().padding(24.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            when (val resolution = sheet.resolution) {
+                is ScanResolution.Single -> {
+                    Text(resolution.item.name, style = MaterialTheme.typography.titleMedium)
+                    Button(onClick = { onViewItem(resolution.item.id) }, modifier = Modifier.fillMaxWidth()) {
+                        Text("View item")
+                    }
+                    OutlinedButton(onClick = { onAdjust(resolution.item.id) }, modifier = Modifier.fillMaxWidth()) {
+                        Text("Adjust quantity")
+                    }
+                }
+                is ScanResolution.Multiple -> {
+                    Text("${resolution.items.size} items match ${sheet.value}", style = MaterialTheme.typography.titleMedium)
+                    resolution.items.forEach { item ->
+                        OutlinedButton(onClick = { onChoose(item.id) }, modifier = Modifier.fillMaxWidth()) {
+                            Text(item.name)
+                        }
+                    }
+                }
+                is ScanResolution.NoMatch -> {
+                    Text("No item found for ${resolution.value}", style = MaterialTheme.typography.titleMedium)
+                    if (resolution.canCreate) {
+                        Button(onClick = onCreate, modifier = Modifier.fillMaxWidth()) { Text("Create item") }
+                    } else {
+                        Text(
+                            "This looks like an HHO label for an item that is not on this device yet. " +
+                                "Sync, then scan again.",
+                            style = MaterialTheme.typography.bodySmall,
+                        )
+                    }
+                }
+            }
+            OutlinedButton(onClick = onDismiss, modifier = Modifier.fillMaxWidth()) { Text("Keep scanning") }
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/ScanViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/ScanViewModel.kt
new file mode 100644
index 0000000..ca03ac3
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/scan/ScanViewModel.kt
@@ -0,0 +1,96 @@
+package dev.hho.android.ui.scan
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.scanner.DecodedBarcode
+import dev.hho.android.ui.deeplink.parseItemDeepLink
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+sealed interface ScanUiState {
+    data object Scanning : ScanUiState
+
+    data class Sheet(val value: String, val resolution: ScanResolution) : ScanUiState
+}
+
+sealed interface ScanEvent {
+    data class CreateItem(
+        val prefillIdentifierKind: String,
+        val prefillIdentifierValue: String,
+    ) : ScanEvent
+}
+
+const val SCAN_PREFILL_KIND = "barcode"
+
+val ScanResolution.NoMatch.canCreate: Boolean get() = parseItemDeepLink(value) == null
+
+@HiltViewModel
+class ScanViewModel
+    @Inject
+    constructor(
+        private val resolver: ScanResolver,
+    ) : ViewModel() {
+        internal var nowMillis: () -> Long = System::currentTimeMillis
+
+        private val mutableState = MutableStateFlow<ScanUiState>(ScanUiState.Scanning)
+        val uiState: StateFlow<ScanUiState> = mutableState.asStateFlow()
+
+        private val eventChannel = Channel<ScanEvent>(Channel.BUFFERED)
+
+        val events: Flow<ScanEvent> = eventChannel.receiveAsFlow()
+
+        @Volatile private var resolving = false
+        @Volatile private var lastSeenValue: String? = null
+        private var lastSeenAt = 0L
+
+        val paused: Boolean get() = resolving || mutableState.value !is ScanUiState.Scanning
+
+        fun onBarcodes(barcodes: List<DecodedBarcode>) {
+            val value = barcodes.firstOrNull()?.value ?: return
+            if (paused) return
+            val now = nowMillis()
+            val repeat = value == lastSeenValue && now - lastSeenAt < REPEAT_SUPPRESSION_MILLIS
+            lastSeenValue = value
+            lastSeenAt = now
+            if (repeat) return
+            resolving = true
+            viewModelScope.launch {
+                try {
+                    mutableState.value = ScanUiState.Sheet(value, resolver.resolve(value))
+                } finally {
+                    resolving = false
+                }
+            }
+        }
+
+        fun dismissSheet() {
+            lastSeenAt = nowMillis()
+            mutableState.value = ScanUiState.Scanning
+        }
+
+        fun createItem() {
+            val sheet = mutableState.value as? ScanUiState.Sheet ?: return
+            val noMatch = sheet.resolution as? ScanResolution.NoMatch ?: return
+            if (!noMatch.canCreate) return
+            dismissSheet()
+            eventChannel.trySend(ScanEvent.CreateItem(SCAN_PREFILL_KIND, noMatch.value))
+        }
+
+        fun choose(itemId: String) {
+            val sheet = mutableState.value as? ScanUiState.Sheet ?: return
+            val multiple = sheet.resolution as? ScanResolution.Multiple ?: return
+            val item = multiple.items.firstOrNull { it.id == itemId } ?: return
+            mutableState.value = sheet.copy(resolution = ScanResolution.Single(item))
+        }
+
+        companion object {
+            const val REPEAT_SUPPRESSION_MILLIS = 3_000L
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/ConflictLogScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/ConflictLogScreen.kt
new file mode 100644
index 0000000..ab30b52
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/ConflictLogScreen.kt
@@ -0,0 +1,51 @@
+package dev.hho.android.ui.syncstatus
+
+import android.text.format.DateUtils
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+
+@Composable
+internal fun ConflictLogScreen(
+    onBack: () -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: ConflictLogViewModel = hiltViewModel(),
+) {
+    val rows by viewModel.state.collectAsState()
+    LazyColumn(
+        modifier = modifier.fillMaxSize().padding(24.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        item { OutlinedButton(onClick = onBack) { Text("Back") } }
+        item { Text("Conflict log", style = MaterialTheme.typography.headlineSmall) }
+        if (rows.isEmpty()) item { Text("No conflicts.") }
+        items(rows, key = { it.id }) { c ->
+            Column {
+                Text("${c.entityLabel} - ${c.fieldLabel}", style = MaterialTheme.typography.bodyLarge)
+                Text("Rejected value: ${c.rejectedValue}", style = MaterialTheme.typography.bodyMedium)
+                Text("Kept (server) value: ${c.keptValue}", style = MaterialTheme.typography.bodyMedium)
+                Text(c.originLabel, style = MaterialTheme.typography.bodySmall)
+                Text(
+                    DateUtils.formatDateTime(
+                        null,
+                        c.detectedAt,
+                        DateUtils.FORMAT_SHOW_DATE or DateUtils.FORMAT_SHOW_TIME or DateUtils.FORMAT_SHOW_YEAR,
+                    ),
+                    style = MaterialTheme.typography.bodySmall,
+                )
+            }
+        }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/ConflictLogViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/ConflictLogViewModel.kt
new file mode 100644
index 0000000..1a278a5
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/ConflictLogViewModel.kt
@@ -0,0 +1,73 @@
+package dev.hho.android.ui.syncstatus
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.room.ConflictOrigin
+import dev.hho.android.data.room.ConflictRecordDao
+import dev.hho.android.data.room.ConflictRecordEntity
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonPrimitive
+import javax.inject.Inject
+
+internal data class ConflictUi(
+    val id: Long,
+    val entityLabel: String,
+    val fieldLabel: String,
+    val rejectedValue: String,
+    val keptValue: String,
+    val detectedAt: Long,
+    val originLabel: String,
+    val mutationId: String?,
+)
+
+@HiltViewModel
+internal class ConflictLogViewModel
+    @Inject
+    constructor(
+        private val conflicts: ConflictRecordDao,
+    ) : ViewModel() {
+        val state: StateFlow<List<ConflictUi>> =
+            conflicts.observeAll()
+                .map { rows -> rows.map { it.toUi() } }
+                .stateIn(viewModelScope, SharingStarted.WhileSubscribed(STOP_TIMEOUT_MILLIS), emptyList())
+
+        private suspend fun ConflictRecordEntity.toUi(): ConflictUi {
+            val name = conflicts.itemNameFor(entityType, entityId)
+            return ConflictUi(
+                id = id,
+                entityLabel = name ?: "$entityType ${entityId.take(SHORT_ID)}",
+                fieldLabel = if (fieldName == WHOLE_ENTITY) "whole item" else fieldName,
+                rejectedValue = renderJsonValue(losingValueJson, "not recorded"),
+                keptValue = renderJsonValue(serverValueJson, "not yet known"),
+                detectedAt = detectedAt,
+                originLabel = if (origin == ConflictOrigin.LOCAL_PUSH) {
+                    "Rejected when this device pushed"
+                } else {
+                    "From the server log (any device in the group)"
+                },
+                mutationId = mutationId.takeUnless { it.isBlank() || it.startsWith("server:") },
+            )
+        }
+
+        private companion object {
+            const val STOP_TIMEOUT_MILLIS = 5_000L
+            const val SHORT_ID = 8
+            const val WHOLE_ENTITY = "_entity"
+        }
+    }
+
+internal fun renderJsonValue(json: String?, absent: String): String {
+    if (json == null) return absent
+    val element = runCatching { Json.parseToJsonElement(json) }.getOrNull() ?: return json
+    return when {
+        element is JsonNull -> "—"
+        element is JsonPrimitive -> element.content
+        else -> element.toString()
+    }
+}
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/SyncProblemViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/SyncProblemViewModel.kt
new file mode 100644
index 0000000..aff3271
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/SyncProblemViewModel.kt
@@ -0,0 +1,22 @@
+package dev.hho.android.ui.syncstatus
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.sync.SyncStatusRepository
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import javax.inject.Inject
+
+@HiltViewModel
+internal class SyncProblemViewModel
+    @Inject
+    constructor(
+        repository: SyncStatusRepository,
+    ) : ViewModel() {
+        val hasProblem: StateFlow<Boolean> =
+            repository.observe().map { it.hasProblem }
+                .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), false)
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/SyncStatusScreen.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/SyncStatusScreen.kt
new file mode 100644
index 0000000..8885b93
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/SyncStatusScreen.kt
@@ -0,0 +1,95 @@
+package dev.hho.android.ui.syncstatus
+
+import android.text.format.DateUtils
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
+
+@Composable
+internal fun SyncStatusScreen(
+    onBack: () -> Unit,
+    onConflictLog: () -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: SyncStatusViewModel = hiltViewModel(),
+) {
+    val ui by viewModel.state.collectAsState()
+    val syncing by viewModel.syncing.collectAsState()
+    val conflictCount by viewModel.conflictCount.collectAsState()
+    LazyColumn(
+        modifier = modifier.fillMaxSize().padding(24.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        item { OutlinedButton(onClick = onBack) { Text("Back") } }
+        item { Text("Sync status", style = MaterialTheme.typography.headlineSmall) }
+        item { Text(headlineText(ui), style = MaterialTheme.typography.titleMedium) }
+        item { Text(lastSyncText(ui.status.lastSyncedAt, System.currentTimeMillis())) }
+        item { Text("Photos waiting to upload: ${ui.status.photoQueueDepth}") }
+        ui.status.lastError?.let { error ->
+            item { Text("Last error: $error", color = MaterialTheme.colorScheme.error) }
+        }
+        item {
+            Button(onClick = viewModel::onSyncNow, enabled = !syncing, modifier = Modifier.fillMaxWidth()) {
+                Text("Sync now")
+            }
+        }
+        item {
+            OutlinedButton(onClick = onConflictLog, modifier = Modifier.fillMaxWidth()) {
+                Text("Conflict log ($conflictCount)")
+            }
+        }
+        item { Text("Failures", style = MaterialTheme.typography.titleMedium) }
+        if (ui.failedMutations.isEmpty() && ui.failedPhotos.isEmpty()) {
+            item { Text("No failures.") }
+        }
+        items(ui.failedMutations, key = { "m-${it.mutationId}" }) { m ->
+            Column {
+                Text("Edit not synced - ${m.label}", style = MaterialTheme.typography.bodyLarge)
+                Text(m.error ?: "Unknown error", style = MaterialTheme.typography.bodyMedium)
+                Text(absoluteTime(m.at), style = MaterialTheme.typography.bodySmall)
+            }
+        }
+        items(ui.failedPhotos, key = { "p-${it.id}" }) { p ->
+            Column {
+                Text("Photo not uploaded - ${p.itemName}", style = MaterialTheme.typography.bodyLarge)
+                Text(p.error ?: "Unknown error", style = MaterialTheme.typography.bodyMedium)
+                Text("Attempts: ${p.attempts}", style = MaterialTheme.typography.bodySmall)
+            }
+        }
+    }
+}
+
+internal fun headlineText(ui: SyncStatusUi): String =
+    when (ui.headline) {
+        SyncHeadline.UP_TO_DATE -> "Up to date"
+        SyncHeadline.PENDING -> "${ui.status.pendingCount} pending"
+        SyncHeadline.PROBLEM -> "Needs attention (${ui.status.failedCount} failed, ${ui.status.pendingCount} pending)"
+    }
+
+private fun lastSyncText(at: Long?, now: Long): String =
+    if (at == null) {
+        "Last sync: never"
+    } else {
+        val relative = DateUtils.getRelativeTimeSpanString(at, now, DateUtils.MINUTE_IN_MILLIS)
+        "Last sync: $relative (${absoluteTime(at)})"
+    }
+
+private fun absoluteTime(at: Long): String =
+    DateUtils.formatDateTime(
+        null,
+        at,
+        DateUtils.FORMAT_SHOW_DATE or DateUtils.FORMAT_SHOW_TIME or DateUtils.FORMAT_SHOW_YEAR,
+    )
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/SyncStatusViewModel.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/SyncStatusViewModel.kt
new file mode 100644
index 0000000..4cbb579
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/syncstatus/SyncStatusViewModel.kt
@@ -0,0 +1,123 @@
+package dev.hho.android.ui.syncstatus
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dev.hho.android.data.room.ConflictRecordDao
+import dev.hho.android.data.room.ItemDao
+import dev.hho.android.data.room.OutboxDao
+import dev.hho.android.data.room.OutboxMutationEntity
+import dev.hho.android.data.room.PhotoQueueDao
+import dev.hho.android.data.sync.SyncScheduler
+import dev.hho.android.data.sync.SyncStatus
+import dev.hho.android.data.sync.SyncStatusRepository
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.jsonObject
+import javax.inject.Inject
+
+internal enum class SyncHeadline { UP_TO_DATE, PENDING, PROBLEM }
+
+internal data class FailedMutationUi(
+    val mutationId: String,
+    val label: String,
+    val error: String?,
+    val at: Long,
+)
+
+internal data class FailedPhotoUi(
+    val id: String,
+    val itemName: String,
+    val error: String?,
+    val attempts: Int,
+)
+
+internal data class SyncStatusUi(
+    val status: SyncStatus = SyncStatus(),
+    val failedMutations: List<FailedMutationUi> = emptyList(),
+    val failedPhotos: List<FailedPhotoUi> = emptyList(),
+) {
+    val headline: SyncHeadline
+        get() = when {
+            status.hasProblem -> SyncHeadline.PROBLEM
+            status.pendingCount > 0 -> SyncHeadline.PENDING
+            else -> SyncHeadline.UP_TO_DATE
+        }
+}
+
+@HiltViewModel
+internal class SyncStatusViewModel
+    internal constructor(
+        repository: SyncStatusRepository,
+        outbox: OutboxDao,
+        photos: PhotoQueueDao,
+        private val itemDao: ItemDao,
+        conflicts: ConflictRecordDao,
+        private val syncNow: () -> Unit,
+    ) : ViewModel() {
+        @Inject
+        constructor(
+            repository: SyncStatusRepository,
+            outbox: OutboxDao,
+            photos: PhotoQueueDao,
+            itemDao: ItemDao,
+            conflicts: ConflictRecordDao,
+            scheduler: SyncScheduler,
+        ) : this(repository, outbox, photos, itemDao, conflicts, scheduler::syncNow)
+
+        val conflictCount: StateFlow<Int> =
+            conflicts.observeCount().stateIn(viewModelScope, SharingStarted.WhileSubscribed(STOP_TIMEOUT_MILLIS), 0)
+
+        val state: StateFlow<SyncStatusUi> =
+            combine(repository.observe(), outbox.observeFailed(), photos.observeFailed()) { status, mutations, failedPhotos ->
+                SyncStatusUi(
+                    status = status,
+                    failedMutations = mutations.map { it.toUi() },
+                    failedPhotos = failedPhotos.map { FailedPhotoUi(it.id, itemName(it.itemId), it.lastError, it.attemptCount) },
+                )
+            }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(STOP_TIMEOUT_MILLIS), SyncStatusUi())
+
+        private val _syncing = MutableStateFlow(false)
+
+        val syncing: StateFlow<Boolean> = _syncing.asStateFlow()
+
+        fun onSyncNow() {
+            if (!_syncing.compareAndSet(expect = false, update = true)) return
+            viewModelScope.launch {
+                try {
+                    syncNow()
+                    delay(CLICK_GUARD_MILLIS)
+                } finally {
+                    _syncing.value = false
+                }
+            }
+        }
+
+        private suspend fun OutboxMutationEntity.toUi(): FailedMutationUi {
+            val itemId = if (entityType == "item") entityId else fieldItemId(fieldsJson)
+            val name = itemId?.let { itemDao.getById(it)?.name }
+            val target = name ?: itemId ?: entityId
+            return FailedMutationUi(mutationId, "$entityType: $target", lastError, lastAttemptAt ?: createdAt)
+        }
+
+        private suspend fun itemName(itemId: String): String = itemDao.getById(itemId)?.name ?: itemId
+
+        private fun fieldItemId(json: String): String? =
+            runCatching {
+                (Json.parseToJsonElement(json).jsonObject["item_id"] as? JsonPrimitive)?.takeIf { it.isString }?.content
+            }.getOrNull()
+
+        private companion object {
+            const val STOP_TIMEOUT_MILLIS = 5_000L
+            const val CLICK_GUARD_MILLIS = 1_500L
+        }
+    }
diff --git a/android-app/app/src/main/kotlin/dev/hho/android/ui/theme/Theme.kt b/android-app/app/src/main/kotlin/dev/hho/android/ui/theme/Theme.kt
new file mode 100644
index 0000000..4a3b5e7
--- /dev/null
+++ b/android-app/app/src/main/kotlin/dev/hho/android/ui/theme/Theme.kt
@@ -0,0 +1,18 @@
+package dev.hho.android.ui.theme
+
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+
+@Composable
+fun HhoTheme(
+    darkTheme: Boolean = isSystemInDarkTheme(),
+    content: @Composable () -> Unit,
+) {
+    MaterialTheme(
+        colorScheme = if (darkTheme) darkColorScheme() else lightColorScheme(),
+        content = content,
+    )
+}
diff --git a/android-app/app/src/main/res/values/strings.xml b/android-app/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..a61936f
--- /dev/null
+++ b/android-app/app/src/main/res/values/strings.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">HHO</string>
+</resources>
diff --git a/android-app/app/src/main/res/values/themes.xml b/android-app/app/src/main/res/values/themes.xml
new file mode 100644
index 0000000..a56a8a5
--- /dev/null
+++ b/android-app/app/src/main/res/values/themes.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <style name="Theme.Hho" parent="android:Theme.Material.Light.NoActionBar" />
+</resources>
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/HhoApplicationWorkerFactoryTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/HhoApplicationWorkerFactoryTest.kt
new file mode 100644
index 0000000..5c56211
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/HhoApplicationWorkerFactoryTest.kt
@@ -0,0 +1,50 @@
+package dev.hho.android
+
+import android.content.Context
+import androidx.hilt.work.HiltWorkerFactory
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.work.ListenableWorker
+import androidx.work.WorkManager
+import androidx.work.WorkerFactory
+import androidx.work.WorkerParameters
+import androidx.work.testing.TestListenableWorkerBuilder
+import dev.hho.android.data.sync.SyncWorker
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36], application = HhoApplication::class)
+class HhoApplicationWorkerFactoryTest {
+
+    private val app: HhoApplication = ApplicationProvider.getApplicationContext<Context>() as HhoApplication
+
+    @Test
+    fun `the application's workManagerConfiguration factory constructs a SyncWorker via Hilt`() {
+        val appFactory = app.workManagerConfiguration.workerFactory
+        assertTrue(appFactory is HiltWorkerFactory)
+
+        var created: ListenableWorker? = null
+        val observing =
+            object : WorkerFactory() {
+                override fun createWorker(
+                    appContext: Context,
+                    workerClassName: String,
+                    workerParameters: WorkerParameters,
+                ): ListenableWorker? = appFactory.createWorker(appContext, workerClassName, workerParameters).also { created = it }
+            }
+
+        TestListenableWorkerBuilder<SyncWorker>(app).setWorkerFactory(observing).build()
+
+        assertTrue("HiltWorkerFactory returned ${created?.javaClass}", created is SyncWorker)
+    }
+
+    @Test
+    fun `the process-wide WorkManager initialised during app startup uses the Hilt worker factory`() {
+        val workerFactory = WorkManager.getInstance(app).configuration.workerFactory
+
+        assertTrue("WorkManager was initialised with ${workerFactory.javaClass}", workerFactory is HiltWorkerFactory)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ScaffoldViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ScaffoldViewModelTest.kt
new file mode 100644
index 0000000..f963c81
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ScaffoldViewModelTest.kt
@@ -0,0 +1,23 @@
+package dev.hho.android
+
+import dev.hho.android.di.BuildInfo
+import dev.hho.android.ui.ScaffoldViewModel
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class ScaffoldViewModelTest {
+
+    private val fakeBuildInfo = object : BuildInfo {
+        override val applicationId = "dev.hho.android"
+        override val versionName = "0.1.0"
+        override val minSdk = 26
+    }
+
+    @Test
+    fun `exposes build info in ui state`() {
+        val state = ScaffoldViewModel(fakeBuildInfo).state
+
+        assertEquals("dev.hho.android", state.applicationId)
+        assertEquals(26, state.minSdk)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/apiclient/HhoApiClientAttachmentsTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/apiclient/HhoApiClientAttachmentsTest.kt
new file mode 100644
index 0000000..d453f64
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/apiclient/HhoApiClientAttachmentsTest.kt
@@ -0,0 +1,168 @@
+package dev.hho.android.data.apiclient
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.edit
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.SocketPolicy
+import org.junit.After
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import java.io.File
+
+class HhoApiClientAttachmentsTest {
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(15)
+
+    private val server = MockWebServer()
+
+    @After
+    fun tearDown() {
+        server.shutdown()
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val prefs = File.createTempFile("hho-att-test", ".preferences_pb").also { it.deleteOnExit() }
+        val dataStore = PreferenceDataStoreFactory.create(produceFile = { prefs })
+        runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() } }
+        val cv = ClientVersionInterceptor()
+        val provider =
+            object : DeviceTokenProvider {
+                override suspend fun tokenFor(requestUrl: HttpUrl): String? = "tok-123"
+
+                override suspend fun invalidate(
+                    requestUrl: HttpUrl,
+                    rejectedToken: String,
+                ) = Unit
+            }
+        val http = NetworkModule.provideOkHttpClient(BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore)), AuthHeaderInterceptor(provider), cv)
+        return HhoApiClient(http, NetworkModule.provideProbeOkHttpClient(http, cv))
+    }
+
+    private val payload = ByteArray(300_000) { (it * 31 % 251).toByte() }
+
+    private fun payloadFile(name: String = "receipt.jpg"): File {
+        val dir = File.createTempFile("hho-att", "dir").also { it.delete(); it.mkdirs(); it.deleteOnExit() }
+        return File(dir, name).also { it.writeBytes(payload); it.deleteOnExit() }
+    }
+
+    private fun attachmentJson(
+        id: String = "a-1",
+        sha: String = "ab".repeat(32),
+        size: Long = payload.size.toLong(),
+    ) = """{"id":"$id","item_id":"item-9","category":"receipt","original_filename":"receipt.jpg","content_type":"image/jpeg",""" +
+        """"size_bytes":$size,"sha256":"$sha","created_at":1700000000000,"updated_at":1700000000001,"version":1,"has_thumbnail":true}"""
+
+    private fun problem(status: Int) =
+        MockResponse()
+            .setResponseCode(status)
+            .setHeader("Content-Type", "application/problem+json")
+            .setBody("""{"type":"about:blank","title":"t","status":$status}""")
+
+    @Test
+    fun `upload sends exact multipart request and decodes 201`() {
+        server.enqueue(MockResponse().setResponseCode(201).setHeader("Content-Type", "application/json").setBody(attachmentJson()))
+        val result = runBlocking { apiClient().uploadAttachment("item-9", AttachmentCategory.RECEIPT, payloadFile()) }
+
+        val info = result.getOrThrow()
+        assertEquals("a-1", info.id)
+        assertEquals("receipt", info.category)
+        assertEquals("ab".repeat(32), info.sha256)
+        assertEquals(payload.size.toLong(), info.sizeBytes)
+        assertTrue(info.hasThumbnail)
+
+        val req = server.takeRequest()
+        assertEquals("POST", req.method)
+        assertEquals("/api/v1/items/item-9/attachments", req.path)
+        assertEquals("Bearer tok-123", req.getHeader("Authorization"))
+        assertNotNull(req.getHeader("X-HHO-Client-Version"))
+        val contentType = req.getHeader("Content-Type")!!
+        assertTrue(contentType, contentType.startsWith("multipart/form-data; boundary="))
+        val boundary = contentType.substringAfter("boundary=")
+
+        val body = req.body.readByteArray()
+        val text = String(body, Charsets.ISO_8859_1)
+        val parts = text.split("--$boundary").drop(1).filter { it.startsWith("\r\n") }
+        assertEquals(2, parts.size)
+        val categoryPart = parts.single { it.contains("""name="category"""") }
+        assertTrue(categoryPart.contains("\r\n\r\nreceipt\r\n"))
+        assertTrue(!categoryPart.contains("filename="))
+        val filePart = parts.single { it.contains("""name="file"""") }
+        assertTrue(filePart.contains("""filename="receipt.jpg""""))
+        assertTrue(filePart.contains("Content-Type: image/jpeg"))
+        val headerEnd = filePart.indexOf("\r\n\r\n") + 4
+        val fileBytes = filePart.substring(headerEnd, filePart.length - 2).toByteArray(Charsets.ISO_8859_1)
+        assertArrayEquals(payload, fileBytes)
+    }
+
+    @Test
+    fun `upload 404 maps to NotFound`() {
+        server.enqueue(problem(404))
+        val error = runBlocking { apiClient().uploadAttachment("nope", AttachmentCategory.IMAGE, payloadFile()) }.exceptionOrNull()
+        assertTrue(error.toString(), error is ApiError.NotFound)
+    }
+
+    @Test
+    fun `upload 413 maps to distinguishable PayloadTooLarge`() {
+        server.enqueue(problem(413))
+        val error = runBlocking { apiClient().uploadAttachment("item-9", AttachmentCategory.IMAGE, payloadFile()) }.exceptionOrNull()
+        assertTrue(error.toString(), error is ApiError.PayloadTooLarge)
+        assertEquals(413, (error as ApiError.Validation).status)
+    }
+
+    @Test
+    fun `upload 500 maps to Server`() {
+        server.enqueue(problem(500))
+        val error = runBlocking { apiClient().uploadAttachment("item-9", AttachmentCategory.IMAGE, payloadFile()) }.exceptionOrNull()
+        assertTrue(error.toString(), error is ApiError.Server)
+        assertEquals(500, (error as ApiError.Server).status)
+    }
+
+    @Test
+    fun `upload network failure maps to Network`() {
+        server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AFTER_REQUEST))
+        val error = runBlocking { apiClient().uploadAttachment("item-9", AttachmentCategory.IMAGE, payloadFile()) }.exceptionOrNull()
+        assertTrue(error.toString(), error is ApiError.Network)
+    }
+
+    @Test
+    fun `list decodes sha256 and size and hits the list path`() {
+        server.enqueue(
+            MockResponse().setResponseCode(200).setHeader("Content-Type", "application/json")
+                .setBody("""{"attachments":[${attachmentJson("a-1", "cd".repeat(32), 42)},${attachmentJson("a-2", "ef".repeat(32), 7)}]}"""),
+        )
+        val list = runBlocking { apiClient().listAttachments("item-9") }.getOrThrow()
+        assertEquals(listOf("a-1", "a-2"), list.map { it.id })
+        assertEquals("cd".repeat(32), list[0].sha256)
+        assertEquals(42L, list[0].sizeBytes)
+        assertEquals(7L, list[1].sizeBytes)
+
+        val req = server.takeRequest()
+        assertEquals("GET", req.method)
+        assertEquals("/api/v1/items/item-9/attachments", req.path)
+        assertEquals("Bearer tok-123", req.getHeader("Authorization"))
+        assertNotNull(req.getHeader("X-HHO-Client-Version"))
+    }
+
+    @Test
+    fun `list empty and 404`() {
+        server.enqueue(MockResponse().setResponseCode(200).setHeader("Content-Type", "application/json").setBody("""{"attachments":[]}"""))
+        assertTrue(runBlocking { apiClient().listAttachments("item-9") }.getOrThrow().isEmpty())
+        server.enqueue(problem(404))
+        assertTrue(runBlocking { apiClient().listAttachments("x") }.exceptionOrNull() is ApiError.NotFound)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/apiclient/HhoApiClientSyncPushTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/apiclient/HhoApiClientSyncPushTest.kt
new file mode 100644
index 0000000..c659f89
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/apiclient/HhoApiClientSyncPushTest.kt
@@ -0,0 +1,235 @@
+package dev.hho.android.data.apiclient
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.edit
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.Json
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import java.io.File
+
+class HhoApiClientSyncPushTest {
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(15)
+
+    private val server = MockWebServer()
+
+    @After
+    fun tearDown() {
+        server.shutdown()
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val file = File.createTempFile("hho-push-test", ".preferences_pb").also { it.deleteOnExit() }
+        val dataStore = PreferenceDataStoreFactory.create(produceFile = { file })
+        runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() } }
+        val cv = ClientVersionInterceptor()
+        val provider =
+            object : DeviceTokenProvider {
+                override suspend fun tokenFor(requestUrl: HttpUrl): String? = null
+
+                override suspend fun invalidate(
+                    requestUrl: HttpUrl,
+                    rejectedToken: String,
+                ) = Unit
+            }
+        val http = NetworkModule.provideOkHttpClient(BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore)), AuthHeaderInterceptor(provider), cv)
+        return HhoApiClient(http, NetworkModule.provideProbeOkHttpClient(http, cv))
+    }
+
+    private fun problem(
+        status: Int,
+        detail: String,
+    ) = MockResponse()
+        .setResponseCode(status)
+        .setHeader("Content-Type", "application/problem+json")
+        .setBody("""{"type":"about:blank","title":"t","status":$status,"detail":${JsonPrimitive(detail)}}""")
+
+    private val mutation =
+        PushMutation(
+            mutationId = "m-1",
+            entityType = "item",
+            entityId = "e-1",
+            baseVersion = 3,
+            fields =
+                mapOf(
+                    "name" to JsonPrimitive("Drill"),
+                    "quantity" to JsonPrimitive(4),
+                    "notes" to JsonNull,
+                    "archived" to JsonPrimitive(false),
+                ),
+        )
+
+    @Test
+    fun `200 mixed applied skipped conflicts decodes and sends the exact request JSON`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(200).setBody(
+                    """{"applied":[{"mutation_id":"m-1","entity_type":"item","entity_id":"e-1","version":4}],""" +
+                        """"skipped":[{"mutation_id":"m-2"}],""" +
+                        """"conflicts":[{"mutation_id":"m-3","entity_type":"item","entity_id":"e-3","field_name":"name"}],""" +
+                        """"new_watermark":42}""",
+                ),
+            )
+
+            val outcome = apiClient().syncPush("dev-1", listOf(mutation, mutation.copy(mutationId = "m-9", op = "delete"))).getOrThrow()
+
+            outcome as SyncPushOutcome.Success
+            assertEquals(listOf("m-1"), outcome.applied.map { it.mutationId })
+            assertEquals(4L, outcome.applied.single().version)
+            assertEquals(listOf("m-2"), outcome.skipped.map { it.mutationId })
+            assertEquals("name", outcome.conflicts.single().fieldName)
+            assertEquals(42L, outcome.newWatermark)
+
+            val recorded = server.takeRequest()
+            assertEquals("/api/v1/sync/push", recorded.path)
+            assertEquals("POST", recorded.method)
+            val expected =
+                Json.parseToJsonElement(
+                    """{"device_id":"dev-1","mutations":[""" +
+                        """{"mutation_id":"m-1","entity_type":"item","entity_id":"e-1","base_version":3,""" +
+                        """"fields":{"name":"Drill","quantity":4,"notes":null,"archived":false}},""" +
+                        """{"mutation_id":"m-9","entity_type":"item","entity_id":"e-1","base_version":3,""" +
+                        """"fields":{"name":"Drill","quantity":4,"notes":null,"archived":false},"op":"delete"}]}""",
+                )
+            assertEquals(expected, Json.parseToJsonElement(recorded.body.readUtf8()))
+        }
+
+    @Test
+    fun `200 with empty lists decodes to an empty Success`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"applied":[],"skipped":[],"conflicts":[],"new_watermark":0}"""))
+
+            val outcome = apiClient().syncPush("d", emptyList()).getOrThrow() as SyncPushOutcome.Success
+
+            assertTrue(outcome.applied.isEmpty() && outcome.skipped.isEmpty() && outcome.conflicts.isEmpty())
+        }
+
+    @Test
+    fun `structural 400 with the pinned detail yields index and mutation id`() =
+        runBlocking {
+            val detail = """mutations[2] (mutation_id="abc-123"): entity_type "bogus" is not a known entity type"""
+            server.enqueue(problem(400, detail))
+
+            val outcome = apiClient().syncPush("d", listOf(mutation)).getOrThrow() as SyncPushOutcome.StructuralRejection
+
+            assertEquals(2, outcome.index)
+            assertEquals("abc-123", outcome.mutationId)
+            assertEquals(detail, outcome.detail)
+        }
+
+    @Test
+    fun `structural 400 with an escaped quote in the id unescapes it`() =
+        runBlocking {
+            server.enqueue(problem(400, """mutations[0] (mutation_id="a\"b"): mutation_id is bad"""))
+
+            val outcome = apiClient().syncPush("d", listOf(mutation)).getOrThrow() as SyncPushOutcome.StructuralRejection
+
+            assertEquals(0, outcome.index)
+            assertEquals("a\"b", outcome.mutationId)
+        }
+
+    @Test
+    fun `structural 400 with an unparseable detail yields null index and id`() =
+        runBlocking {
+            server.enqueue(problem(400, "mutations[oops] something else entirely"))
+
+            val outcome = apiClient().syncPush("d", listOf(mutation)).getOrThrow() as SyncPushOutcome.StructuralRejection
+
+            assertNull(outcome.index)
+            assertNull(outcome.mutationId)
+            assertEquals("mutations[oops] something else entirely", outcome.detail)
+        }
+
+    @Test
+    fun `non-structural 400 maps to ApiError Validation not StructuralRejection`() =
+        runBlocking {
+            server.enqueue(problem(400, "device_id is required"))
+
+            val error = apiClient().syncPush("", listOf(mutation)).exceptionOrNull() as ApiError.Validation
+
+            assertEquals(400, error.status)
+            assertEquals("device_id is required", error.detail)
+        }
+
+    @Test
+    fun `401 maps to Unauthorized`() =
+        runBlocking {
+            server.enqueue(problem(401, "nope"))
+            assertTrue(apiClient().syncPush("d", listOf(mutation)).exceptionOrNull() is ApiError.Unauthorized)
+        }
+
+    @Test
+    fun `426 maps to UpgradeRequired carrying the minimum version`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(426).setBody(
+                    """{"type":"urn:hho:problem:upgrade-required","title":"Upgrade Required","status":426,"minimum_version":"2.4.0"}""",
+                ),
+            )
+
+            val error = apiClient().syncPush("d", listOf(mutation)).exceptionOrNull() as ApiError.UpgradeRequired
+
+            assertEquals("2.4.0", error.minimumVersion)
+        }
+
+    @Test
+    fun `500 maps to Server`() =
+        runBlocking {
+            server.enqueue(problem(500, "boom"))
+
+            val error = apiClient().syncPush("d", listOf(mutation)).exceptionOrNull() as ApiError.Server
+
+            assertEquals(500, error.status)
+        }
+
+    @Test
+    fun `200 with a malformed body maps to UnexpectedPayload`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("{not json"))
+            assertTrue(apiClient().syncPush("d", listOf(mutation)).exceptionOrNull() is ApiError.UnexpectedPayload)
+        }
+
+    @Test
+    fun `200 with a JSON body missing required fields maps to UnexpectedPayload`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"applied":[]}"""))
+            assertTrue(apiClient().syncPush("d", listOf(mutation)).exceptionOrNull() is ApiError.UnexpectedPayload)
+        }
+
+    @Test
+    fun `A145 evidence - generated SyncMutation cannot encode its free-form fields`() {
+        val generated =
+            dev.hho.android.data.apiclient.generated.models.SyncMutation(
+                mutationId = "m",
+                entityType = "item",
+                entityId = "e",
+                baseVersion = 0,
+                fields = JsonObject(mapOf("name" to JsonPrimitive("x"))),
+            )
+        val failed =
+            runCatching {
+                dev.hho.android.data.apiclient.generated.infrastructure.Serializer.kotlinxSerializationJson
+                    .encodeToString(dev.hho.android.data.apiclient.generated.models.SyncMutation.serializer(), generated)
+            }.isFailure
+        assertTrue("generated SyncMutation unexpectedly encodes; hand-written encoder no longer needed", failed)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/apiclient/HhoApiClientTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/apiclient/HhoApiClientTest.kt
new file mode 100644
index 0000000..7076c99
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/apiclient/HhoApiClientTest.kt
@@ -0,0 +1,516 @@
+package dev.hho.android.data.apiclient
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import dev.hho.android.BuildConfig
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Rule
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.rules.Timeout
+import java.io.File
+
+class HhoApiClientTest {
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(15)
+
+    private val server = MockWebServer()
+
+    @After
+    fun tearDown() {
+        server.shutdown()
+    }
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("hho-api-client-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    private fun apiClient(
+        instanceUrl: String? = server.url("/").toString(),
+        token: String? = null,
+    ): HhoApiClient {
+        val dataStore = tempDataStore()
+        if (instanceUrl != null) {
+            runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = instanceUrl } }
+        }
+        val clientVersionInterceptor = ClientVersionInterceptor()
+        val authHeaderInterceptor = AuthHeaderInterceptor(fixedTokenProvider(token))
+        val baseUrlInterceptor = BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore))
+
+        val httpClient =
+            NetworkModule.provideOkHttpClient(baseUrlInterceptor, authHeaderInterceptor, clientVersionInterceptor)
+        val probeHttpClient = NetworkModule.provideProbeOkHttpClient(httpClient, clientVersionInterceptor)
+        return HhoApiClient(httpClient, probeHttpClient)
+    }
+
+    private fun fixedTokenProvider(token: String?): DeviceTokenProvider =
+        object : DeviceTokenProvider {
+            override suspend fun tokenFor(requestUrl: HttpUrl): String? = token
+
+            override suspend fun invalidate(
+                requestUrl: HttpUrl,
+                rejectedToken: String,
+            ) = Unit
+        }
+
+    @Test
+    fun `a facade call against an instance with a path prefix sends the exact prefixed path`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            val client = apiClient(instanceUrl = server.url("/hho").toString())
+
+            val result = client.getStatus()
+
+            assertTrue(result.isSuccess)
+            assertEquals("/hho/api/v1/status", server.takeRequest().path)
+        }
+
+    @Test
+    fun `sync pull against a prefixed instance sends the exact prefixed path`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(200).setBody(
+                    """{"changes":[],"tombstones":[],"next_watermark":0,"has_more":false}""",
+                ),
+            )
+            val client = apiClient(instanceUrl = server.url("/hho").toString())
+
+            val result = client.syncPull(deviceId = "device-1", since = 0, limit = 100)
+
+            assertTrue(result.isSuccess)
+            val recorded = server.takeRequest()
+            assertEquals("/hho/api/v1/sync/pull", recorded.path)
+            assertEquals("POST", recorded.method)
+            assertTrue(recorded.body.readUtf8().contains("\"device_id\":\"device-1\""))
+        }
+
+    @Test
+    fun `a stored device token is attached as Authorization on facade calls`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            val client = apiClient(token = "device-token-123")
+
+            client.getStatus()
+
+            assertEquals("Bearer device-token-123", server.takeRequest().getHeader("Authorization"))
+        }
+
+    @Test
+    fun `no stored device token means no Authorization header at all on facade calls`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            val client = apiClient(token = null)
+
+            client.getStatus()
+
+            assertEquals(null, server.takeRequest().getHeader("Authorization"))
+        }
+
+    @Test
+    fun `a facade call sends the exact byte-for-byte client version header`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            val client = apiClient()
+
+            client.getStatus()
+
+            assertEquals(BuildConfig.HHO_CLIENT_VERSION, server.takeRequest().getHeader("X-HHO-Client-Version"))
+        }
+
+    @Test
+    fun `probeInstance sends the exact byte-for-byte client version header`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            val client = apiClient(instanceUrl = null)
+
+            client.probeInstance(server.url("/"))
+
+            assertEquals(BuildConfig.HHO_CLIENT_VERSION, server.takeRequest().getHeader("X-HHO-Client-Version"))
+        }
+
+    @Test
+    fun `426 on a facade call maps to ApiError UpgradeRequired carrying the minimum version`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(426).setBody(
+                    """{"type":"urn:hho:problem:upgrade-required","title":"Upgrade Required",""" +
+                        """"status":426,"minimum_version":"2.4.0"}""",
+                ),
+            )
+            val client = apiClient()
+
+            val result = client.getStatus()
+
+            val error = result.exceptionOrNull() as ApiError.UpgradeRequired
+            assertEquals("2.4.0", error.minimumVersion)
+        }
+
+    @Test
+    fun `no instance configured maps to ApiError NoInstanceConfigured`() =
+        runBlocking {
+            val client = apiClient(instanceUrl = null)
+
+            val result = client.getStatus()
+
+            assertTrue(result.exceptionOrNull() is ApiError.NoInstanceConfigured)
+        }
+
+    @Test
+    fun `401 maps to ApiError Unauthorized`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(401))
+            val client = apiClient()
+
+            val result = client.getStatus()
+
+            assertTrue(result.exceptionOrNull() is ApiError.Unauthorized)
+        }
+
+    @Test
+    fun `404 maps to ApiError NotFound`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(404))
+            val client = apiClient()
+
+            val result = client.getStatus()
+
+            assertTrue(result.exceptionOrNull() is ApiError.NotFound)
+        }
+
+    @Test
+    fun `409 maps to ApiError Conflict carrying the problem detail`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(409).setBody(
+                    """{"type":"urn:hho:problem:conflict","title":"Conflict","status":409,"detail":"field diverged"}""",
+                ),
+            )
+            val client = apiClient()
+
+            val result = client.getStatus()
+
+            val error = result.exceptionOrNull() as ApiError.Conflict
+            assertEquals("field diverged", error.detail)
+        }
+
+    @Test
+    fun `422 maps to ApiError Validation carrying the problem detail`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(422).setBody(
+                    """{"type":"urn:hho:problem:validation","title":"Unprocessable","status":422,"detail":"since must be >= 0"}""",
+                ),
+            )
+            val client = apiClient()
+
+            val result = client.getStatus()
+
+            val error = result.exceptionOrNull() as ApiError.Validation
+            assertEquals(422, error.status)
+            assertEquals("since must be >= 0", error.detail)
+        }
+
+    @Test
+    fun `400 with problem+json detail maps to ApiError Validation carrying that detail`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(400).setBody(
+                    """{"type":"urn:hho:problem:bad-request","title":"Bad Request","status":400,"detail":"malformed body"}""",
+                ),
+            )
+            val client = apiClient()
+
+            val result = client.getStatus()
+
+            val error = result.exceptionOrNull() as ApiError.Validation
+            assertEquals(400, error.status)
+            assertEquals("malformed body", error.detail)
+        }
+
+    @Test
+    fun `500 maps to ApiError Server`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(500).setBody(
+                    """{"type":"urn:hho:problem:internal","title":"Internal Server Error","status":500}""",
+                ),
+            )
+            val client = apiClient()
+
+            val result = client.getStatus()
+
+            val error = result.exceptionOrNull() as ApiError.Server
+            assertEquals(500, error.status)
+        }
+
+    @Test
+    fun `an IO failure maps to ApiError Network`() =
+        runBlocking {
+            val client = apiClient()
+            server.shutdown()
+
+            val result = client.getStatus()
+
+            assertTrue(result.exceptionOrNull() is ApiError.Network)
+        }
+
+    @Test
+    fun `sync pull decodes a normal page through the entity_type dispatcher`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(200).setBody(
+                    """
+                    {
+                      "changes": [
+                        {"entity_type":"location","id":"loc-1","group_change_seq":1,
+                         "data":{"id":"loc-1","name":"Garage","created_at":1,"updated_at":1,"version":1}}
+                      ],
+                      "tombstones": [],
+                      "next_watermark": 7,
+                      "has_more": false
+                    }
+                    """.trimIndent(),
+                ),
+            )
+            val client = apiClient()
+
+            val result = client.syncPull(deviceId = "device-1", since = 0, limit = 100)
+
+            val page = result.getOrThrow() as SyncPullOutcome.Page
+            assertEquals(1, page.changes.size)
+            assertTrue(page.changes[0] is SyncChange.LocationChange)
+            assertEquals(7L, page.nextWatermark)
+        }
+
+    @Test
+    fun `sync pull surfaces cursor_too_old as its own distinct outcome`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"cursor_too_old":true}"""))
+            val client = apiClient()
+
+            val result = client.syncPull(deviceId = "device-1", since = 1, limit = 100)
+
+            assertEquals(SyncPullOutcome.CursorTooOld, result.getOrThrow())
+        }
+
+    @Test
+    fun `sync pull with an unknown entity_type fails as ApiError UnexpectedPayload, not a silent drop`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(200).setBody(
+                    """
+                    {
+                      "changes": [{"entity_type":"widget","id":"w-1","group_change_seq":1,"data":{}}],
+                      "tombstones": [],
+                      "next_watermark": 1,
+                      "has_more": false
+                    }
+                    """.trimIndent(),
+                ),
+            )
+            val client = apiClient()
+
+            val result = client.syncPull(deviceId = "device-1", since = 0, limit = 100)
+
+            assertTrue(result.exceptionOrNull() is ApiError.UnexpectedPayload)
+        }
+
+    @Test
+    fun `sync pull 401 maps to ApiError Unauthorized via the hand-rolled call path too`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(401))
+            val client = apiClient()
+
+            val result = client.syncPull(deviceId = "device-1", since = 0, limit = 100)
+
+            assertTrue(result.exceptionOrNull() is ApiError.Unauthorized)
+        }
+
+    @Test
+    fun `probeInstance against a prefixed candidate hits the prefixed api-v1-status path`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            val client = apiClient(instanceUrl = null)
+
+            val result = client.probeInstance(server.url("/hho"))
+
+            assertTrue(result.isSuccess)
+            assertEquals("/hho/api/v1/status", server.takeRequest().path)
+        }
+
+    @Test
+    fun `probeInstance is not host-rewritten to whatever instance is currently configured`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            val client = apiClient(instanceUrl = "https://configured.invalid/hho")
+
+            val result = client.probeInstance(server.url("/"))
+
+            assertTrue(result.isSuccess)
+            assertEquals("/api/v1/status", server.takeRequest().path)
+        }
+
+    @Test
+    fun `probeInstance never sends the stored device token`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            val client = apiClient(instanceUrl = null, token = "should-never-be-sent")
+
+            client.probeInstance(server.url("/"))
+
+            assertEquals(null, server.takeRequest().getHeader("Authorization"))
+        }
+
+    @Test
+    fun `probeInstance 426 maps to ApiError UpgradeRequired carrying the minimum version`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(426).setBody(
+                    """{"type":"urn:hho:problem:upgrade-required","title":"Upgrade Required",""" +
+                        """"status":426,"minimum_version":"2.4.0"}""",
+                ),
+            )
+            val client = apiClient(instanceUrl = null)
+
+            val result = client.probeInstance(server.url("/"))
+
+            val error = result.exceptionOrNull() as ApiError.UpgradeRequired
+            assertEquals("2.4.0", error.minimumVersion)
+        }
+
+    @Test
+    fun `probeInstance against a 200 with a non-JSON content type maps to ApiError UnexpectedPayload`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(200)
+                    .setHeader("Content-Type", "text/html")
+                    .setBody("<html>not an HHO server</html>"),
+            )
+            val client = apiClient(instanceUrl = null)
+
+            val result = client.probeInstance(server.url("/"))
+
+            assertTrue(result.exceptionOrNull() is ApiError.UnexpectedPayload)
+        }
+
+    @Test
+    fun `probeInstance against a 200 JSON body missing required StatusResponse fields maps to ApiError UnexpectedPayload`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"hello":"world"}"""))
+            val client = apiClient(instanceUrl = null)
+
+            val result = client.probeInstance(server.url("/"))
+
+            assertTrue(result.exceptionOrNull() is ApiError.UnexpectedPayload)
+        }
+
+    private val loginOkBody = """{"group_id":"g1","user_id":"u1","username":"alice","role":"owner"}"""
+
+    @Test
+    fun `login extracts the session cookie out of Set-Cookie, trimmed to name=value`() =
+        runBlocking {
+            server.enqueue(
+                MockResponse().setResponseCode(200)
+                    .setHeader("Set-Cookie", "hho_session=abc123; HttpOnly; Secure; SameSite=Lax; Max-Age=3600")
+                    .setBody(loginOkBody),
+            )
+            val client = apiClient()
+
+            val outcome = client.login("alice", "secret").getOrThrow()
+
+            assertEquals("hho_session=abc123", outcome.sessionCookie)
+            assertEquals("alice", outcome.response.username)
+        }
+
+    @Test
+    fun `a 200 login response with no Set-Cookie header maps to ApiError UnexpectedPayload`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(200).setBody(loginOkBody))
+            val client = apiClient()
+
+            val result = client.login("alice", "secret")
+
+            assertTrue(result.exceptionOrNull() is ApiError.UnexpectedPayload)
+        }
+
+    @Test
+    fun `login 401 maps to ApiError Unauthorized`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(401))
+            val client = apiClient()
+
+            val result = client.login("alice", "wrong-password")
+
+            assertTrue(result.exceptionOrNull() is ApiError.Unauthorized)
+        }
+
+    @Test
+    fun `login 429 maps to ApiError Validation carrying status 429`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(429).setHeader("Retry-After", "30"))
+            val client = apiClient()
+
+            val result = client.login("alice", "secret")
+
+            val error = result.exceptionOrNull() as ApiError.Validation
+            assertEquals(429, error.status)
+        }
+
+    @Test
+    fun `issueDeviceToken sends exactly the given session cookie as the Cookie header`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(201).setBody("""{"id":"dt1","device_label":"Pixel","token":"device-token-xyz"}"""))
+            val client = apiClient()
+
+            val result = client.issueDeviceToken("Pixel", "hho_session=abc123")
+
+            assertTrue(result.isSuccess)
+            assertEquals("hho_session=abc123", server.takeRequest().getHeader("Cookie"))
+        }
+
+    @Test
+    fun `issueDeviceToken sends no Authorization header even when a device token is already held`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(201).setBody("""{"id":"dt2","device_label":"Pixel","token":"new-device-token"}"""))
+            val client = apiClient(token = "already-held-device-token")
+
+            val result = client.issueDeviceToken("Pixel", "hho_session=abc123")
+
+            assertTrue(result.isSuccess)
+            val recorded = server.takeRequest()
+            assertNull(recorded.getHeader("Authorization"))
+            assertEquals("hho_session=abc123", recorded.getHeader("Cookie"))
+        }
+
+    @Test
+    fun `issueDeviceToken's session cookie never leaks onto a later unrelated facade call`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(201).setBody("""{"id":"dt1","device_label":"Pixel","token":"device-token-xyz"}"""))
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            val client = apiClient()
+
+            client.issueDeviceToken("Pixel", "hho_session=abc123")
+            server.takeRequest()
+
+            client.getStatus()
+
+            assertNull(server.takeRequest().getHeader("Cookie"))
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/apiclient/SyncChangeDecoderTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/apiclient/SyncChangeDecoderTest.kt
new file mode 100644
index 0000000..c4365b1
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/apiclient/SyncChangeDecoderTest.kt
@@ -0,0 +1,235 @@
+package dev.hho.android.data.apiclient
+
+import dev.hho.android.data.apiclient.generated.infrastructure.Serializer
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+class SyncChangeDecoderTest {
+
+    private val json = Serializer.kotlinxSerializationJson
+
+    private fun decode(element: String): SyncChange = SyncChangeDecoder.decodeChange(json.parseToJsonElement(element))
+
+    @Test
+    fun `item decodes to ItemChange with its own payload`() {
+        val change =
+            decode(
+                """{"entity_type":"item","id":"item-1","group_change_seq":1,
+                   |"data":{"id":"item-1","name":"Drill"}}""".trimMargin(),
+            )
+
+        val item = change as SyncChange.ItemChange
+        assertEquals("item-1", item.id)
+        assertEquals(1L, item.groupChangeSeq)
+        assertEquals("Drill", item.data.name)
+    }
+
+    @Test
+    fun `warranty_block decodes to WarrantyBlockChange with its own payload`() {
+        val change =
+            decode(
+                """{"entity_type":"warranty_block","id":"wb-1","group_change_seq":2,
+                   |"data":{"is_lifetime":true}}""".trimMargin(),
+            )
+
+        val warranty = change as SyncChange.WarrantyBlockChange
+        assertEquals("wb-1", warranty.id)
+        assertEquals(2L, warranty.groupChangeSeq)
+        assertEquals(true, warranty.data.isLifetime)
+    }
+
+    @Test
+    fun `sold_to_block decodes to SoldToBlockChange with its own payload`() {
+        val change =
+            decode(
+                """{"entity_type":"sold_to_block","id":"stb-1","group_change_seq":3,
+                   |"data":{"sale_price_minor":1000}}""".trimMargin(),
+            )
+
+        val soldTo = change as SyncChange.SoldToBlockChange
+        assertEquals("stb-1", soldTo.id)
+        assertEquals(3L, soldTo.groupChangeSeq)
+        assertEquals(1000L, soldTo.data.salePriceMinor)
+    }
+
+    @Test
+    fun `purchased_from_block decodes to PurchasedFromBlockChange with its own payload`() {
+        val change =
+            decode(
+                """{"entity_type":"purchased_from_block","id":"pfb-1","group_change_seq":4,
+                   |"data":{"purchase_price_minor":2000}}""".trimMargin(),
+            )
+
+        val purchasedFrom = change as SyncChange.PurchasedFromBlockChange
+        assertEquals("pfb-1", purchasedFrom.id)
+        assertEquals(4L, purchasedFrom.groupChangeSeq)
+        assertEquals(2000L, purchasedFrom.data.purchasePriceMinor)
+    }
+
+    @Test
+    fun `item_identification decodes to ItemIdentificationChange with its own payload`() {
+        val change =
+            decode(
+                """{"entity_type":"item_identification","id":"ident-1","group_change_seq":5,
+                   |"data":{"kind":"serial","value":"SN123"}}""".trimMargin(),
+            )
+
+        val identification = change as SyncChange.ItemIdentificationChange
+        assertEquals("ident-1", identification.id)
+        assertEquals(5L, identification.groupChangeSeq)
+        assertEquals("SN123", identification.data.value)
+    }
+
+    @Test
+    fun `item_custom_field decodes to ItemCustomFieldChange with its own payload`() {
+        val change =
+            decode(
+                """{"entity_type":"item_custom_field","id":"icf-1","group_change_seq":6,
+                   |"data":{"name":"Color","field_type":"text"}}""".trimMargin(),
+            )
+
+        val customField = change as SyncChange.ItemCustomFieldChange
+        assertEquals("icf-1", customField.id)
+        assertEquals(6L, customField.groupChangeSeq)
+        assertEquals("Color", customField.data.name)
+    }
+
+    @Test
+    fun `stock_adjustment decodes to StockAdjustmentChange with its own payload`() {
+        val change =
+            decode(
+                """{"entity_type":"stock_adjustment","id":"sa-1","group_change_seq":7,
+                   |"data":{"delta":1,"resulting_quantity":5}}""".trimMargin(),
+            )
+
+        val stockAdjustment = change as SyncChange.StockAdjustmentChange
+        assertEquals("sa-1", stockAdjustment.id)
+        assertEquals(7L, stockAdjustment.groupChangeSeq)
+        assertEquals(5L, stockAdjustment.data.resultingQuantity)
+    }
+
+    @Test
+    fun `location decodes to LocationChange with its own payload`() {
+        val change =
+            decode(
+                """{"entity_type":"location","id":"loc-1","group_change_seq":8,
+                   |"data":{"id":"loc-1","name":"Garage","created_at":1,"updated_at":1,"version":1}}""".trimMargin(),
+            )
+
+        val location = change as SyncChange.LocationChange
+        assertEquals("loc-1", location.id)
+        assertEquals(8L, location.groupChangeSeq)
+        assertEquals("Garage", location.data.name)
+    }
+
+    @Test
+    fun `label decodes to LabelChange with its own payload`() {
+        val change =
+            decode(
+                """{"entity_type":"label","id":"lbl-1","group_change_seq":9,
+                   |"data":{"id":"lbl-1","name":"Fragile","color":"#ff0000","created_at":1,
+                   |"updated_at":1,"version":1}}""".trimMargin(),
+            )
+
+        val label = change as SyncChange.LabelChange
+        assertEquals("lbl-1", label.id)
+        assertEquals(9L, label.groupChangeSeq)
+        assertEquals("Fragile", label.data.name)
+    }
+
+    @Test
+    fun `item_label decodes to ItemLabelChange with its own payload`() {
+        val change =
+            decode(
+                """{"entity_type":"item_label","id":"il-1","group_change_seq":10,
+                   |"data":{"item_id":"item-1","label_id":"lbl-1"}}""".trimMargin(),
+            )
+
+        val itemLabel = change as SyncChange.ItemLabelChange
+        assertEquals("il-1", itemLabel.id)
+        assertEquals(10L, itemLabel.groupChangeSeq)
+        assertEquals("lbl-1", itemLabel.data.labelId)
+    }
+
+    @Test
+    fun `attachment decodes to AttachmentChange with its own payload`() {
+        val change =
+            decode(
+                """{"entity_type":"attachment","id":"att-1","group_change_seq":11,
+                   |"data":{"id":"att-1","item_id":"item-1","category":"image",
+                   |"original_filename":"photo.jpg","content_type":"image/jpeg","size_bytes":1024,
+                   |"sha256":"abc123","created_at":1,"updated_at":1,"version":1,
+                   |"has_thumbnail":false}}""".trimMargin(),
+            )
+
+        val attachment = change as SyncChange.AttachmentChange
+        assertEquals("att-1", attachment.id)
+        assertEquals(11L, attachment.groupChangeSeq)
+        assertEquals("photo.jpg", attachment.data.originalFilename)
+    }
+
+    @Test
+    fun `unknown entity_type fails loudly instead of being dropped`() {
+        val thrown =
+            assertThrows(UnknownSyncEntityTypeException::class.java) {
+                decode(
+                    """{"entity_type":"widget","id":"w-1","group_change_seq":1,"data":{}}""",
+                )
+            }
+
+        assertEquals("widget", thrown.rawEntityType)
+    }
+
+    @Test
+    fun `missing entity_type field fails loudly`() {
+        val thrown =
+            assertThrows(UnknownSyncEntityTypeException::class.java) {
+                decode("""{"id":"w-1","group_change_seq":1,"data":{}}""")
+            }
+
+        assertEquals(null, thrown.rawEntityType)
+    }
+
+    @Test
+    fun `a change entry that fails to decode against its own variant is a MalformedSyncPullResponseException`() {
+        assertThrows(MalformedSyncPullResponseException::class.java) {
+            decode("""{"entity_type":"item","id":"item-1","group_change_seq":1,"data":{}}""")
+        }
+    }
+
+    @Test
+    fun `full pull envelope decodes changes and tombstones together`() {
+        val outcome =
+            SyncChangeDecoder.decodePullResponse(
+                json.parseToJsonElement(
+                    """
+                    {
+                      "changes": [
+                        {"entity_type":"location","id":"loc-1","group_change_seq":1,
+                         "data":{"id":"loc-1","name":"Garage","created_at":1,"updated_at":1,"version":1}}
+                      ],
+                      "tombstones": [
+                        {"entity_type":"label","id":"lbl-9","deleted_at":123}
+                      ],
+                      "next_watermark": 42,
+                      "has_more": false
+                    }
+                    """.trimIndent(),
+                ),
+            ) as SyncPullOutcome.Page
+
+        assertEquals(1, outcome.changes.size)
+        assertEquals(1, outcome.tombstones.size)
+        assertEquals("lbl-9", outcome.tombstones[0].id)
+        assertEquals(42L, outcome.nextWatermark)
+        assertEquals(false, outcome.hasMore)
+    }
+
+    @Test
+    fun `cursor_too_old shape is a distinct outcome, not a Page`() {
+        val outcome = SyncChangeDecoder.decodePullResponse(json.parseToJsonElement("""{"cursor_too_old":true}"""))
+
+        assertEquals(SyncPullOutcome.CursorTooOld, outcome)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/attachments/AttachmentCacheSustainedBrowsingTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/attachments/AttachmentCacheSustainedBrowsingTest.kt
new file mode 100644
index 0000000..769745f
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/attachments/AttachmentCacheSustainedBrowsingTest.kt
@@ -0,0 +1,348 @@
+package dev.hho.android.data.attachments
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.room.AttachmentEntity
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.RecordedRequest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+import java.security.MessageDigest
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.random.Random
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class AttachmentCacheSustainedBrowsingTest {
+
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(30)
+
+    private val server = MockWebServer()
+    private lateinit var db: HhoDatabase
+    private lateinit var scratchDir: File
+    private lateinit var cacheDir: File
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        scratchDir =
+            File.createTempFile("attachment-cache-sustained-test", "").apply {
+                delete()
+                mkdirs()
+                deleteOnExit()
+            }
+        cacheDir = File(scratchDir, "attachments")
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+        server.shutdown()
+        scratchDir.deleteRecursively()
+    }
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("attachment-cache-sustained-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val dataStore = tempDataStore()
+        runBlocking {
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() }
+        }
+        val clientVersionInterceptor = ClientVersionInterceptor()
+        val authHeaderInterceptor =
+            AuthHeaderInterceptor(
+                object : DeviceTokenProvider {
+                    override suspend fun tokenFor(requestUrl: HttpUrl): String? = "device-token"
+
+                    override suspend fun invalidate(
+                        requestUrl: HttpUrl,
+                        rejectedToken: String,
+                    ) = Unit
+                },
+            )
+        val baseUrlInterceptor = BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore))
+        val httpClient =
+            NetworkModule.provideOkHttpClient(baseUrlInterceptor, authHeaderInterceptor, clientVersionInterceptor)
+        val probeHttpClient = NetworkModule.provideProbeOkHttpClient(httpClient, clientVersionInterceptor)
+        return HhoApiClient(httpClient, probeHttpClient)
+    }
+
+    private fun sha256Hex(content: String): String =
+        MessageDigest.getInstance("SHA-256").digest(content.toByteArray(Charsets.US_ASCII))
+            .joinToString(separator = "") { "%02x".format(it) }
+
+    private fun sha256Hex(file: File): String =
+        MessageDigest.getInstance("SHA-256").digest(file.readBytes())
+            .joinToString(separator = "") { "%02x".format(it) }
+
+    private fun seedAttachment(
+        id: String,
+        content: String,
+        itemId: String = "item-1",
+    ) = runBlocking {
+        db.attachmentDao().upsert(
+            AttachmentEntity(
+                id = id,
+                groupChangeSeq = 1L,
+                itemId = itemId,
+                category = "general",
+                originalFilename = "$id.bin",
+                contentType = "application/octet-stream",
+                sizeBytes = content.length.toLong(),
+                sha256 = sha256Hex(content),
+                hasThumbnail = false,
+                createdAt = 1L,
+                updatedAt = 1L,
+                version = 1L,
+            ),
+        )
+    }
+
+    private fun cache(maxCacheBytes: Long): AttachmentCache =
+        AttachmentCache(
+            cacheDir = cacheDir,
+            apiClient = apiClient(),
+            attachmentDao = db.attachmentDao(),
+            maxCacheBytes = maxCacheBytes,
+        )
+
+    private fun contentOfSize(
+        seedValue: Long,
+        size: Int,
+    ): String {
+        val random = Random(seedValue)
+        return String(CharArray(size) { 'a' + random.nextInt(26) })
+    }
+
+    private fun totalCacheBytes(): Long = cacheDir.walkTopDown().filter { it.isFile }.sumOf { it.length() }
+
+    private fun tmpDirIsEmpty(): Boolean = File(cacheDir, ".tmp").listFiles().orEmpty().isEmpty()
+
+    private fun assertBoundHolds(bound: Long) {
+        assertTrue("cache dir exceeded its bound: ${totalCacheBytes()} > $bound", totalCacheBytes() <= bound)
+        assertTrue(".tmp/ left a staged file behind", tmpDirIsEmpty())
+    }
+
+    private class ByIdDispatcher(private val contentById: Map<String, String>) : Dispatcher() {
+        val requestCounts = ConcurrentHashMap<String, Int>()
+
+        override fun dispatch(request: RecordedRequest): MockResponse {
+            val id = request.path.orEmpty().substringAfterLast('/')
+            requestCounts.merge(id, 1, Int::plus)
+            val content = contentById[id] ?: return MockResponse().setResponseCode(404)
+            return MockResponse().setResponseCode(200).setBody(content)
+        }
+    }
+
+    @Test
+    fun `sustained browsing across sequential, hot-set and randomized access keeps the bound after every view`() =
+        runTest {
+            val bound = 20_000L
+            val count = 64
+            val ids = (0 until count).map { "sb-$it" }
+            val contentById =
+                ids.mapIndexed { i, id ->
+                    val size = if (i % 8 == 0) (bound - 200).toInt() else 200 + (i * 37) % 2800
+                    id to contentOfSize(seedValue = i.toLong(), size = size)
+                }.toMap()
+            contentById.forEach { (id, content) -> seedAttachment(id, content) }
+            server.dispatcher = ByIdDispatcher(contentById)
+            val attachmentCache = cache(maxCacheBytes = bound)
+
+            val hotSet = ids.take(6)
+            val hotSetRevisits = List(8) { hotSet }.flatten()
+            val random = Random(20260928L)
+            val randomPass = List(40) { ids[random.nextInt(ids.size)] }
+            val browsingSequence = ids + hotSetRevisits + randomPass
+
+            for (id in browsingSequence) {
+                val result = attachmentCache.file(id)
+                assertTrue("view of $id failed: ${result.exceptionOrNull()}", result.isSuccess)
+                assertBoundHolds(bound)
+            }
+        }
+
+    @Test
+    fun `a small hot set re-viewed frequently is never re-fetched, even as other attachments churn through the cache`() =
+        runTest {
+            val bound = 6_000L
+            val hotIds = listOf("hot-0", "hot-1")
+            val hotContent = hotIds.associateWith { id -> contentOfSize(seedValue = id.hashCode().toLong(), size = 300) }
+            val churnIds = (0 until 40).map { "churn-$it" }
+            val churnContent =
+                churnIds.associateWith { id -> contentOfSize(seedValue = id.hashCode().toLong(), size = 500) }
+            val contentById = hotContent + churnContent
+            contentById.forEach { (id, content) -> seedAttachment(id, content) }
+            val dispatcher = ByIdDispatcher(contentById)
+            server.dispatcher = dispatcher
+            val attachmentCache = cache(maxCacheBytes = bound)
+
+            hotIds.forEach { assertTrue(attachmentCache.file(it).isSuccess) }
+
+            for (churnId in churnIds) {
+                assertTrue(attachmentCache.file(churnId).isSuccess)
+                Thread.sleep(MTIME_TICK_MS)
+                hotIds.forEach {
+                    assertTrue(attachmentCache.file(it).isSuccess)
+                    Thread.sleep(MTIME_TICK_MS)
+                }
+            }
+
+            hotIds.forEach { id ->
+                assertEquals("hot id $id was re-fetched", 1, dispatcher.requestCounts[id])
+            }
+        }
+
+    @Test
+    fun `concurrent sustained browsing across overlapping ids leaves the bound intact and every cached file valid`() =
+        runTest {
+            val bound = 15_000L
+            val count = 30
+            val ids = (0 until count).map { "cc-$it" }
+            val contentById =
+                ids.mapIndexed { i, id ->
+                    id to contentOfSize(seedValue = i.toLong() + 1_000, size = 300 + (i * 53) % 1_200)
+                }.toMap()
+            contentById.forEach { (id, content) -> seedAttachment(id, content) }
+            server.dispatcher = ByIdDispatcher(contentById)
+            val attachmentCache = cache(maxCacheBytes = bound)
+
+            val workers =
+                (0 until 8).map { workerIndex ->
+                    async(Dispatchers.Default) {
+                        val random = Random(workerIndex * 97L + 3)
+                        repeat(25) {
+                            val id = ids[random.nextInt(ids.size)]
+                            attachmentCache.file(id).getOrThrow()
+                        }
+                    }
+                }
+            workers.awaitAll()
+
+            assertBoundHolds(bound)
+            cacheDir.listFiles { candidate -> candidate.isFile }.orEmpty().forEach { cached ->
+                val expected = contentById.getValue(cached.name)
+                assertEquals(
+                    "cached file ${cached.name} does not match its sha256 — a torn write?",
+                    sha256Hex(expected),
+                    sha256Hex(cached),
+                )
+            }
+        }
+
+    @Test
+    fun `an oversize attachment interleaved with normal browsing is served every time without ever counting toward the bound`() =
+        runTest {
+            val bound = 5_000L
+            val bigId = "oversize"
+            val bigContent = contentOfSize(seedValue = 999L, size = (bound + 1_000).toInt())
+            val normalIds = (0 until 10).map { "normal-$it" }
+            val normalContent =
+                normalIds.associateWith { id -> contentOfSize(seedValue = id.hashCode().toLong(), size = 400) }
+            val contentById = normalContent + (bigId to bigContent)
+            contentById.forEach { (id, content) -> seedAttachment(id, content) }
+            val dispatcher = ByIdDispatcher(contentById)
+            server.dispatcher = dispatcher
+            val attachmentCache = cache(maxCacheBytes = bound)
+
+            val sequence = normalIds.flatMapIndexed { i, id -> if (i % 2 == 0) listOf(id, bigId) else listOf(id) }
+            for (id in sequence) {
+                val result = attachmentCache.file(id)
+                assertTrue("view of $id failed: ${result.exceptionOrNull()}", result.isSuccess)
+                assertEquals(contentById.getValue(id), result.getOrThrow().readText())
+                assertBoundHolds(bound)
+                assertFalse(File(cacheDir, bigId).exists())
+            }
+
+            assertEquals(5, dispatcher.requestCounts[bigId])
+        }
+
+    @Test
+    fun `the production default bound is A168's 200 MiB`() {
+        assertEquals(209_715_200L, ATTACHMENT_CACHE_MAX_BYTES)
+        assertEquals(200L * 1024 * 1024, ATTACHMENT_CACHE_MAX_BYTES)
+    }
+
+    @Test
+    fun `views over a set larger than capacity keep exactly the five most recently used and refetch evicted ones lazily`() =
+        runTest {
+            val entrySize = 1_000
+            val capacity = 5
+            val bound = (entrySize * capacity).toLong()
+            val ids = (0 until 12).map { "lru-$it" }
+            val contentById = ids.mapIndexed { i, id -> id to contentOfSize(seedValue = 500L + i, size = entrySize) }.toMap()
+            assertTrue("total size must exceed the bound", contentById.values.sumOf { it.length } > bound)
+            contentById.forEach { (id, content) -> seedAttachment(id, content) }
+            val dispatcher = ByIdDispatcher(contentById)
+            server.dispatcher = dispatcher
+            val attachmentCache = cache(maxCacheBytes = bound)
+
+            val random = Random(161L)
+            val sequence = ids + listOf(ids[7]) + ids.take(3) + List(120) { ids[random.nextInt(ids.size)] }
+
+            val model = LinkedHashSet<String>()
+            val expectedRequests = HashMap<String, Int>()
+            for (id in sequence) {
+                val hit = model.remove(id)
+                model.add(id)
+                if (!hit) expectedRequests.merge(id, 1, Int::plus)
+                while (model.size > capacity) model.remove(model.first())
+
+                val result = attachmentCache.file(id)
+                assertTrue("view of $id failed: ${result.exceptionOrNull()}", result.isSuccess)
+                assertEquals(contentById.getValue(id), result.getOrThrow().readText())
+                Thread.sleep(MTIME_TICK_MS)
+
+                assertBoundHolds(bound)
+                val onDisk = cacheDir.listFiles { f -> f.isFile }.orEmpty().map { it.name }.toSet()
+                assertEquals("on-disk set diverged from the LRU model after viewing $id", model.toSet(), onDisk)
+                assertEquals(
+                    "request counts diverged (hit/miss mismatch) after viewing $id",
+                    expectedRequests.toMap(),
+                    dispatcher.requestCounts.toMap(),
+                )
+            }
+
+            assertTrue("no id was ever refetched", dispatcher.requestCounts.values.any { it > 1 })
+            assertEquals(capacity, model.size)
+        }
+
+    private companion object {
+        const val MTIME_TICK_MS = 15L
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/attachments/AttachmentCacheTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/attachments/AttachmentCacheTest.kt
new file mode 100644
index 0000000..3493e2e
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/attachments/AttachmentCacheTest.kt
@@ -0,0 +1,311 @@
+package dev.hho.android.data.attachments
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.room.AttachmentDao
+import dev.hho.android.data.room.AttachmentEntity
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+import java.security.MessageDigest
+import java.util.concurrent.TimeUnit
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class AttachmentCacheTest {
+
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(15)
+
+    private val server = MockWebServer()
+    private lateinit var db: HhoDatabase
+    private lateinit var scratchDir: File
+
+    @org.junit.Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        scratchDir = File.createTempFile("attachment-cache-test", "").apply {
+            delete()
+            mkdirs()
+            deleteOnExit()
+        }
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+        server.shutdown()
+        scratchDir.deleteRecursively()
+    }
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("attachment-cache-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val dataStore = tempDataStore()
+        runBlocking {
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() }
+        }
+        val clientVersionInterceptor = ClientVersionInterceptor()
+        val authHeaderInterceptor =
+            AuthHeaderInterceptor(
+                object : DeviceTokenProvider {
+                    override suspend fun tokenFor(requestUrl: HttpUrl): String? = "device-token"
+
+                    override suspend fun invalidate(
+                        requestUrl: HttpUrl,
+                        rejectedToken: String,
+                    ) = Unit
+                },
+            )
+        val baseUrlInterceptor = BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore))
+        val httpClient =
+            NetworkModule.provideOkHttpClient(baseUrlInterceptor, authHeaderInterceptor, clientVersionInterceptor)
+        val probeHttpClient = NetworkModule.provideProbeOkHttpClient(httpClient, clientVersionInterceptor)
+        return HhoApiClient(httpClient, probeHttpClient)
+    }
+
+    private fun sha256Hex(content: String): String =
+        MessageDigest.getInstance("SHA-256").digest(content.toByteArray(Charsets.US_ASCII))
+            .joinToString(separator = "") { "%02x".format(it) }
+
+    private fun seedAttachment(
+        id: String,
+        content: String,
+        itemId: String = "item-1",
+        sha256: String = sha256Hex(content),
+        sizeBytes: Long = content.length.toLong(),
+    ) = runBlocking {
+        db.attachmentDao().upsert(
+            AttachmentEntity(
+                id = id,
+                groupChangeSeq = 1L,
+                itemId = itemId,
+                category = "general",
+                originalFilename = "$id.bin",
+                contentType = "application/octet-stream",
+                sizeBytes = sizeBytes,
+                sha256 = sha256,
+                hasThumbnail = false,
+                createdAt = 1L,
+                updatedAt = 1L,
+                version = 1L,
+            ),
+        )
+    }
+
+    private fun cache(maxCacheBytes: Long = ATTACHMENT_CACHE_MAX_BYTES): AttachmentCache =
+        AttachmentCache(
+            cacheDir = File(scratchDir, "attachments"),
+            apiClient = apiClient(),
+            attachmentDao = db.attachmentDao(),
+            maxCacheBytes = maxCacheBytes,
+        )
+
+    @Test
+    fun `first view fetches the bytes over the network, a second view of the same id serves the cached copy`() =
+        runTest {
+            val content = "hello attachment bytes"
+            seedAttachment(id = "a1", content = content)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(content))
+            val attachmentCache = cache()
+
+            val first = attachmentCache.file("a1")
+            assertTrue(first.isSuccess)
+            assertEquals(content, first.getOrThrow().readText())
+            assertEquals(1, server.requestCount)
+
+            val second = attachmentCache.file("a1")
+            assertTrue(second.isSuccess)
+            assertEquals(content, second.getOrThrow().readText())
+            assertEquals(1, server.requestCount)
+        }
+
+    @Test
+    fun `the download request targets the attachment's own item and id`() =
+        runTest {
+            val content = "x"
+            seedAttachment(id = "att-99", content = content, itemId = "item-77")
+            server.enqueue(MockResponse().setResponseCode(200).setBody(content))
+
+            cache().file("att-99")
+
+            assertEquals("/api/v1/items/item-77/attachments/att-99", server.takeRequest().path)
+        }
+
+    @Test
+    fun `a body whose sha256 does not match the mirrored metadata is not cached`() =
+        runTest {
+            val content = "corrupted-on-the-wire"
+            seedAttachment(id = "a2", content = content, sha256 = "0".repeat(64))
+            server.enqueue(MockResponse().setResponseCode(200).setBody(content))
+            val attachmentCache = cache()
+
+            val result = attachmentCache.file("a2")
+
+            assertTrue(result.isFailure)
+            assertTrue(result.exceptionOrNull() is AttachmentIntegrityException)
+            assertFalse(File(scratchDir, "attachments/a2").exists())
+            assertTrue(File(scratchDir, "attachments/.tmp").listFiles().orEmpty().isEmpty())
+        }
+
+    @Test
+    fun `a body whose length does not match the mirrored size is not cached`() =
+        runTest {
+            val content = "short"
+            seedAttachment(id = "a3", content = content, sizeBytes = 999L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(content))
+            val attachmentCache = cache()
+
+            val result = attachmentCache.file("a3")
+
+            assertTrue(result.isFailure)
+            assertTrue(result.exceptionOrNull() is AttachmentIntegrityException)
+            assertFalse(File(scratchDir, "attachments/a3").exists())
+        }
+
+    @Test
+    fun `a network failure leaves nothing cached and surfaces as an ApiError`() =
+        runTest {
+            seedAttachment(id = "a4", content = "irrelevant")
+            server.enqueue(MockResponse().setResponseCode(500).setBody("""{"type":"urn:hho:problem:internal","title":"boom","status":500}"""))
+            val attachmentCache = cache()
+
+            val result = attachmentCache.file("a4")
+
+            assertTrue(result.isFailure)
+            assertTrue(result.exceptionOrNull() is ApiError.Server)
+            assertFalse(File(scratchDir, "attachments/a4").exists())
+        }
+
+    @Test
+    fun `no metadata row for the id fails without ever calling the network`() =
+        runTest {
+            val attachmentCache = cache()
+
+            val result = attachmentCache.file("does-not-exist")
+
+            assertTrue(result.isFailure)
+            assertTrue(result.exceptionOrNull() is AttachmentNotCachedException)
+            assertEquals(0, server.requestCount)
+        }
+
+    @Test
+    fun `two concurrent requests for the same id produce exactly one fetch`() =
+        runTest {
+            val content = "shared-bytes"
+            seedAttachment(id = "a5", content = content)
+            server.enqueue(
+                MockResponse().setResponseCode(200).setBody(content)
+                    .setBodyDelay(300, TimeUnit.MILLISECONDS),
+            )
+            val attachmentCache = cache()
+
+            val first = async(Dispatchers.Default) { attachmentCache.file("a5") }
+            val second = async(Dispatchers.Default) { attachmentCache.file("a5") }
+            val (r1, r2) = awaitAll(first, second)
+
+            assertTrue(r1.isSuccess)
+            assertTrue(r2.isSuccess)
+            assertEquals(content, (r1.getOrThrow() as File).readText())
+            assertEquals(content, (r2.getOrThrow() as File).readText())
+            assertEquals(1, server.requestCount)
+        }
+
+    @Test
+    fun `eviction removes the least-recently-used entry, not simply the oldest write`() =
+        runTest {
+            val contentA = "0123456789"
+            val contentB = "abcdefghij"
+            val contentC = "ABCDEFGHIJ"
+            seedAttachment(id = "lru-a", content = contentA)
+            seedAttachment(id = "lru-b", content = contentB)
+            seedAttachment(id = "lru-c", content = contentC)
+            val attachmentCache = cache(maxCacheBytes = 25)
+
+            server.enqueue(MockResponse().setResponseCode(200).setBody(contentA))
+            attachmentCache.file("lru-a")
+            Thread.sleep(10)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(contentB))
+            attachmentCache.file("lru-b")
+            Thread.sleep(10)
+            attachmentCache.file("lru-a")
+            Thread.sleep(10)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(contentC))
+            attachmentCache.file("lru-c")
+
+            assertTrue(File(scratchDir, "attachments/lru-a").exists())
+            assertFalse(File(scratchDir, "attachments/lru-b").exists())
+            assertTrue(File(scratchDir, "attachments/lru-c").exists())
+            assertEquals(3, server.requestCount)
+        }
+
+    @Test
+    fun `an attachment larger than the whole bound is served without being cached`() =
+        runTest {
+            val content = "this-is-longer-than-the-tiny-bound"
+            seedAttachment(id = "big", content = content)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(content))
+            val attachmentCache = cache(maxCacheBytes = 4)
+
+            val result = attachmentCache.file("big")
+
+            assertTrue(result.isSuccess)
+            assertEquals(content, result.getOrThrow().readText())
+            assertFalse(File(scratchDir, "attachments/big").exists())
+        }
+
+    @Test
+    fun `a fresh AttachmentCache instance over the same directory rebuilds its index from disk, without re-fetching`() =
+        runTest {
+            val content = "durable-bytes"
+            seedAttachment(id = "a6", content = content)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(content))
+            val client = apiClient()
+            val cacheDir = File(scratchDir, "attachments")
+            val first = AttachmentCache(cacheDir, client, db.attachmentDao(), ATTACHMENT_CACHE_MAX_BYTES)
+            assertTrue(first.file("a6").isSuccess)
+            assertEquals(1, server.requestCount)
+
+            val restarted = AttachmentCache(cacheDir, client, db.attachmentDao(), ATTACHMENT_CACHE_MAX_BYTES)
+            val result = restarted.file("a6")
+
+            assertTrue(result.isSuccess)
+            assertEquals(content, result.getOrThrow().readText())
+            assertEquals(1, server.requestCount)
+            assertNotEquals(first, restarted)
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/auth/AesGcmDeviceTokenCipherTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/auth/AesGcmDeviceTokenCipherTest.kt
new file mode 100644
index 0000000..c13e50a
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/auth/AesGcmDeviceTokenCipherTest.kt
@@ -0,0 +1,92 @@
+package dev.hho.android.data.auth
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+import java.security.GeneralSecurityException
+import javax.crypto.KeyGenerator
+import javax.crypto.SecretKey
+
+class AesGcmDeviceTokenCipherTest {
+
+    private val defaultAad = "https://hho.example.com/".toByteArray(Charsets.UTF_8)
+
+    private fun softwareAesKey(): SecretKey = KeyGenerator.getInstance("AES").apply { init(256) }.generateKey()
+
+    private fun cipherWithFixedKey(key: SecretKey = softwareAesKey()): AesGcmDeviceTokenCipher =
+        AesGcmDeviceTokenCipher(secretKey = { key })
+
+    @Test
+    fun `decrypt reverses encrypt exactly`() {
+        val cipher = cipherWithFixedKey()
+        val plaintext = "device-token-abc123".toByteArray(Charsets.UTF_8)
+
+        val ciphertext = cipher.encrypt(plaintext, defaultAad)
+        val decrypted = cipher.decrypt(ciphertext, defaultAad)
+
+        assertArrayEquals(plaintext, decrypted)
+    }
+
+    @Test
+    fun `ciphertext never contains the plaintext token bytes verbatim`() {
+        val cipher = cipherWithFixedKey()
+        val plaintext = "super-secret-device-token".toByteArray(Charsets.UTF_8)
+
+        val ciphertext = cipher.encrypt(plaintext, defaultAad)
+
+        assertNotEquals(String(plaintext, Charsets.ISO_8859_1), String(ciphertext, Charsets.ISO_8859_1))
+        assertFalse(
+            "ciphertext leaked the plaintext token",
+            String(ciphertext, Charsets.ISO_8859_1).contains(String(plaintext, Charsets.ISO_8859_1)),
+        )
+    }
+
+    @Test
+    fun `encrypting the same plaintext twice produces different ciphertext (fresh IV per call)`() {
+        val cipher = cipherWithFixedKey()
+        val plaintext = "device-token-abc123".toByteArray(Charsets.UTF_8)
+
+        val first = cipher.encrypt(plaintext, defaultAad)
+        val second = cipher.encrypt(plaintext, defaultAad)
+
+        assertNotEquals(first.toList(), second.toList())
+        assertArrayEquals(plaintext, cipher.decrypt(first, defaultAad))
+        assertArrayEquals(plaintext, cipher.decrypt(second, defaultAad))
+    }
+
+    @Test
+    fun `decrypting a tampered payload throws instead of returning garbage`() {
+        val cipher = cipherWithFixedKey()
+        val ciphertext = cipher.encrypt("device-token-abc123".toByteArray(Charsets.UTF_8), defaultAad)
+        ciphertext[ciphertext.size - 1] = (ciphertext[ciphertext.size - 1] + 1).toByte()
+
+        assertThrows(GeneralSecurityException::class.java) { cipher.decrypt(ciphertext, defaultAad) }
+    }
+
+    @Test
+    fun `decrypting with the wrong key throws`() {
+        val ciphertext = cipherWithFixedKey(softwareAesKey()).encrypt("device-token-abc123".toByteArray(Charsets.UTF_8), defaultAad)
+        val otherKeyCipher = cipherWithFixedKey(softwareAesKey())
+
+        assertThrows(GeneralSecurityException::class.java) { otherKeyCipher.decrypt(ciphertext, defaultAad) }
+    }
+
+    @Test
+    fun `decrypting a too-short payload throws`() {
+        val cipher = cipherWithFixedKey()
+
+        assertThrows(GeneralSecurityException::class.java) { cipher.decrypt(ByteArray(4), defaultAad) }
+    }
+
+    @Test
+    fun `decrypting with mismatched associated data throws (AAD binding)`() {
+        val cipher = cipherWithFixedKey()
+        val ciphertext = cipher.encrypt("device-token-abc123".toByteArray(Charsets.UTF_8), defaultAad)
+
+        assertThrows(GeneralSecurityException::class.java) {
+            cipher.decrypt(ciphertext, "https://attacker.example.com/".toByteArray(Charsets.UTF_8))
+        }
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/auth/AuthRepositoryImplTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/auth/AuthRepositoryImplTest.kt
new file mode 100644
index 0000000..1f0b2f7
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/auth/AuthRepositoryImplTest.kt
@@ -0,0 +1,356 @@
+package dev.hho.android.data.auth
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import dev.hho.android.domain.AuthState
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.io.File
+
+class AuthRepositoryImplTest {
+
+    private val server = MockWebServer()
+
+    @After
+    fun tearDown() {
+        server.shutdown()
+    }
+
+    private fun tempDataStoreFile(): File {
+        val file = File.createTempFile("auth-repository-test", ".preferences_pb")
+        file.deleteOnExit()
+        return file
+    }
+
+    private fun dataStoreFor(
+        file: File,
+        instanceUrl: String,
+    ): DataStore<Preferences> {
+        val dataStore = PreferenceDataStoreFactory.create(produceFile = { file })
+        runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = instanceUrl } }
+        return dataStore
+    }
+
+    private class Fixture(
+        val hhoApiClient: HhoApiClient,
+        val deviceTokenStore: DeviceTokenStore,
+        val deviceTokenProvider: InstanceScopedDeviceTokenProvider,
+        val repository: AuthRepositoryImpl,
+        val instanceDataStore: DataStore<Preferences>,
+    )
+
+    private fun fixture(
+        instanceUrl: String,
+        deviceLabel: String = "Test Device",
+        instanceDataStoreFile: File = tempDataStoreFile(),
+        deviceTokenStore: DeviceTokenStore = FakeDeviceTokenStore(),
+    ): Fixture {
+        val dataStore = dataStoreFor(instanceDataStoreFile, instanceUrl)
+        val resolver = InstanceBaseUrlResolver(dataStore)
+        val clientVersionInterceptor = ClientVersionInterceptor()
+        val tokenProvider = InstanceScopedDeviceTokenProvider(deviceTokenStore)
+        val authHeaderInterceptor = AuthHeaderInterceptor(tokenProvider)
+        val baseUrlInterceptor = BaseUrlInterceptor(resolver)
+        val httpClient =
+            NetworkModule.provideOkHttpClient(baseUrlInterceptor, authHeaderInterceptor, clientVersionInterceptor)
+        val probeHttpClient = NetworkModule.provideProbeOkHttpClient(httpClient, clientVersionInterceptor)
+        val hhoApiClient = HhoApiClient(httpClient, probeHttpClient)
+        val repository =
+            AuthRepositoryImpl(hhoApiClient, deviceTokenStore, resolver, DeviceLabelProvider { deviceLabel })
+        return Fixture(hhoApiClient, deviceTokenStore, tokenProvider, repository, dataStore)
+    }
+
+    private val loginOkBody = """{"group_id":"g1","user_id":"u1","username":"alice","role":"owner"}"""
+
+    private fun enqueueLoginOk(
+        target: MockWebServer = server,
+        sessionCookie: String = "hho_session=abc123; HttpOnly; Secure; SameSite=Lax; Max-Age=3600",
+    ) {
+        target.enqueue(MockResponse().setResponseCode(200).setHeader("Set-Cookie", sessionCookie).setBody(loginOkBody))
+    }
+
+    private fun enqueueDeviceTokenOk(
+        target: MockWebServer = server,
+        token: String = "device-token-xyz",
+    ) {
+        target.enqueue(
+            MockResponse().setResponseCode(201).setBody(
+                """{"id":"dt1","device_label":"Test Device","token":"$token"}""",
+            ),
+        )
+    }
+
+    @Test
+    fun `login carries the session cookie from auth-login into the auth-device-tokens request`() =
+        runBlocking {
+            enqueueLoginOk()
+            enqueueDeviceTokenOk()
+            val fixture = fixture(server.url("/").toString())
+
+            val result = fixture.repository.login("alice", "secret")
+
+            assertTrue(result.isSuccess)
+            server.takeRequest()
+            val deviceTokenRequest = server.takeRequest()
+            assertEquals("/api/v1/auth/device-tokens", deviceTokenRequest.path)
+            assertEquals("hho_session=abc123", deviceTokenRequest.getHeader("Cookie"))
+        }
+
+    @Test
+    fun `a subsequent unrelated call carries the issued device token but not the session cookie`() =
+        runBlocking {
+            enqueueLoginOk()
+            enqueueDeviceTokenOk(token = "device-token-xyz")
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            val fixture = fixture(server.url("/").toString())
+
+            fixture.repository.login("alice", "secret")
+            server.takeRequest()
+            server.takeRequest()
+            fixture.hhoApiClient.getStatus()
+
+            val laterRequest = server.takeRequest()
+            assertEquals("Bearer device-token-xyz", laterRequest.getHeader("Authorization"))
+            assertNull(laterRequest.getHeader("Cookie"))
+        }
+
+    @Test
+    fun `login flips authState to LoggedIn only after both calls succeed`() =
+        runBlocking {
+            enqueueLoginOk()
+            enqueueDeviceTokenOk()
+            val fixture = fixture(server.url("/").toString())
+
+            fixture.repository.login("alice", "secret")
+
+            assertEquals(AuthState.LoggedIn, fixture.repository.authState.first())
+            assertEquals("device-token-xyz", fixture.deviceTokenProvider.tokenFor(server.url("/api/v1/status")))
+        }
+
+    @Test
+    fun `401 on login fails without ever calling auth-device-tokens and leaves the repository logged out`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(401))
+            val fixture = fixture(server.url("/").toString())
+
+            val result = fixture.repository.login("alice", "wrong-password")
+
+            assertTrue(result.isFailure)
+            assertEquals(1, server.requestCount)
+            assertEquals(AuthState.LoggedOut, fixture.repository.authState.first())
+            assertNull(fixture.deviceTokenStore.load())
+        }
+
+    @Test
+    fun `429 on login fails and leaves the repository logged out`() =
+        runBlocking {
+            server.enqueue(MockResponse().setResponseCode(429).setHeader("Retry-After", "30"))
+            val fixture = fixture(server.url("/").toString())
+
+            val result = fixture.repository.login("alice", "secret")
+
+            assertTrue(result.isFailure)
+            assertEquals(AuthState.LoggedOut, fixture.repository.authState.first())
+        }
+
+    @Test
+    fun `a failure of the device-token call after a successful login leaves nothing half logged in`() =
+        runBlocking {
+            enqueueLoginOk()
+            server.enqueue(MockResponse().setResponseCode(500))
+            val fixture = fixture(server.url("/").toString())
+
+            val result = fixture.repository.login("alice", "secret")
+
+            assertTrue(result.isFailure)
+            assertEquals(AuthState.LoggedOut, fixture.repository.authState.first())
+            assertNull(fixture.deviceTokenStore.load())
+
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            fixture.hhoApiClient.getStatus()
+            server.takeRequest()
+            server.takeRequest()
+            val laterRequest = server.takeRequest()
+            assertNull(laterRequest.getHeader("Cookie"))
+            assertNull(laterRequest.getHeader("Authorization"))
+        }
+
+    @Test
+    fun `logout clears the held device token so the next request carries no Authorization header`() =
+        runBlocking {
+            enqueueLoginOk()
+            enqueueDeviceTokenOk()
+            val fixture = fixture(server.url("/").toString())
+            fixture.repository.login("alice", "secret")
+            server.takeRequest()
+            server.takeRequest()
+
+            fixture.repository.logout()
+
+            assertEquals(AuthState.LoggedOut, fixture.repository.authState.first())
+            assertNull(fixture.deviceTokenStore.load())
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            fixture.hhoApiClient.getStatus()
+            assertNull(server.takeRequest().getHeader("Authorization"))
+        }
+
+    @Test
+    fun `a 401 from a server-side revocation clears the stored device token and flips authState to LoggedOut`() =
+        runBlocking {
+            enqueueLoginOk()
+            enqueueDeviceTokenOk(token = "device-token-xyz")
+            val fixture = fixture(server.url("/").toString())
+            fixture.repository.login("alice", "secret")
+            server.takeRequest()
+            server.takeRequest()
+            assertEquals(AuthState.LoggedIn, fixture.repository.authState.first())
+            assertEquals(StoredToken(token = "device-token-xyz", instanceUrl = server.url("/").toString()), fixture.deviceTokenStore.load())
+
+            server.enqueue(
+                MockResponse()
+                    .setResponseCode(401)
+                    .setHeader("WWW-Authenticate", "Bearer")
+                    .setHeader("Content-Type", "application/problem+json")
+                    .setBody("""{"type":"about:blank","title":"Unauthorized","status":401}"""),
+            )
+
+            val result = fixture.hhoApiClient.getStatus()
+
+            assertTrue("a revoked device's next call must fail, not succeed", result.isFailure)
+
+            assertNull("the revoked token must be gone from the durable store", fixture.deviceTokenStore.load())
+            assertEquals(AuthState.LoggedOut, fixture.repository.authState.first())
+        }
+
+    @Test
+    fun `after server-side revocation, the client stops retrying with the dead credential`() =
+        runBlocking {
+            enqueueLoginOk()
+            enqueueDeviceTokenOk(token = "device-token-xyz")
+            val fixture = fixture(server.url("/").toString())
+            fixture.repository.login("alice", "secret")
+            server.takeRequest()
+            server.takeRequest()
+            server.enqueue(MockResponse().setResponseCode(401).setHeader("WWW-Authenticate", "Bearer"))
+            fixture.hhoApiClient.getStatus()
+            server.takeRequest()
+
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            fixture.hhoApiClient.getStatus()
+
+            assertNull(server.takeRequest().getHeader("Authorization"))
+        }
+
+    @Test
+    fun `a 401 on a request that carried no Authorization header never clears an unrelated stored token`() =
+        runBlocking {
+            val unrelatedToken = StoredToken(token = "token-for-other-instance", instanceUrl = "https://other.example.com/")
+            val sharedTokenStore = FakeDeviceTokenStore(unrelatedToken)
+            val fixture = fixture(server.url("/").toString(), deviceTokenStore = sharedTokenStore)
+            server.enqueue(MockResponse().setResponseCode(401).setHeader("WWW-Authenticate", "Bearer"))
+
+            val result = fixture.hhoApiClient.getStatus()
+
+            assertTrue(result.isFailure)
+            assertNull(server.takeRequest().getHeader("Authorization"))
+            assertEquals(unrelatedToken, fixture.deviceTokenStore.load())
+        }
+
+    @Test
+    fun `a token issued for instance A is not sent after the configured instance changes to B, and authState reads LoggedOut`() =
+        runBlocking {
+            val serverA = server
+            val serverB = MockWebServer()
+            try {
+                enqueueLoginOk(serverA)
+                enqueueDeviceTokenOk(serverA, token = "token-for-a")
+                val instanceDataStoreFile = tempDataStoreFile()
+                val sharedTokenStore = FakeDeviceTokenStore()
+                val fixture = fixture(
+                    instanceUrl = serverA.url("/").toString(),
+                    instanceDataStoreFile = instanceDataStoreFile,
+                    deviceTokenStore = sharedTokenStore,
+                )
+
+                val loginResult = fixture.repository.login("alice", "secret")
+                assertTrue(loginResult.isSuccess)
+                assertEquals(AuthState.LoggedIn, fixture.repository.authState.first())
+
+                fixture.instanceDataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = serverB.url("/").toString() }
+
+                assertEquals(AuthState.LoggedOut, fixture.repository.authState.first())
+
+                serverB.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+                fixture.hhoApiClient.getStatus()
+                val requestToB = serverB.takeRequest()
+                assertNull("server B must never see server A's device token", requestToB.getHeader("Authorization"))
+            } finally {
+                serverB.shutdown()
+            }
+        }
+
+    @Test
+    fun `reconnecting back to the original instance reactivates its token without a fresh login`() =
+        runBlocking {
+            val serverA = server
+            val serverB = MockWebServer()
+            try {
+                enqueueLoginOk(serverA)
+                enqueueDeviceTokenOk(serverA, token = "token-for-a")
+                val instanceDataStoreFile = tempDataStoreFile()
+                val sharedTokenStore = FakeDeviceTokenStore()
+                val fixture = fixture(
+                    instanceUrl = serverA.url("/").toString(),
+                    instanceDataStoreFile = instanceDataStoreFile,
+                    deviceTokenStore = sharedTokenStore,
+                )
+                fixture.repository.login("alice", "secret")
+                fixture.instanceDataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = serverB.url("/").toString() }
+                assertEquals(AuthState.LoggedOut, fixture.repository.authState.first())
+
+                fixture.instanceDataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = serverA.url("/").toString() }
+
+                assertEquals(AuthState.LoggedIn, fixture.repository.authState.first())
+            } finally {
+                serverB.shutdown()
+            }
+        }
+
+    @Test
+    fun `authState and the held token are restored from durable storage across a simulated restart`() =
+        runBlocking {
+            enqueueLoginOk()
+            enqueueDeviceTokenOk(token = "restart-token")
+            val sharedTokenStore = FakeDeviceTokenStore()
+            val instanceUrl = server.url("/").toString()
+
+            val fixtureBeforeRestart = fixture(instanceUrl = instanceUrl, deviceTokenStore = sharedTokenStore)
+            fixtureBeforeRestart.repository.login("alice", "secret")
+            assertEquals(AuthState.LoggedIn, fixtureBeforeRestart.repository.authState.first())
+
+            val fixtureAfterRestart = fixture(instanceUrl = instanceUrl, deviceTokenStore = sharedTokenStore)
+
+            assertEquals(AuthState.LoggedIn, fixtureAfterRestart.repository.authState.first())
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"status":"ok","version":"1.0.0","schema_version":1}"""))
+            fixtureAfterRestart.hhoApiClient.getStatus()
+            server.takeRequest()
+            server.takeRequest()
+            assertEquals("Bearer restart-token", server.takeRequest().getHeader("Authorization"))
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/auth/DeviceIdProviderTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/auth/DeviceIdProviderTest.kt
new file mode 100644
index 0000000..66765a3
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/auth/DeviceIdProviderTest.kt
@@ -0,0 +1,69 @@
+package dev.hho.android.data.auth
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import dev.hho.android.data.settings.SettingsKeys
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.io.File
+import java.util.UUID
+
+class DeviceIdProviderTest {
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("device-id-provider-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    @Test
+    fun `generates and persists a random UUID on first call`() =
+        runBlocking {
+            val dataStore = tempDataStore()
+            val provider = DataStoreDeviceIdProvider(dataStore)
+
+            val id = provider.deviceId()
+
+            assertNotNull(id)
+            UUID.fromString(id)
+            assertEquals(id, dataStore.data.first()[SettingsKeys.DEVICE_ID])
+        }
+
+    @Test
+    fun `returns the same id on every subsequent call`() =
+        runBlocking {
+            val provider = DataStoreDeviceIdProvider(tempDataStore())
+
+            val first = provider.deviceId()
+            val second = provider.deviceId()
+            val third = provider.deviceId()
+
+            assertEquals(first, second)
+            assertEquals(first, third)
+        }
+
+    @Test
+    fun `stays stable across independently constructed instances sharing the same DataStore file (survives a process restart)`() =
+        runBlocking {
+            val dataStore = tempDataStore()
+
+            val idBeforeRestart = DataStoreDeviceIdProvider(dataStore).deviceId()
+            val idAfterRestart = DataStoreDeviceIdProvider(dataStore).deviceId()
+
+            assertEquals(idBeforeRestart, idAfterRestart)
+        }
+
+    @Test
+    fun `two different DataStore files (a reinstall) get two different ids`() =
+        runBlocking {
+            val idA = DataStoreDeviceIdProvider(tempDataStore()).deviceId()
+            val idB = DataStoreDeviceIdProvider(tempDataStore()).deviceId()
+
+            assertTrue(idA != idB)
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/auth/FakeDeviceTokenStore.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/auth/FakeDeviceTokenStore.kt
new file mode 100644
index 0000000..c5be2f8
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/auth/FakeDeviceTokenStore.kt
@@ -0,0 +1,15 @@
+package dev.hho.android.data.auth
+
+class FakeDeviceTokenStore(initial: StoredToken? = null) : DeviceTokenStore {
+    private var stored: StoredToken? = initial
+
+    override suspend fun load(): StoredToken? = stored
+
+    override suspend fun save(token: StoredToken) {
+        stored = token
+    }
+
+    override suspend fun clear() {
+        stored = null
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/auth/InstanceScopedDeviceTokenProviderTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/auth/InstanceScopedDeviceTokenProviderTest.kt
new file mode 100644
index 0000000..8ee3564
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/auth/InstanceScopedDeviceTokenProviderTest.kt
@@ -0,0 +1,135 @@
+package dev.hho.android.data.auth
+
+import kotlinx.coroutines.runBlocking
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class InstanceScopedDeviceTokenProviderTest {
+
+    @Test
+    fun `no token stored means no token returned`() =
+        runBlocking {
+            val provider = InstanceScopedDeviceTokenProvider(FakeDeviceTokenStore())
+
+            assertNull(provider.tokenFor("https://hho.example.com/api/v1/status".toHttpUrl()))
+        }
+
+    @Test
+    fun `a token bound to the request's exact host and port is returned`() =
+        runBlocking {
+            val store = FakeDeviceTokenStore(StoredToken(token = "device-token-xyz", instanceUrl = "https://hho.example.com/"))
+            val provider = InstanceScopedDeviceTokenProvider(store)
+
+            assertEquals("device-token-xyz", provider.tokenFor("https://hho.example.com/api/v1/status".toHttpUrl()))
+        }
+
+    @Test
+    fun `a token bound to a different host than the request is refused`() =
+        runBlocking {
+            val store = FakeDeviceTokenStore(StoredToken(token = "token-for-a", instanceUrl = "https://a.example.com/"))
+            val provider = InstanceScopedDeviceTokenProvider(store)
+
+            assertNull(provider.tokenFor("https://b.example.com/api/v1/status".toHttpUrl()))
+        }
+
+    @Test
+    fun `a token bound to a different port on the same host is refused`() =
+        runBlocking {
+            val store = FakeDeviceTokenStore(StoredToken(token = "token-for-8443", instanceUrl = "https://hho.example.com:8443/"))
+            val provider = InstanceScopedDeviceTokenProvider(store)
+
+            assertNull(provider.tokenFor("https://hho.example.com:9443/api/v1/status".toHttpUrl()))
+        }
+
+    @Test
+    fun `a token bound to a different scheme on the same host and port is refused`() =
+        runBlocking {
+            val store = FakeDeviceTokenStore(StoredToken(token = "token-for-https", instanceUrl = "https://hho.example.com/"))
+            val provider = InstanceScopedDeviceTokenProvider(store)
+
+            assertNull(provider.tokenFor("http://hho.example.com/api/v1/status".toHttpUrl()))
+        }
+
+    @Test
+    fun `a token bound to a reverse-proxy prefix is returned for a request under that exact prefix`() =
+        runBlocking {
+            val store = FakeDeviceTokenStore(StoredToken(token = "token-for-hho", instanceUrl = "https://ex.com/hho"))
+            val provider = InstanceScopedDeviceTokenProvider(store)
+
+            assertEquals("token-for-hho", provider.tokenFor("https://ex.com/hho/api/v1/status".toHttpUrl()))
+        }
+
+    @Test
+    fun `a token bound to a reverse-proxy prefix is refused for a request whose segment merely starts with the same characters`() =
+        runBlocking {
+            val store = FakeDeviceTokenStore(StoredToken(token = "token-for-hho", instanceUrl = "https://ex.com/hho"))
+            val provider = InstanceScopedDeviceTokenProvider(store)
+
+            assertNull(provider.tokenFor("https://ex.com/hhox/api/v1/status".toHttpUrl()))
+        }
+
+    @Test
+    fun `a token bound to a reverse-proxy prefix is refused for a request with no prefix at all`() =
+        runBlocking {
+            val store = FakeDeviceTokenStore(StoredToken(token = "token-for-hho", instanceUrl = "https://ex.com/hho"))
+            val provider = InstanceScopedDeviceTokenProvider(store)
+
+            assertNull(provider.tokenFor("https://ex.com/api/v1/status".toHttpUrl()))
+        }
+
+    @Test
+    fun `a token bound to a bare origin (no prefix) is returned for any path under that host`() =
+        runBlocking {
+            val store = FakeDeviceTokenStore(StoredToken(token = "token-for-bare", instanceUrl = "https://ex.com/"))
+            val provider = InstanceScopedDeviceTokenProvider(store)
+
+            assertEquals("token-for-bare", provider.tokenFor("https://ex.com/api/v1/status".toHttpUrl()))
+            assertEquals("token-for-bare", provider.tokenFor("https://ex.com/anything/else".toHttpUrl()))
+        }
+
+    @Test
+    fun `invalidate clears a token that is still bound to the request's instance and still has the rejected value`() =
+        runBlocking {
+            val store = FakeDeviceTokenStore(StoredToken(token = "device-token-xyz", instanceUrl = "https://hho.example.com/"))
+            val provider = InstanceScopedDeviceTokenProvider(store)
+
+            provider.invalidate("https://hho.example.com/api/v1/status".toHttpUrl(), rejectedToken = "device-token-xyz")
+
+            assertNull("the rejected token must be gone from the durable store, not merely from the read side", store.load())
+        }
+
+    @Test
+    fun `invalidate is a no-op when nothing is stored`() =
+        runBlocking {
+            val store = FakeDeviceTokenStore()
+            val provider = InstanceScopedDeviceTokenProvider(store)
+
+            provider.invalidate("https://hho.example.com/api/v1/status".toHttpUrl(), rejectedToken = "some-token")
+
+            assertNull(store.load())
+        }
+
+    @Test
+    fun `invalidate never touches a token bound to a different instance than the rejected request`() =
+        runBlocking {
+            val store = FakeDeviceTokenStore(StoredToken(token = "token-for-a", instanceUrl = "https://a.example.com/"))
+            val provider = InstanceScopedDeviceTokenProvider(store)
+
+            provider.invalidate("https://b.example.com/api/v1/status".toHttpUrl(), rejectedToken = "token-for-a")
+
+            assertEquals(StoredToken(token = "token-for-a", instanceUrl = "https://a.example.com/"), store.load())
+        }
+
+    @Test
+    fun `invalidate never clears a newer token for the same instance that no longer matches the rejected value (TOCTOU safety)`() =
+        runBlocking {
+            val store = FakeDeviceTokenStore(StoredToken(token = "brand-new-token", instanceUrl = "https://hho.example.com/"))
+            val provider = InstanceScopedDeviceTokenProvider(store)
+
+            provider.invalidate("https://hho.example.com/api/v1/status".toHttpUrl(), rejectedToken = "stale-token")
+
+            assertEquals(StoredToken(token = "brand-new-token", instanceUrl = "https://hho.example.com/"), store.load())
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/auth/KeystoreDeviceTokenStoreTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/auth/KeystoreDeviceTokenStoreTest.kt
new file mode 100644
index 0000000..ff35e82
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/auth/KeystoreDeviceTokenStoreTest.kt
@@ -0,0 +1,110 @@
+package dev.hho.android.data.auth
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Test
+import java.io.File
+import javax.crypto.KeyGenerator
+import javax.crypto.SecretKey
+
+class KeystoreDeviceTokenStoreTest {
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("device-token-store-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    private fun softwareAesKey(): SecretKey = KeyGenerator.getInstance("AES").apply { init(256) }.generateKey()
+
+    private fun store(
+        dataStore: DataStore<Preferences> = tempDataStore(),
+        key: SecretKey = softwareAesKey(),
+    ): KeystoreDeviceTokenStore = KeystoreDeviceTokenStore(dataStore, AesGcmDeviceTokenCipher(secretKey = { key }))
+
+    @Test
+    fun `load returns null when nothing has ever been saved`() =
+        runBlocking {
+            assertNull(store().load())
+        }
+
+    @Test
+    fun `save then load round-trips the token and its instance url`() =
+        runBlocking {
+            val tokenStore = store()
+
+            tokenStore.save(StoredToken(token = "device-token-xyz", instanceUrl = "https://hho.example.com/"))
+            val loaded = tokenStore.load()
+
+            assertEquals(StoredToken(token = "device-token-xyz", instanceUrl = "https://hho.example.com/"), loaded)
+        }
+
+    @Test
+    fun `clear removes the stored token`() =
+        runBlocking {
+            val tokenStore = store()
+            tokenStore.save(StoredToken(token = "device-token-xyz", instanceUrl = "https://hho.example.com/"))
+
+            tokenStore.clear()
+
+            assertNull(tokenStore.load())
+        }
+
+    @Test
+    fun `save overwrites whatever was stored before`() =
+        runBlocking {
+            val tokenStore = store()
+            tokenStore.save(StoredToken(token = "first-token", instanceUrl = "https://a.example.com/"))
+
+            tokenStore.save(StoredToken(token = "second-token", instanceUrl = "https://b.example.com/"))
+
+            assertEquals(StoredToken(token = "second-token", instanceUrl = "https://b.example.com/"), tokenStore.load())
+        }
+
+    @Test
+    fun `a token saved with one key cannot be decrypted with another`() =
+        runBlocking {
+            val dataStore = tempDataStore()
+            store(dataStore, key = softwareAesKey()).save(
+                StoredToken(token = "device-token-xyz", instanceUrl = "https://hho.example.com/"),
+            )
+
+            val loadedWithWrongKey = store(dataStore, key = softwareAesKey()).load()
+
+            assertNull(loadedWithWrongKey)
+        }
+
+    @Test
+    fun `editing the persisted instance url after save invalidates the ciphertext (AAD binding)`() =
+        runBlocking {
+            val dataStore = tempDataStore()
+            val tokenStore = store(dataStore)
+            tokenStore.save(StoredToken(token = "device-token-xyz", instanceUrl = "https://a.example.com/"))
+
+            dataStore.edit { it[stringPreferencesKey("device_token_instance_url")] = "https://attacker.example.com/" }
+
+            assertNull(tokenStore.load())
+        }
+
+    @Test
+    fun `the persisted preference value never contains the plaintext token`() =
+        runBlocking {
+            val dataStore = tempDataStore()
+            val tokenStore = store(dataStore)
+            val secretToken = "super-secret-device-token-value"
+
+            tokenStore.save(StoredToken(token = secretToken, instanceUrl = "https://hho.example.com/"))
+
+            val rawPrefs = dataStore.data.first()
+            val ciphertextB64 = rawPrefs.asMap().values.joinToString { it.toString() }
+            assertFalse(ciphertextB64.contains(secretToken))
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/ids/UuidV7GeneratorTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/ids/UuidV7GeneratorTest.kt
new file mode 100644
index 0000000..7b1e551
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/ids/UuidV7GeneratorTest.kt
@@ -0,0 +1,101 @@
+package dev.hho.android.data.ids
+
+import java.util.Random
+import java.util.UUID
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class UuidV7GeneratorTest {
+    private class FixedRandom(private val long: Long, private val int: Int) : Random() {
+        override fun nextLong(): Long = long
+        override fun nextInt(bound: Int): Int = int
+    }
+
+    private fun cmp(a: UUID, b: UUID): Int {
+        val m = java.lang.Long.compareUnsigned(a.mostSignificantBits, b.mostSignificantBits)
+        return if (m != 0) m else java.lang.Long.compareUnsigned(a.leastSignificantBits, b.leastSignificantBits)
+    }
+
+    private fun millisOf(u: UUID): Long = u.mostSignificantBits ushr 16
+
+    @Test
+    fun layoutMatchesRfc9562ForFixedClockAndRandom() {
+        val ms = 0x0123_4567_89ABL
+        val gen = UuidV7Generator({ ms }, FixedRandom(-1L, 0x155))
+        val id = gen.next()
+        assertEquals("01234567-89ab-7155-bfff-ffffffffffff", id.toString())
+        assertEquals(ms, millisOf(id))
+        assertEquals(7, (id.mostSignificantBits ushr 12).toInt() and 0xF)
+        assertEquals(0b10L, id.leastSignificantBits ushr 62)
+    }
+
+    @Test
+    fun zeroRandomKeepsVersionAndVariantBits() {
+        val id = UuidV7Generator({ 1L }, FixedRandom(0L, 0)).next()
+        assertEquals("00000000-0001-7000-8000-000000000000", id.toString())
+    }
+
+    @Test
+    fun stringFormIsLowercaseCanonical() {
+        val s = UuidV7Generator({ 0xABCDEF012345L }, FixedRandom(-1L, 0xABC and 0x7FF)).generate()
+        assertEquals(s.lowercase(), s)
+        assertTrue(Regex("[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}").matches(s))
+        assertEquals(UUID.fromString(s).toString(), s)
+    }
+
+    @Test
+    fun strictlyIncreasingWithinOneMillisecond() {
+        val gen = UuidV7Generator({ 1_000L }, Random(1))
+        val ids = List(2_000) { gen.next() }
+        ids.zipWithNext().forEach { (a, b) ->
+            assertTrue("$a < $b", cmp(a, b) < 0)
+            assertTrue(a.toString() < b.toString())
+        }
+    }
+
+    @Test
+    fun strictlyIncreasingAcrossMilliseconds() {
+        var now = 5_000L
+        val gen = UuidV7Generator({ now }, Random(2))
+        val ids = buildList {
+            repeat(50) { step ->
+                now += step % 3
+                add(gen.next())
+            }
+        }
+        ids.zipWithNext().forEach { (a, b) ->
+            assertTrue(cmp(a, b) < 0)
+            assertTrue(a.toString() < b.toString())
+        }
+    }
+
+    @Test
+    fun counterOverflowBorrowsNextMillisecondAndStaysOrdered() {
+        val gen = UuidV7Generator({ 9_000L }, Random(3))
+        val ids = List(10_000) { gen.next() }
+        ids.zipWithNext().forEach { (a, b) -> assertTrue(cmp(a, b) < 0) }
+        assertTrue(millisOf(ids.last()) > 9_000L)
+    }
+
+    @Test
+    fun clockRegressionNeverProducesSmallerId() {
+        var now = 10_000L
+        val gen = UuidV7Generator({ now }, Random(4))
+        val first = gen.next()
+        now = 3_000L
+        val second = gen.next()
+        assertTrue(cmp(first, second) < 0)
+        assertEquals(millisOf(first), millisOf(second))
+        now = 20_000L
+        val third = gen.next()
+        assertTrue(cmp(second, third) < 0)
+        assertEquals(20_000L, millisOf(third))
+    }
+
+    @Test
+    fun tenThousandIdsAreUnique() {
+        val gen = UuidV7Generator()
+        assertEquals(10_000, List(10_000) { gen.generate() }.toSet().size)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/items/ItemSearchTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/items/ItemSearchTest.kt
new file mode 100644
index 0000000..91d26dd
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/items/ItemSearchTest.kt
@@ -0,0 +1,242 @@
+package dev.hho.android.data.items
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemIdentificationEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ItemSearchTest {
+
+    private lateinit var db: HhoDatabase
+    private lateinit var search: ItemSearch
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        search = ItemSearch(db.itemDao())
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+    }
+
+    private fun itemFixture(id: String, name: String, shortCode: String? = null) =
+        ItemEntity(
+            id = id,
+            groupChangeSeq = 1L,
+            name = name,
+            description = null,
+            locationId = null,
+            quantity = 1L,
+            shortCode = shortCode,
+            createdAt = 1L,
+            updatedAt = 1L,
+            version = 1L,
+        )
+
+    private fun identifierFixture(id: String, itemId: String, value: String, kind: String = "barcode") =
+        ItemIdentificationEntity(
+            id = id,
+            groupChangeSeq = 1L,
+            itemId = itemId,
+            kind = kind,
+            value = value,
+            createdAt = 1L,
+            updatedAt = 1L,
+            version = 1L,
+        )
+
+    @Test
+    fun `blank query returns every synced item, sorted by name`() = runTest {
+        db.itemDao().upsert(itemFixture("item-2", name = "Saw"))
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+
+        val results = search.results("").first()
+
+        assertEquals(listOf("item-1", "item-2"), results.map { it.id })
+    }
+
+    @Test
+    fun `whitespace-only query is treated the same as a blank one`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+
+        val results = search.results("   ").first()
+
+        assertEquals(listOf("item-1"), results.map { it.id })
+    }
+
+    @Test
+    fun `matches a substring of the item name`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Cordless Drill"))
+        db.itemDao().upsert(itemFixture("item-2", name = "Table Saw"))
+
+        val results = search.results("Drill").first()
+
+        assertEquals(listOf("item-1"), results.map { it.id })
+    }
+
+    @Test
+    fun `matches a substring of the short code`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Cordless Drill", shortCode = "DRL-42"))
+        db.itemDao().upsert(itemFixture("item-2", name = "Table Saw", shortCode = "SAW-1"))
+
+        val results = search.results("drl").first()
+
+        assertEquals(listOf("item-1"), results.map { it.id })
+    }
+
+    @Test
+    fun `matches a substring of a linked identifier value`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Cordless Drill"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-1", itemId = "item-1", value = "EAN-1234567890"))
+
+        val results = search.results("1234567").first()
+
+        assertEquals(listOf("item-1"), results.map { it.id })
+    }
+
+    @Test
+    fun `matching is case-insensitive across name, short code, and identifier value`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Cordless Drill", shortCode = "drl-42"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-1", itemId = "item-1", value = "eAn-999"))
+
+        assertEquals(listOf("item-1"), search.results("DRILL").first().map { it.id })
+        assertEquals(listOf("item-1"), search.results("DRL-42").first().map { it.id })
+        assertEquals(listOf("item-1"), search.results("ean-999").first().map { it.id })
+    }
+
+    @Test
+    fun `an item is not duplicated when its name and one of its identifiers both match`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-1", itemId = "item-1", value = "drill-barcode"))
+
+        val results = search.results("drill").first()
+
+        assertEquals(listOf("item-1"), results.map { it.id })
+    }
+
+    @Test
+    fun `an item is not duplicated when more than one of its identifiers matches`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-1", itemId = "item-1", value = "drill-barcode-1"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-2", itemId = "item-1", value = "drill-barcode-2"))
+
+        val results = search.results("drill").first()
+
+        assertEquals(listOf("item-1"), results.map { it.id })
+    }
+
+    @Test
+    fun `a literal percent sign in the query is matched literally, not treated as a wildcard`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "100% Cotton Rag"))
+        db.itemDao().upsert(itemFixture("item-2", name = "1000 Screws"))
+
+        val results = search.results("100%").first()
+
+        assertEquals(listOf("item-1"), results.map { it.id })
+    }
+
+    @Test
+    fun `a literal underscore in the query is matched literally, not treated as a single-char wildcard`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Cordless Drill"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-1", itemId = "item-1", value = "SKU_123"))
+        db.itemDao().upsert(itemFixture("item-2", name = "Table Saw"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-2", itemId = "item-2", value = "SKUX123"))
+
+        val results = search.results("SKU_123").first()
+
+        assertEquals(listOf("item-1"), results.map { it.id })
+    }
+
+    @Test
+    fun `findByIdentifierValue resolves the exact barcode to its owning item`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Cordless Drill"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-1", itemId = "item-1", value = "EAN-1234567890"))
+
+        val results = search.findByIdentifierValue("EAN-1234567890")
+
+        assertEquals(listOf("item-1"), results.map { it.id })
+    }
+
+    @Test
+    fun `findByIdentifierValue is exact, not substring — a partial value finds nothing`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Cordless Drill"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-1", itemId = "item-1", value = "EAN-1234567890"))
+
+        val results = search.findByIdentifierValue("1234567")
+
+        assertEquals(emptyList<String>(), results.map { it.id })
+    }
+
+    @Test
+    fun `findByIdentifierValue with no matching identifier returns an empty list, not a crash`() = runTest {
+        val results = search.findByIdentifierValue("does-not-exist")
+
+        assertEquals(emptyList<String>(), results.map { it.id })
+    }
+
+    @Test
+    fun `findByIdentifierValue is case-sensitive and does not trim`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Cordless Drill"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-1", itemId = "item-1", value = "EAN-abc"))
+
+        assertEquals(emptyList<String>(), search.findByIdentifierValue("ean-ABC").map { it.id })
+        assertEquals(emptyList<String>(), search.findByIdentifierValue(" EAN-abc").map { it.id })
+        assertEquals(listOf("item-1"), search.findByIdentifierValue("EAN-abc").map { it.id })
+    }
+
+    @Test
+    fun `findByIdentifierValue returns each item once even with duplicate identifiers, and all sharing items`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        db.itemDao().upsert(itemFixture("item-2", name = "Saw"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-1", itemId = "item-1", value = "X1", kind = "barcode"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-2", itemId = "item-1", value = "X1", kind = "qr"))
+        db.itemIdentificationDao().upsert(identifierFixture("ident-3", itemId = "item-2", value = "X1"))
+
+        assertEquals(setOf("item-1", "item-2"), search.findByIdentifierValue("X1").map { it.id }.toSet())
+        assertEquals(2, search.findByIdentifierValue("X1").size)
+    }
+
+    @Test
+    fun `an identifier orphaned from any item does not resolve or match`() = runTest {
+        db.itemIdentificationDao().upsert(identifierFixture("ident-1", itemId = "gone", value = "ORPHAN"))
+
+        assertEquals(emptyList<String>(), search.findByIdentifierValue("ORPHAN").map { it.id })
+        assertEquals(emptyList<String>(), search.results("ORPHAN").first().map { it.id })
+    }
+
+    @Test
+    fun `a non-ASCII query still matches with the same case`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Ölkanne"))
+
+        assertEquals(listOf("item-1"), search.results("Öl").first().map { it.id })
+    }
+
+    @Test
+    fun `results re-emits when a new matching identifier is synced`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        val flow = search.results("ZZ99")
+        assertEquals(emptyList<String>(), flow.first().map { it.id })
+
+        db.itemIdentificationDao().upsert(identifierFixture("ident-1", itemId = "item-1", value = "ZZ99"))
+
+        assertEquals(listOf("item-1"), flow.first().map { it.id })
+    }
+
+    @Test
+    fun `likePatternFor wraps the query and escapes backslash, percent, and underscore`() {
+        assertEquals("%50\\%\\_off\\\\ish%", likePatternFor("50%_off\\ish"))
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/network/AuthHeaderBaseUrlTocTouTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/network/AuthHeaderBaseUrlTocTouTest.kt
new file mode 100644
index 0000000..c2201a4
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/network/AuthHeaderBaseUrlTocTouTest.kt
@@ -0,0 +1,94 @@
+package dev.hho.android.data.network
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.preferencesOf
+import dev.hho.android.data.auth.FakeDeviceTokenStore
+import dev.hho.android.data.auth.InstanceScopedDeviceTokenProvider
+import dev.hho.android.data.auth.StoredToken
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.runBlocking
+import okhttp3.Request
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+import java.util.concurrent.atomic.AtomicInteger
+
+class AuthHeaderBaseUrlTocTouTest {
+
+    private val server = MockWebServer()
+
+    @After
+    fun tearDown() {
+        server.shutdown()
+    }
+
+    private class SequentialInstanceUrlDataStore(private val urlsByCallIndex: List<String>) : DataStore<Preferences> {
+        val callCount = AtomicInteger(0)
+
+        override val data: Flow<Preferences> =
+            flow {
+                val index = callCount.getAndIncrement().coerceAtMost(urlsByCallIndex.size - 1)
+                emit(preferencesOf(SettingsKeys.INSTANCE_BASE_URL to urlsByCallIndex[index]))
+            }
+
+        override suspend fun updateData(transform: suspend (t: Preferences) -> Preferences): Preferences =
+            throw UnsupportedOperationException("read-only fake — this test never writes through it")
+    }
+
+    @Test
+    fun `exactly one instance-url read happens per request, so the attach decision can never see a different instance than the routing decision`() =
+        runBlocking {
+            val instanceA = server.url("/").toString()
+            val instanceB = "https://instance-b.invalid/"
+            val sequentialDataStore = SequentialInstanceUrlDataStore(listOf(instanceA, instanceB))
+            val resolver = InstanceBaseUrlResolver(sequentialDataStore)
+            val deviceTokenStore = FakeDeviceTokenStore(StoredToken(token = "token-for-a", instanceUrl = instanceA))
+            val tokenProvider = InstanceScopedDeviceTokenProvider(deviceTokenStore)
+            val baseUrlInterceptor = BaseUrlInterceptor(resolver)
+            val authHeaderInterceptor = AuthHeaderInterceptor(tokenProvider)
+            val clientVersionInterceptor = ClientVersionInterceptor()
+            val httpClient =
+                NetworkModule.provideOkHttpClient(baseUrlInterceptor, authHeaderInterceptor, clientVersionInterceptor)
+
+            server.enqueue(MockResponse().setResponseCode(200))
+            httpClient
+                .newCall(Request.Builder().url("http://placeholder.invalid/api/v1/status").build())
+                .execute()
+                .close()
+
+            assertEquals(1, sequentialDataStore.callCount.get())
+            val recorded = server.takeRequest()
+            assertEquals("Bearer token-for-a", recorded.getHeader("Authorization"))
+        }
+
+    @Test
+    fun `a token bound to an instance the resolver no longer reports is never attached, regardless of read timing`() =
+        runBlocking {
+            val instanceA = "https://instance-a.invalid/"
+            val instanceB = server.url("/").toString()
+            val sequentialDataStore = SequentialInstanceUrlDataStore(listOf(instanceB))
+            val resolver = InstanceBaseUrlResolver(sequentialDataStore)
+            val deviceTokenStore = FakeDeviceTokenStore(StoredToken(token = "token-for-a", instanceUrl = instanceA))
+            val tokenProvider = InstanceScopedDeviceTokenProvider(deviceTokenStore)
+            val baseUrlInterceptor = BaseUrlInterceptor(resolver)
+            val authHeaderInterceptor = AuthHeaderInterceptor(tokenProvider)
+            val clientVersionInterceptor = ClientVersionInterceptor()
+            val httpClient =
+                NetworkModule.provideOkHttpClient(baseUrlInterceptor, authHeaderInterceptor, clientVersionInterceptor)
+
+            server.enqueue(MockResponse().setResponseCode(200))
+            httpClient
+                .newCall(Request.Builder().url("http://placeholder.invalid/api/v1/status").build())
+                .execute()
+                .close()
+
+            assertNull("server B (the actually-routed instance) must never see server A's device token", server.takeRequest().getHeader("Authorization"))
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/network/AuthHeaderInterceptorTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/network/AuthHeaderInterceptorTest.kt
new file mode 100644
index 0000000..3650e94
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/network/AuthHeaderInterceptorTest.kt
@@ -0,0 +1,111 @@
+package dev.hho.android.data.network
+
+import dev.hho.android.data.auth.DeviceTokenProvider
+import okhttp3.HttpUrl
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class AuthHeaderInterceptorTest {
+
+    private val server = MockWebServer()
+
+    @After
+    fun tearDown() {
+        server.shutdown()
+    }
+
+    private fun clientWithToken(token: String?): OkHttpClient {
+        val provider = fixedTokenProvider(token)
+        return OkHttpClient.Builder().addInterceptor(AuthHeaderInterceptor(provider)).build()
+    }
+
+    @Test
+    fun `a stored token is attached as a Bearer Authorization header`() {
+        server.enqueue(MockResponse().setResponseCode(200))
+        val client = clientWithToken("secret-device-token")
+
+        client.newCall(Request.Builder().url(server.url("/api/v1/status")).build()).execute().close()
+
+        assertEquals("Bearer secret-device-token", server.takeRequest().getHeader("Authorization"))
+    }
+
+    @Test
+    fun `no stored token sends no Authorization header at all`() {
+        server.enqueue(MockResponse().setResponseCode(200))
+        val client = clientWithToken(null)
+
+        client.newCall(Request.Builder().url(server.url("/api/v1/status")).build()).execute().close()
+
+        assertNull(server.takeRequest().getHeader("Authorization"))
+    }
+
+    @Test
+    fun `a blank stored token sends no Authorization header at all`() {
+        server.enqueue(MockResponse().setResponseCode(200))
+        val client = clientWithToken("   ")
+
+        client.newCall(Request.Builder().url(server.url("/api/v1/status")).build()).execute().close()
+
+        assertNull(server.takeRequest().getHeader("Authorization"))
+    }
+
+    @Test
+    fun `an existing Authorization header on the request is overwritten, never duplicated`() {
+        server.enqueue(MockResponse().setResponseCode(200))
+        val client = clientWithToken("fresh-token")
+
+        client
+            .newCall(
+                Request.Builder()
+                    .url(server.url("/api/v1/status"))
+                    .header("Authorization", "Bearer stale-token")
+                    .build(),
+            ).execute()
+            .close()
+
+        val recorded = server.takeRequest()
+        assertEquals("Bearer fresh-token", recorded.getHeader("Authorization"))
+        assertEquals(1, recorded.headers.values("Authorization").size)
+    }
+
+    @Test
+    fun `the actual outgoing request url is what gets passed to the token provider (T156e TOCTOU fix)`() {
+        server.enqueue(MockResponse().setResponseCode(200))
+        var capturedUrl: HttpUrl? = null
+        val provider =
+            object : DeviceTokenProvider {
+                override suspend fun tokenFor(requestUrl: HttpUrl): String? {
+                    capturedUrl = requestUrl
+                    return "token-for-captured-url"
+                }
+
+                override suspend fun invalidate(
+                    requestUrl: HttpUrl,
+                    rejectedToken: String,
+                ) = Unit
+            }
+        val client = OkHttpClient.Builder().addInterceptor(AuthHeaderInterceptor(provider)).build()
+        val requestUrl = server.url("/api/v1/status")
+
+        client.newCall(Request.Builder().url(requestUrl).build()).execute().close()
+
+        assertEquals(requestUrl, capturedUrl)
+        assertEquals("Bearer token-for-captured-url", server.takeRequest().getHeader("Authorization"))
+    }
+}
+
+private fun fixedTokenProvider(token: String?): DeviceTokenProvider =
+    object : DeviceTokenProvider {
+        override suspend fun tokenFor(requestUrl: HttpUrl): String? = token
+
+        override suspend fun invalidate(
+            requestUrl: HttpUrl,
+            rejectedToken: String,
+        ) = Unit
+    }
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/network/BaseUrlInterceptorTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/network/BaseUrlInterceptorTest.kt
new file mode 100644
index 0000000..f406fb5
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/network/BaseUrlInterceptorTest.kt
@@ -0,0 +1,106 @@
+package dev.hho.android.data.network
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import dev.hho.android.data.settings.SettingsKeys
+import kotlinx.coroutines.runBlocking
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+import java.io.File
+import java.io.IOException
+
+class BaseUrlInterceptorTest {
+
+    private val server = MockWebServer()
+
+    @After
+    fun tearDown() {
+        server.shutdown()
+    }
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("hho-interceptor-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    private fun clientConfiguredFor(instanceUrl: String): OkHttpClient {
+        val dataStore = tempDataStore()
+        runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = instanceUrl } }
+        val interceptor = BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore))
+        return OkHttpClient.Builder().addInterceptor(interceptor).build()
+    }
+
+    private fun clientWithNoInstanceConfigured(): OkHttpClient {
+        val interceptor = BaseUrlInterceptor(InstanceBaseUrlResolver(tempDataStore()))
+        return OkHttpClient.Builder().addInterceptor(interceptor).build()
+    }
+
+    @Test
+    fun `bare origin sends the request path unchanged`() {
+        server.enqueue(MockResponse().setResponseCode(200))
+        val client = clientConfiguredFor(server.url("/").toString())
+
+        val placeholder = "http://placeholder.invalid/api/v1/status".toHttpUrl()
+        client.newCall(Request.Builder().url(placeholder).build()).execute().close()
+
+        assertEquals("/api/v1/status", server.takeRequest().path)
+    }
+
+    @Test
+    fun `origin with a path prefix without trailing slash is prepended`() {
+        server.enqueue(MockResponse().setResponseCode(200))
+        val client = clientConfiguredFor(server.url("/hho").toString())
+
+        val placeholder = "http://placeholder.invalid/api/v1/status".toHttpUrl()
+        client.newCall(Request.Builder().url(placeholder).build()).execute().close()
+
+        assertEquals("/hho/api/v1/status", server.takeRequest().path)
+    }
+
+    @Test
+    fun `origin with a path prefix with a trailing slash is prepended without a double slash`() {
+        server.enqueue(MockResponse().setResponseCode(200))
+        val client = clientConfiguredFor(server.url("/hho/").toString())
+
+        val placeholder = "http://placeholder.invalid/api/v1/status".toHttpUrl()
+        client.newCall(Request.Builder().url(placeholder).build()).execute().close()
+
+        assertEquals("/hho/api/v1/status", server.takeRequest().path)
+    }
+
+    @Test
+    fun `request query string is preserved alongside a path prefix`() {
+        server.enqueue(MockResponse().setResponseCode(200))
+        val client = clientConfiguredFor(server.url("/hho").toString())
+
+        val placeholder = "http://placeholder.invalid/api/v1/sync/pull?since=5&limit=10".toHttpUrl()
+        client.newCall(Request.Builder().url(placeholder).build()).execute().close()
+
+        assertEquals("/hho/api/v1/sync/pull?since=5&limit=10", server.takeRequest().path)
+    }
+
+    @Test
+    fun `no instance url configured throws NoInstanceUrlConfiguredException`() {
+        val client = clientWithNoInstanceConfigured()
+        val placeholder = "http://placeholder.invalid/api/v1/status".toHttpUrl()
+
+        val thrown =
+            assertThrows(IOException::class.java) {
+                client.newCall(Request.Builder().url(placeholder).build()).execute()
+            }
+
+        assert(thrown is NoInstanceUrlConfiguredException) {
+            "expected NoInstanceUrlConfiguredException, got $thrown"
+        }
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/network/ClientVersionInterceptorTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/network/ClientVersionInterceptorTest.kt
new file mode 100644
index 0000000..4477772
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/network/ClientVersionInterceptorTest.kt
@@ -0,0 +1,48 @@
+package dev.hho.android.data.network
+
+import dev.hho.android.BuildConfig
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class ClientVersionInterceptorTest {
+
+    private val server = MockWebServer()
+
+    @After
+    fun tearDown() {
+        server.shutdown()
+    }
+
+    private fun clientWithInterceptor(): OkHttpClient =
+        OkHttpClient.Builder().addInterceptor(ClientVersionInterceptor()).build()
+
+    @Test
+    fun `sets the header to BuildConfig HHO_CLIENT_VERSION on a request that had none`() {
+        server.enqueue(MockResponse().setResponseCode(200))
+        val request = Request.Builder().url(server.url("/")).build()
+
+        clientWithInterceptor().newCall(request).execute().close()
+
+        assertEquals(BuildConfig.HHO_CLIENT_VERSION, server.takeRequest().getHeader("X-HHO-Client-Version"))
+    }
+
+    @Test
+    fun `replaces rather than duplicates a header the request already carried`() {
+        server.enqueue(MockResponse().setResponseCode(200))
+        val request =
+            Request.Builder()
+                .url(server.url("/"))
+                .header("X-HHO-Client-Version", "9.9.9-should-be-overwritten")
+                .build()
+
+        clientWithInterceptor().newCall(request).execute().close()
+
+        val recorded = server.takeRequest()
+        assertEquals(listOf(BuildConfig.HHO_CLIENT_VERSION), recorded.headers.values("X-HHO-Client-Version"))
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/network/InstanceBaseUrlResolverTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/network/InstanceBaseUrlResolverTest.kt
new file mode 100644
index 0000000..47f7755
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/network/InstanceBaseUrlResolverTest.kt
@@ -0,0 +1,97 @@
+package dev.hho.android.data.network
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import dev.hho.android.data.settings.SettingsKeys
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.io.File
+
+class InstanceBaseUrlResolverTest {
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("hho-settings-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    @Test
+    fun `resolves NotConfigured when no url has ever been stored`() =
+        runBlocking {
+            val resolver = InstanceBaseUrlResolver(tempDataStore())
+
+            assertEquals(BaseUrlResolution.NotConfigured, resolver.resolve())
+        }
+
+    @Test
+    fun `resolves Configured with the stored url`() =
+        runBlocking {
+            val dataStore = tempDataStore()
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "https://hho.example.com" }
+
+            val resolution = InstanceBaseUrlResolver(dataStore).resolve()
+
+            val configured = resolution as? BaseUrlResolution.Configured
+            assertEquals("hho.example.com", configured?.baseUrl?.host)
+            assertEquals("https", configured?.baseUrl?.scheme)
+        }
+
+    @Test
+    fun `resolves NotConfigured when the stored value does not parse as a url`() =
+        runBlocking {
+            val dataStore = tempDataStore()
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "not a url" }
+
+            val resolution = InstanceBaseUrlResolver(dataStore).resolve()
+
+            assertTrue(resolution is BaseUrlResolution.NotConfigured)
+        }
+
+    @Test
+    fun `reflects a url changed after the resolver was created, without caching`() =
+        runBlocking {
+            val dataStore = tempDataStore()
+            val resolver = InstanceBaseUrlResolver(dataStore)
+            assertTrue(resolver.resolve() is BaseUrlResolution.NotConfigured)
+
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "https://second.example.com" }
+
+            val resolution = resolver.resolve()
+            assertEquals("second.example.com", (resolution as BaseUrlResolution.Configured).baseUrl.host)
+        }
+
+    @Test
+    fun `resolutionFlow reflects the value currently in DataStore on first collection`() =
+        runBlocking {
+            val dataStore = tempDataStore()
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "https://hho.example.com" }
+
+            val resolution = InstanceBaseUrlResolver(dataStore).resolutionFlow().first()
+
+            assertEquals("hho.example.com", (resolution as BaseUrlResolution.Configured).baseUrl.host)
+        }
+
+    @Test
+    fun `resolutionFlow re-emits when a different collaborator writes a new instance url`() =
+        runBlocking {
+            val dataStore = tempDataStore()
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "https://first.example.com" }
+            val resolver = InstanceBaseUrlResolver(dataStore)
+
+            val emissions =
+                resolver.resolutionFlow().let { flow ->
+                    val first = flow.first()
+                    dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "https://second.example.com" }
+                    val second = flow.first()
+                    listOf(first, second)
+                }
+
+            assertEquals("first.example.com", (emissions[0] as BaseUrlResolution.Configured).baseUrl.host)
+            assertEquals("second.example.com", (emissions[1] as BaseUrlResolution.Configured).baseUrl.host)
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/network/InstanceUrlNormalizerTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/network/InstanceUrlNormalizerTest.kt
new file mode 100644
index 0000000..156bafc
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/network/InstanceUrlNormalizerTest.kt
@@ -0,0 +1,92 @@
+package dev.hho.android.data.network
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class InstanceUrlNormalizerTest {
+
+    @Test
+    fun `bare https origin normalises unchanged`() {
+        val result = InstanceUrlNormalizer.normalize("https://hho.example.com")
+        val valid = result as InstanceUrlNormalization.Valid
+        assertEquals("https", valid.url.scheme)
+        assertEquals("hho.example.com", valid.url.host)
+        assertTrue(valid.url.pathSegments.filterNot { it.isEmpty() }.isEmpty())
+    }
+
+    @Test
+    fun `http scheme on a LAN address is accepted, not rejected as insecure`() {
+        val result = InstanceUrlNormalizer.normalize("http://192.168.1.10:7745")
+        val valid = result as InstanceUrlNormalization.Valid
+        assertEquals("http", valid.url.scheme)
+        assertEquals("192.168.1.10", valid.url.host)
+        assertEquals(7745, valid.url.port)
+    }
+
+    @Test
+    fun `surrounding whitespace is trimmed`() {
+        val result = InstanceUrlNormalizer.normalize("  https://hho.example.com  ")
+        val valid = result as InstanceUrlNormalization.Valid
+        assertEquals("hho.example.com", valid.url.host)
+    }
+
+    @Test
+    fun `a trailing slash on the bare origin is stripped`() {
+        val result = InstanceUrlNormalizer.normalize("https://hho.example.com/")
+        val valid = result as InstanceUrlNormalization.Valid
+        assertEquals("https://hho.example.com/", valid.url.toString())
+        assertTrue(valid.url.pathSegments.filterNot { it.isEmpty() }.isEmpty())
+    }
+
+    @Test
+    fun `a reverse-proxy path prefix is kept`() {
+        val result = InstanceUrlNormalizer.normalize("https://example.com/hho")
+        val valid = result as InstanceUrlNormalization.Valid
+        assertEquals(listOf("hho"), valid.url.pathSegments)
+        assertEquals("https://example.com/hho", valid.url.toString())
+    }
+
+    @Test
+    fun `a trailing slash on a path prefix is stripped but the prefix itself is kept`() {
+        val result = InstanceUrlNormalizer.normalize("https://example.com/hho/")
+        val valid = result as InstanceUrlNormalization.Valid
+        assertEquals("https://example.com/hho", valid.url.toString())
+    }
+
+    @Test
+    fun `a missing scheme is rejected, never silently defaulted`() {
+        val result = InstanceUrlNormalizer.normalize("hho.example.com")
+        assertTrue(result is InstanceUrlNormalization.Invalid)
+    }
+
+    @Test
+    fun `blank input is rejected`() {
+        val result = InstanceUrlNormalizer.normalize("   ")
+        assertTrue(result is InstanceUrlNormalization.Invalid)
+    }
+
+    @Test
+    fun `userinfo is rejected`() {
+        val result = InstanceUrlNormalizer.normalize("https://user:pass@example.com")
+        assertTrue(result is InstanceUrlNormalization.Invalid)
+    }
+
+    @Test
+    fun `a query string is rejected`() {
+        val result = InstanceUrlNormalizer.normalize("https://example.com/hho?debug=1")
+        assertTrue(result is InstanceUrlNormalization.Invalid)
+    }
+
+    @Test
+    fun `a fragment is rejected`() {
+        val result = InstanceUrlNormalizer.normalize("https://example.com/hho#section")
+        assertTrue(result is InstanceUrlNormalization.Invalid)
+    }
+
+    @Test
+    fun `an unparsable value is rejected`() {
+        val result = InstanceUrlNormalizer.normalize("https://")
+        assertTrue(result is InstanceUrlNormalization.Invalid)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/LedgerFakeServer.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/LedgerFakeServer.kt
new file mode 100644
index 0000000..ecc7df8
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/LedgerFakeServer.kt
@@ -0,0 +1,106 @@
+package dev.hho.android.data.outbox
+
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.RecordedRequest
+import okhttp3.mockwebserver.SocketPolicy
+
+internal class LedgerFakeServer : Dispatcher() {
+    enum class Fault { NONE, SERVER_ERROR_500, APPLY_THEN_DROP_RESPONSE }
+
+    private val ledger = HashSet<String>()
+
+    val appliedCount = HashMap<String, Int>()
+
+    val applyOrder = ArrayList<String>()
+
+    val entityState = HashMap<String, MutableMap<String, String>>()
+
+    val versions = HashMap<String, Long>()
+
+    val baseVersions = HashMap<String, Long>()
+
+    val poisonedEntityIds = HashSet<String>()
+    var pushRequests = 0
+        private set
+    val faults = ArrayDeque<Fault>()
+
+    val batchSizes = ArrayList<Int>()
+
+    val sentIds = ArrayList<List<String>>()
+
+    val requestBodies = ArrayList<String>()
+
+    val skippedCount = HashMap<String, Int>()
+
+    val opById = HashMap<String, String>()
+
+    val fieldsById = HashMap<String, JsonObject>()
+
+    override fun dispatch(request: RecordedRequest): MockResponse {
+        if (request.path.orEmpty().endsWith("/sync/push").not()) return json(404, """{"title":"x","status":404}""")
+        pushRequests++
+        val fault = faults.removeFirstOrNull() ?: Fault.NONE
+        if (fault == Fault.SERVER_ERROR_500) {
+            return json(500, """{"type":"about:blank","title":"boom","status":500}""")
+        }
+        val bodyText = request.body.readUtf8()
+        requestBodies += bodyText
+        val muts = Json.parseToJsonElement(bodyText).jsonObject["mutations"]!!.jsonArray.map { it.jsonObject }
+        batchSizes += muts.size
+        sentIds += muts.map { it["mutation_id"]!!.jsonPrimitive.content }
+        muts.forEachIndexed { i, m ->
+            if (m["entity_id"]!!.jsonPrimitive.content in poisonedEntityIds) {
+                val id = m["mutation_id"]!!.jsonPrimitive.content
+                return MockResponse().setResponseCode(400)
+                    .setHeader("Content-Type", "application/problem+json")
+                    .setBody(
+                        """{"type":"about:blank","title":"Bad Request","status":400,""" +
+                            """"detail":"mutations[$i] (mutation_id=\"$id\"): unsupported field"}""",
+                    )
+            }
+        }
+        val applied = ArrayList<String>()
+        val skipped = ArrayList<String>()
+        for (m in muts) {
+            val id = m["mutation_id"]!!.jsonPrimitive.content
+            val type = m["entity_type"]!!.jsonPrimitive.content
+            val entity = m["entity_id"]!!.jsonPrimitive.content
+            if (!ledger.add(id)) {
+                skippedCount.merge(id, 1, Int::plus)
+                skipped += """{"mutation_id":"$id"}"""
+                continue
+            }
+            val key = "$type/$entity"
+            val version = (versions[key] ?: 0L) + 1
+            versions[key] = version
+            appliedCount.merge(id, 1, Int::plus)
+            applyOrder += id
+            baseVersions[id] = m["base_version"]!!.jsonPrimitive.content.toLong()
+            val fields: JsonObject = m["fields"]!!.jsonObject
+            opById[id] = m["op"]?.jsonPrimitive?.content ?: "upsert"
+            fieldsById[id] = fields
+            val state = entityState.getOrPut(key) { HashMap() }
+            fields.forEach { (k, v) -> state[k] = v.jsonPrimitive.content }
+            applied += """{"mutation_id":"$id","entity_type":"$type","entity_id":"$entity","version":$version}"""
+        }
+        val response = json(
+            200,
+            """{"applied":[${applied.joinToString(",")}],"skipped":[${skipped.joinToString(",")}],""" +
+                """"conflicts":[],"new_watermark":99}""",
+        )
+        return if (fault == Fault.APPLY_THEN_DROP_RESPONSE) {
+            response.setSocketPolicy(SocketPolicy.DISCONNECT_AFTER_REQUEST)
+        } else {
+            response
+        }
+    }
+
+    private fun json(status: Int, body: String) =
+        MockResponse().setResponseCode(status).setHeader("Content-Type", "application/json").setBody(body)
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/LedgerTestSupport.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/LedgerTestSupport.kt
new file mode 100644
index 0000000..4d83d89
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/LedgerTestSupport.kt
@@ -0,0 +1,32 @@
+package dev.hho.android.data.outbox
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.edit
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import okhttp3.HttpUrl
+import okhttp3.Interceptor
+import okhttp3.mockwebserver.MockWebServer
+import java.io.File
+
+internal fun ledgerApiClient(server: MockWebServer, extraInterceptors: List<Interceptor> = emptyList()): HhoApiClient {
+    val prefs = File.createTempFile("ledger-api", ".preferences_pb").also { it.deleteOnExit() }
+    val dataStore = PreferenceDataStoreFactory.create(produceFile = { prefs })
+    runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() } }
+    val cv = ClientVersionInterceptor()
+    val provider = object : DeviceTokenProvider {
+        override suspend fun tokenFor(requestUrl: HttpUrl): String? = "tok"
+
+        override suspend fun invalidate(requestUrl: HttpUrl, rejectedToken: String) = Unit
+    }
+    val base = NetworkModule.provideOkHttpClient(BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore)), AuthHeaderInterceptor(provider), cv)
+    val http = base.newBuilder().apply { extraInterceptors.forEach { addInterceptor(it) } }.build()
+    return HhoApiClient(http, NetworkModule.provideProbeOkHttpClient(http, cv))
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/OutboxDurabilityTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/OutboxDurabilityTest.kt
new file mode 100644
index 0000000..aaca802
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/OutboxDurabilityTest.kt
@@ -0,0 +1,359 @@
+package dev.hho.android.data.outbox
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.work.BackoffPolicy
+import androidx.work.ListenableWorker
+import androidx.work.WorkRequest
+import androidx.work.WorkerFactory
+import androidx.work.WorkerParameters
+import androidx.work.testing.TestListenableWorkerBuilder
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceIdProvider
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.OutboxMutationEntity
+import dev.hho.android.data.room.OutboxState
+import dev.hho.android.data.room.deleteHhoDatabaseFile
+import dev.hho.android.data.room.fileHhoDatabase
+import dev.hho.android.data.sync.OutboxSyncer
+import dev.hho.android.data.sync.PushPhaseOutcome
+import dev.hho.android.data.sync.SyncRunRecorder
+import dev.hho.android.data.sync.SyncScheduler
+import dev.hho.android.data.sync.SyncWorker
+import dev.hho.android.data.sync.testSyncEngine
+import dev.hho.android.domain.AuthRepository
+import dev.hho.android.domain.AuthState
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class OutboxDurabilityTest {
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(60)
+
+    private val server = MockWebServer()
+    private val ledger = LedgerFakeServer()
+    private val dbs = mutableListOf<HhoDatabase>()
+    private val dbName = "outbox-durability-${System.nanoTime()}"
+    private var now = 1_000L
+
+    @Before
+    fun setUp() {
+        deleteHhoDatabaseFile(dbName)
+        server.dispatcher = ledger
+    }
+
+    @After
+    fun tearDown() {
+        dbs.forEach { runCatching { it.close() } }
+        deleteHhoDatabaseFile(dbName)
+        server.shutdown()
+    }
+
+    @Test
+    fun `kill after enqueue loses no row and keeps seq order`() =
+        runBlocking {
+            val before = open()
+            val ids = listOf("a", "b", "c", "d").map { OutboxRepository(before, clock = { now++ }).enqueue(edit(it, "v-$it")).mutationId }
+            val seqsBefore = before.outboxDao().getAllOrdered().map { it.seq }
+            before.close()
+
+            val after = open()
+            val rows = after.outboxDao().getAllOrdered()
+            assertEquals(ids, rows.map { it.mutationId })
+            assertEquals(seqsBefore, rows.map { it.seq })
+            assertEquals(seqsBefore.sorted(), seqsBefore)
+            assertTrue(rows.all { it.state == OutboxState.PENDING })
+
+            assertEquals(PushPhaseOutcome.Drained, syncer(after).push(DEVICE))
+            assertTrue(after.outboxDao().getAllOrdered().isEmpty())
+            assertEquals("applied in seq order", ids, ledger.applyOrder)
+            listOf("a", "b", "c", "d").forEach { assertEquals("v-$it", ledger.entityState["item/$it"]!!["name"]) }
+        }
+
+    @Test
+    fun `kill with request sent but no ack - in-flight rows recover and replay is skipped, not duplicated`() =
+        runBlocking {
+            val before = open()
+            val repo = OutboxRepository(before, clock = { now++ })
+            val ids = listOf("a", "b", "c").map { repo.enqueue(edit(it, "v-$it")).mutationId }
+            val batch = repo.nextBatch()
+            repo.markInFlight(batch.map { it.mutationId })
+            assertTrue(api().syncPush(DEVICE, batch.map { it.toPushMutation() }).isSuccess)
+            before.close()
+
+            val after = open()
+            val stale = after.outboxDao().getAllOrdered()
+            assertEquals(ids, stale.map { it.mutationId })
+            assertTrue("rows are still IN_FLIGHT after the kill", stale.all { it.state == OutboxState.IN_FLIGHT })
+            assertTrue(OutboxRepository(after).nextBatch().isEmpty())
+
+            assertEquals(PushPhaseOutcome.Drained, syncer(after).push(DEVICE))
+            assertTrue(after.outboxDao().getAllOrdered().isEmpty())
+            assertEquals(2, ledger.pushRequests)
+            ids.forEach { assertEquals("applied exactly once: $it", 1, ledger.appliedCount[it]) }
+            listOf("a", "b", "c").forEach { assertEquals("v-$it", ledger.entityState["item/$it"]!!["name"]) }
+        }
+
+    @Test
+    fun `resetInFlightToPending after a reopen restores every in-flight row in seq order`() =
+        runBlocking {
+            val before = open()
+            val repo = OutboxRepository(before, clock = { now++ })
+            val ids = listOf("a", "b", "c").map { repo.enqueue(edit(it, "v-$it")).mutationId }
+            repo.markInFlight(ids)
+            before.close()
+
+            val after = open()
+            val repo2 = OutboxRepository(after)
+            assertTrue(repo2.nextBatch().isEmpty())
+            assertEquals(3, repo2.resetInFlightToPending())
+            assertEquals(ids, repo2.nextBatch().map { it.mutationId })
+            assertTrue(after.outboxDao().getAllOrdered().all { it.lastAttemptAt != null })
+        }
+
+    @Test
+    fun `kill after ack keeps the released follower in order rebased on the acked version`() =
+        runBlocking {
+            val before = open()
+            val repo = OutboxRepository(before, clock = { now++ })
+            val first = repo.enqueue(edit("a", "one", base = 1))
+            val other = repo.enqueue(edit("b", "other", base = 1))
+            repo.markInFlight(listOf(first.mutationId))
+            val follower = repo.enqueue(edit("a", "two", base = 1))
+            assertEquals(OutboxState.HELD, follower.state)
+            val sent = before.outboxDao().getByMutationId(first.mutationId)!!
+            assertTrue(api().syncPush(DEVICE, listOf(sent.toPushMutation())).isSuccess)
+            repo.ack(first.mutationId, 1L)
+            before.close()
+
+            val after = open()
+            val rows = after.outboxDao().getAllOrdered()
+            assertEquals(listOf(other.mutationId, follower.mutationId), rows.map { it.mutationId })
+            assertTrue(rows[0].seq < rows[1].seq)
+            assertTrue(rows.all { it.state == OutboxState.PENDING })
+            assertEquals("follower rebased onto the acked version", 1L, rows[1].baseVersion)
+
+            assertEquals(PushPhaseOutcome.Drained, syncer(after).push(DEVICE))
+            assertTrue(after.outboxDao().getAllOrdered().isEmpty())
+            assertEquals(1, ledger.appliedCount[first.mutationId])
+            assertEquals("two", ledger.entityState["item/a"]!!["name"])
+            assertEquals("other", ledger.entityState["item/b"]!!["name"])
+            assertEquals(2L, ledger.versions["item/a"])
+        }
+
+    @Test
+    fun `a lost response is replayed with the same mutation ids and never applied twice`() =
+        runBlocking {
+            val db = open()
+            val repo = OutboxRepository(db, clock = { now++ })
+            val ids = listOf("a", "b", "c").map { repo.enqueue(edit(it, "v-$it")).mutationId }
+            ledger.faults += LedgerFakeServer.Fault.APPLY_THEN_DROP_RESPONSE
+
+            val first = syncer(db).push(DEVICE)
+            assertTrue("transport failure surfaces as Failed: $first", first is PushPhaseOutcome.Failed)
+            ids.forEach { assertEquals("server applied it once already", 1, ledger.appliedCount[it]) }
+            val queued = db.outboxDao().getAllOrdered()
+            assertEquals("rows survive the lost response", ids, queued.map { it.mutationId })
+            assertTrue(queued.all { it.attemptCount == 1 && it.state == OutboxState.PENDING })
+
+            assertEquals(PushPhaseOutcome.Drained, syncer(db).push(DEVICE))
+
+            assertEquals("replay used the same ids", ledger.sentIds[0], ledger.sentIds[1])
+            assertEquals(ids, ledger.sentIds[1])
+            ids.forEach { assertEquals("zero duplicate applications: $it", 1, ledger.appliedCount[it]) }
+            assertEquals(1L, ledger.versions["item/a"])
+            assertEquals("v-a", ledger.entityState["item/a"]!!["name"])
+            assertTrue(db.outboxDao().getAllOrdered().isEmpty())
+        }
+
+    @Test
+    fun `an edit made after a lost response is held behind the possibly-sent row, then applied once, in order`() =
+        runBlocking {
+            val db = open()
+            val repo = OutboxRepository(db, clock = { now++ })
+            val first = repo.enqueue(edit("a", "one")).mutationId
+            ledger.faults += LedgerFakeServer.Fault.APPLY_THEN_DROP_RESPONSE
+            assertTrue(syncer(db).push(DEVICE) is PushPhaseOutcome.Failed)
+
+            val second = repo.enqueue(edit("a", "two"))
+            assertTrue("never merged into a possibly-sent row", !second.coalesced && second.mutationId != first)
+            assertEquals(OutboxState.HELD, second.state)
+
+            assertEquals(PushPhaseOutcome.Drained, syncer(db).push(DEVICE))
+            val left = db.outboxDao().getAllOrdered()
+            assertEquals(listOf(second.mutationId), left.map { it.mutationId })
+            assertEquals(1, ledger.appliedCount[first])
+            assertEquals("one", ledger.entityState["item/a"]!!["name"])
+            repo.releaseHeld { _, _ -> 1L }
+            assertEquals(PushPhaseOutcome.Drained, syncer(db).push(DEVICE))
+            assertEquals("two", ledger.entityState["item/a"]!!["name"])
+            assertEquals(listOf(first, second.mutationId), ledger.applyOrder)
+            assertTrue(db.outboxDao().getAllOrdered().isEmpty())
+        }
+
+    @Test
+    fun `repeated 5xx grows attempt_count each run and the worker returns retry every time`() =
+        runBlocking {
+            val db = open()
+            val repo = OutboxRepository(db, clock = { now++ })
+            val id = repo.enqueue(edit("a", "one")).mutationId
+            val engine = testSyncEngine(api(), db, repo)
+            repeat(4) { ledger.faults += LedgerFakeServer.Fault.SERVER_ERROR_500 }
+
+            for (run in 1..4) {
+                val result = worker(engine, db).doWork()
+                assertEquals("run $run", ListenableWorker.Result.retry(), result)
+                val row = db.outboxDao().getByMutationId(id)!!
+                assertEquals("attempt_count after run $run", run, row.attemptCount)
+                assertEquals(OutboxState.PENDING, row.state)
+                assertTrue(row.lastError != null)
+            }
+            assertEquals("no pull was attempted, only pushes", 4, server.requestCount)
+
+            assertEquals(PushPhaseOutcome.Drained, syncer(db).push(DEVICE))
+            assertEquals(1, ledger.appliedCount[id])
+            assertTrue(db.outboxDao().getAllOrdered().isEmpty())
+        }
+
+    @Test
+    fun `the sync work requests use exponential backoff`() {
+        val onDemand = SyncScheduler.buildOnDemandRequest().workSpec
+        val periodic = SyncScheduler.buildPeriodicRequest().workSpec
+        assertEquals(BackoffPolicy.EXPONENTIAL, onDemand.backoffPolicy)
+        assertEquals(BackoffPolicy.EXPONENTIAL, periodic.backoffPolicy)
+        assertEquals(WorkRequest.MIN_BACKOFF_MILLIS, onDemand.backoffDelayDuration)
+        val delays = (1..4).map { attempts ->
+            onDemand.also { it.runAttemptCount = attempts }.calculateNextRunTime() - onDemand.lastEnqueueTime
+        }
+        assertEquals(delays.sorted(), delays)
+        assertEquals(delays[0] * 2, delays[1])
+        assertEquals(delays[1] * 2, delays[2])
+        assertEquals(delays[2] * 2, delays[3])
+    }
+
+    @Test
+    fun `a poisoned mutation is quarantined, the rest apply, and it is never resent`() =
+        runBlocking {
+            val db = open()
+            val repo = OutboxRepository(db, clock = { now++ })
+            val good1 = repo.enqueue(edit("a", "v-a")).mutationId
+            val bad = repo.enqueue(edit("bad", "v-bad")).mutationId
+            val good2 = repo.enqueue(edit("c", "v-c")).mutationId
+            ledger.poisonedEntityIds += "bad"
+
+            assertEquals(PushPhaseOutcome.Drained, syncer(db).push(DEVICE))
+
+            val left = db.outboxDao().getAllOrdered()
+            assertEquals(listOf(bad), left.map { it.mutationId })
+            assertEquals(OutboxState.FAILED, left.single().state)
+            assertTrue(left.single().lastError!!.contains(bad))
+            assertEquals(listOf(good1, good2), ledger.applyOrder)
+            assertEquals("v-a", ledger.entityState["item/a"]!!["name"])
+            assertEquals("v-c", ledger.entityState["item/c"]!!["name"])
+            assertTrue(ledger.entityState["item/bad"] == null)
+
+            val requestsBefore = ledger.pushRequests
+            ledger.sentIds.clear()
+            assertEquals(PushPhaseOutcome.Drained, syncer(db).push(DEVICE))
+            assertEquals("nothing left to send: no request", requestsBefore, ledger.pushRequests)
+
+            val next = repo.enqueue(edit("d", "v-d")).mutationId
+            assertEquals(PushPhaseOutcome.Drained, syncer(db).push(DEVICE))
+            assertEquals(listOf(next), ledger.sentIds.flatten())
+            assertTrue(bad !in ledger.sentIds.flatten())
+            assertEquals(listOf(bad), db.outboxDao().getAllOrdered().map { it.mutationId })
+        }
+
+    @Test
+    fun `a poisoned row survives a kill and is still not resent after reopen`() =
+        runBlocking {
+            val before = open()
+            val repo = OutboxRepository(before, clock = { now++ })
+            val bad = repo.enqueue(edit("bad", "x")).mutationId
+            repo.enqueue(edit("a", "v-a"))
+            ledger.poisonedEntityIds += "bad"
+            assertEquals(PushPhaseOutcome.Drained, syncer(before).push(DEVICE))
+            before.close()
+
+            val after = open()
+            ledger.sentIds.clear()
+            assertEquals(PushPhaseOutcome.Drained, syncer(after).push(DEVICE))
+            assertTrue(ledger.sentIds.isEmpty())
+            val row = after.outboxDao().getByMutationId(bad)!!
+            assertEquals(OutboxState.FAILED, row.state)
+        }
+
+    @Test
+    fun `a row whose fields_json cannot be decoded does not wedge the push`() =
+        runBlocking {
+            val db = open()
+            val repo = OutboxRepository(db, clock = { now++ })
+            val good1 = repo.enqueue(edit("a", "v-a")).mutationId
+            val corrupt = OutboxMutationEntity(
+                mutationId = "corrupt-1", entityType = "item", entityId = "zzz", op = "upsert", baseVersion = 1,
+                fieldsJson = "{not json", state = OutboxState.PENDING, createdAt = now++,
+            )
+            db.outboxDao().insert(corrupt)
+            val good2 = repo.enqueue(edit("c", "v-c")).mutationId
+
+            val outcome = runCatching { syncer(db).push(DEVICE) }
+
+            assertTrue(
+                "push must neither throw nor leave the healthy rows stuck; outcome=$outcome ledger=${ledger.applyOrder}",
+                outcome.isSuccess && ledger.applyOrder.containsAll(listOf(good1, good2)),
+            )
+            val remaining = db.outboxDao().getAllOrdered()
+            assertTrue("healthy rows drained: $remaining", remaining.none { it.mutationId == good1 || it.mutationId == good2 })
+            assertEquals("corrupt row kept for D4.6, not retried", OutboxState.FAILED, remaining.single().state)
+        }
+
+    private fun open(): HhoDatabase = fileHhoDatabase(dbName).also { dbs += it }
+
+    private fun syncer(db: HhoDatabase) = OutboxSyncer(db, api(), OutboxRepository(db, clock = { now++ }), clock = { now++ })
+
+    private fun edit(id: String, name: String, base: Long = 1) =
+        LocalMutation("item", id, "upsert", base, buildJsonObject { put("name", JsonPrimitive(name)) })
+
+    private fun api(): HhoApiClient = ledgerApiClient(server)
+
+    private fun worker(engine: dev.hho.android.data.sync.SyncEngine, db: HhoDatabase): SyncWorker {
+        val context = ApplicationProvider.getApplicationContext<Context>()
+        val auth = object : AuthRepository {
+            override val authState: Flow<AuthState> = MutableStateFlow(AuthState.LoggedIn)
+
+            override suspend fun login(username: String, password: String): Result<Unit> = error("unused")
+
+            override suspend fun logout() = error("unused")
+        }
+        val ids = object : DeviceIdProvider {
+            override suspend fun deviceId(): String = DEVICE
+        }
+        return TestListenableWorkerBuilder<SyncWorker>(context)
+            .setWorkerFactory(
+                object : WorkerFactory() {
+                    override fun createWorker(appContext: Context, workerClassName: String, workerParameters: WorkerParameters) =
+                        SyncWorker(appContext, workerParameters, engine, ids, auth, SyncRunRecorder(db.syncRunStateDao()))
+                },
+            ).build()
+    }
+
+    private companion object {
+        const val DEVICE = "dev-1"
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/OutboxOverlayTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/OutboxOverlayTest.kt
new file mode 100644
index 0000000..9286fdb
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/OutboxOverlayTest.kt
@@ -0,0 +1,225 @@
+package dev.hho.android.data.outbox
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemLabelEntity
+import dev.hho.android.data.room.OutboxMutationEntity
+import dev.hho.android.data.room.OutboxState
+import dev.hho.android.data.room.PurchasedFromBlockEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.sync.SyncMirrorApplier
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertThrows
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.time.LocalDate
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class OutboxOverlayTest {
+    private lateinit var db: HhoDatabase
+    private var n = 0
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+    }
+
+    @After
+    fun tearDown() = db.close()
+
+    private fun item(id: String, qty: Long = 5, name: String = "Drill") =
+        ItemEntity(id, 1, name, "d", "loc-1", qty, "SC1", 10, 20, 3)
+
+    private suspend fun queue(
+        type: String, id: String, fields: String, op: String = "upsert", base: Long = 0, state: String = OutboxState.PENDING,
+    ): Long = db.outboxDao().insert(
+        OutboxMutationEntity(
+            mutationId = "m-${n++}", entityType = type, entityId = id, op = op, baseVersion = base,
+            fieldsJson = fields, state = state, createdAt = 0,
+        ),
+    )
+
+    private fun m(type: String, id: String, fields: String, op: String = "upsert", base: Long = 0) =
+        LocalMutation(type, id, op, base, kotlinx.serialization.json.Json.parseToJsonElement(fields) as kotlinx.serialization.json.JsonObject)
+
+    @Test
+    fun itemCreate_writesRowWithoutShortCodeOrQuantity() = runTest {
+        assertEquals(true, OptimisticApplier.apply(db, m("item", "i1", """{"name":"Saw","description":"x","location_id":"l1"}""")))
+        val row = db.itemDao().getById("i1")!!
+        assertEquals("Saw", row.name)
+        assertEquals("l1", row.locationId)
+        assertNull(row.shortCode)
+        assertEquals(0L, row.quantity)
+        assertEquals(0L, row.version)
+    }
+
+    @Test
+    fun itemUpdate_changesOnlyNamedFields_andNullClears() = runTest {
+        db.itemDao().upsert(item("i1"))
+        OptimisticApplier.apply(db, m("item", "i1", """{"name":"New","description":null}""", base = 3))
+        val row = db.itemDao().getById("i1")!!
+        assertEquals("New", row.name)
+        assertNull(row.description)
+        assertEquals("loc-1", row.locationId)
+        assertEquals("SC1", row.shortCode)
+        assertEquals(3L, row.version)
+        OptimisticApplier.apply(db, m("item", "i1", """{"location_id":"l2"}""", base = 3))
+        assertEquals("l2", db.itemDao().getById("i1")!!.locationId)
+    }
+
+    @Test
+    fun itemMutationCarryingQuantity_isRejected() = runTest {
+        assertThrows(UnsupportedMutationException::class.java) {
+            kotlinx.coroutines.runBlocking { OptimisticApplier.apply(db, m("item", "i1", """{"name":"a","quantity":9}""")) }
+        }
+    }
+
+    @Test
+    fun updateOnAbsentRow_isSkipped_forItemAndPurchase() = runTest {
+        assertEquals(false, OptimisticApplier.apply(db, m("item", "gone", """{"name":"x"}""", base = 2)))
+        assertNull(db.itemDao().getById("gone"))
+        assertEquals(false, OptimisticApplier.apply(db, m("purchased_from_block", "p1", """{"item_id":"i1","vendor":"V"}""", base = 2)))
+        assertNull(db.purchasedFromBlockDao().getByItemId("i1"))
+    }
+
+    @Test
+    fun stockAdjustmentCreate_writesHistoryRow_butNotItemQuantity() = runTest {
+        db.itemDao().upsert(item("i1", qty = 5))
+        OptimisticApplier.apply(db, m("stock_adjustment", "s1", """{"item_id":"i1","delta":2,"reason":"found","note":"n"}"""))
+        assertEquals(5L, db.itemDao().getById("i1")!!.quantity)
+        val h = db.stockAdjustmentDao().observeByItemId("i1").first().single()
+        assertEquals(2L, h.delta)
+        assertEquals(7L, h.resultingQuantity)
+        assertEquals("found", h.reason)
+        assertEquals("n", h.note)
+    }
+
+    @Test
+    fun itemLabel_upsertThenDelete() = runTest {
+        OptimisticApplier.apply(db, m("item_label", "e1", """{"item_id":"i1","label_id":"lb1"}"""))
+        assertEquals(listOf(ItemLabelEntity("e1", 0, "i1", "lb1")), db.itemLabelDao().observeByItemId("i1").first())
+        OptimisticApplier.apply(db, m("item_label", "e1", """{"item_id":"i1","label_id":"lb1"}""", op = "delete"))
+        assertEquals(emptyList<ItemLabelEntity>(), db.itemLabelDao().observeByItemId("i1").first())
+    }
+
+    @Test
+    fun identificationCreate_writesRow() = runTest {
+        OptimisticApplier.apply(db, m("item_identification", "d1", """{"item_id":"i1","kind":"barcode","value":"123"}"""))
+        val row = db.itemIdentificationDao().findByValue("123").single()
+        assertEquals("d1", row.id)
+        assertEquals("i1", row.itemId)
+        assertEquals("barcode", row.kind)
+    }
+
+    @Test
+    fun purchaseCreateThenUpdate() = runTest {
+        OptimisticApplier.apply(
+            db,
+            m("purchased_from_block", "p1", """{"item_id":"i1","vendor":"V","purchased_on":"2026-09-01","order_reference":"PO-1"}"""),
+        )
+        var row: PurchasedFromBlockEntity = db.purchasedFromBlockDao().getByItemId("i1")!!
+        assertEquals("V", row.vendor)
+        assertEquals(LocalDate.of(2026, 9, 1), row.purchasedOn)
+        assertEquals(0L, row.purchasePriceMinor)
+        db.purchasedFromBlockDao().upsert(row.copy(purchasePriceMinor = 999, version = 4))
+        OptimisticApplier.apply(db, m("purchased_from_block", "p1", """{"item_id":"i1","vendor":"W"}""", base = 4))
+        row = db.purchasedFromBlockDao().getByItemId("i1")!!
+        assertEquals("W", row.vendor)
+        assertEquals(999L, row.purchasePriceMinor)
+        assertEquals("PO-1", row.orderReference)
+    }
+
+    @Test
+    fun reapply_createSurvivesFullClear_updateOnTombstonedRowSkipped() = runTest {
+        queue("item", "new", """{"name":"Local"}""")
+        queue("item", "gone", """{"name":"Edit"}""", base = 2)
+        queue("item_label", "e1", """{"item_id":"new","label_id":"lb"}""")
+        db.itemDao().upsert(item("gone"))
+        SyncMirrorApplier.clearMirror(db)
+        assertEquals(2, OutboxOverlay.reapplyPending(db))
+        assertEquals("Local", db.itemDao().getById("new")!!.name)
+        assertNull(db.itemDao().getById("gone"))
+        assertEquals(1, db.itemLabelDao().observeByItemId("new").first().size)
+    }
+
+    @Test
+    fun reapply_replaysInSeqOrder_lastUpdateWins() = runTest {
+        db.itemDao().upsert(item("i1"))
+        queue("item", "i1", """{"name":"first"}""", base = 3)
+        queue("item", "i1", """{"name":"second"}""", base = 3)
+        OutboxOverlay.reapplyPending(db)
+        assertEquals("second", db.itemDao().getById("i1")!!.name)
+    }
+
+    @Test
+    fun reapply_ignoresFailedRows_andSkipsUnsupported() = runTest {
+        db.itemDao().upsert(item("i1"))
+        queue("item", "i1", """{"name":"failed"}""", base = 3, state = OutboxState.FAILED)
+        queue("warranty_block", "w1", """{"item_id":"i1"}""")
+        queue("item", "i1", """{"name":"held"}""", base = 3, state = OutboxState.HELD)
+        assertEquals(1, OutboxOverlay.reapplyPending(db))
+        assertEquals("held", db.itemDao().getById("i1")!!.name)
+    }
+
+    @Test
+    fun reapply_pendingUpdateOverridesFreshServerValue() = runTest {
+        queue("item", "i1", """{"name":"mine"}""", base = 3)
+        db.itemDao().upsert(item("i1", name = "server"))
+        OutboxOverlay.reapplyPending(db)
+        assertEquals("mine", db.itemDao().getById("i1")!!.name)
+    }
+
+    @Test
+    fun derivedQuantity_mirrorPlusPendingDelta() = runTest {
+        db.itemDao().upsert(item("i1", qty = 5))
+        queue("stock_adjustment", "s1", """{"item_id":"i1","delta":2}""")
+        assertEquals(7L, OutboxOverlay.derivedQuantity(db, "i1"))
+        assertEquals(7L, OutboxOverlay.observeDerivedQuantity(db, "i1").first())
+    }
+
+    @Test
+    fun derivedQuantity_noDoubleCount_afterPullDeliversAckedAdjustment() = runTest {
+        db.itemDao().upsert(item("i1", qty = 5))
+        val seq = queue("stock_adjustment", "s1", """{"item_id":"i1","delta":2}""")
+        assertEquals(7L, OutboxOverlay.derivedQuantity(db, "i1"))
+        db.outboxDao().deleteBySeq(seq)
+        db.itemDao().upsert(item("i1", qty = 7))
+        OutboxOverlay.reapplyPending(db)
+        assertEquals(7L, OutboxOverlay.derivedQuantity(db, "i1"))
+        assertEquals(7L, db.itemDao().getById("i1")!!.quantity)
+    }
+
+    @Test
+    fun derivedQuantity_pullWhileAdjustmentStillPending_countsOnce_evenRepeated() = runTest {
+        db.itemDao().upsert(item("i1", qty = 5))
+        queue("stock_adjustment", "s1", """{"item_id":"i1","delta":2}""")
+        queue("stock_adjustment", "s2", """{"item_id":"i1","delta":-1}""", state = OutboxState.IN_FLIGHT)
+        db.itemDao().upsert(item("i1", qty = 10))
+        OutboxOverlay.reapplyPending(db)
+        OutboxOverlay.reapplyPending(db)
+        assertEquals(11L, OutboxOverlay.derivedQuantity(db, "i1"))
+        SyncMirrorApplier.clearMirror(db)
+        db.itemDao().upsert(item("i1", qty = 10))
+        OutboxOverlay.reapplyPending(db)
+        assertEquals(11L, OutboxOverlay.derivedQuantity(db, "i1"))
+        assertNotNull(db.stockAdjustmentDao().observeByItemId("i1").first().firstOrNull { it.id == "s1" })
+    }
+
+    @Test
+    fun derivedQuantity_ignoresFailedAndOtherItems() = runTest {
+        db.itemDao().upsert(item("i1", qty = 5))
+        queue("stock_adjustment", "s1", """{"item_id":"i1","delta":2}""", state = OutboxState.FAILED)
+        queue("stock_adjustment", "s2", """{"item_id":"other","delta":9}""")
+        assertEquals(5L, OutboxOverlay.derivedQuantity(db, "i1"))
+        assertNull(OutboxOverlay.derivedQuantity(db, "missing"))
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/OutboxRepositoryTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/OutboxRepositoryTest.kt
new file mode 100644
index 0000000..9278472
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/OutboxRepositoryTest.kt
@@ -0,0 +1,443 @@
+package dev.hho.android.data.outbox
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.OutboxState
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import androidx.datastore.preferences.core.edit
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonObject
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import kotlin.random.Random
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class OutboxRepositoryTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var repo: OutboxRepository
+    private var now = 1_000L
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        repo = OutboxRepository(db, clock = { now++ })
+    }
+
+    @After
+    fun tearDown() = db.close()
+
+    private fun m(type: String, id: String, fields: String, op: String = "upsert", base: Long = 1) =
+        LocalMutation(type, id, op, base, Json.parseToJsonElement(fields).jsonObject)
+
+    private suspend fun rows() = db.outboxDao().getAllOrdered()
+
+    private suspend fun row(mutationId: String) = db.outboxDao().getByMutationId(mutationId)!!
+
+    private fun fieldsOf(json: String): JsonObject = Json.parseToJsonElement(json).jsonObject
+
+    @Test
+    fun enqueue_assignsFifoSeq_freshUuidV7Ids_pending() = runTest {
+        val a = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        val b = repo.enqueue(m("item", "b", """{"name":"B"}"""))
+        assertTrue(a.seq < b.seq)
+        assertNotEquals(a.mutationId, b.mutationId)
+        assertEquals('7', a.mutationId[14])
+        assertEquals(listOf(OutboxState.PENDING, OutboxState.PENDING), rows().map { it.state })
+    }
+
+    @Test
+    fun updatesToSamePendingEntity_coalesce_laterKeyWins_keepsSeqBaseAndMutationId() = runTest {
+        val first = repo.enqueue(m("item", "a", """{"name":"A","description":"d"}""", base = 3))
+        repo.enqueue(m("item", "b", """{"name":"B"}"""))
+        val second = repo.enqueue(m("item", "a", """{"name":"A2","location_id":"L"}""", base = 9))
+        assertTrue(second.coalesced)
+        assertEquals(first.mutationId, second.mutationId)
+        assertEquals(first.seq, second.seq)
+        val all = rows()
+        assertEquals(2, all.size)
+        val a = all.first { it.entityId == "a" }
+        assertEquals(3L, a.baseVersion)
+        assertEquals(first.seq, a.seq)
+        assertEquals(fieldsOf("""{"name":"A2","description":"d","location_id":"L"}"""), fieldsOf(a.fieldsJson))
+    }
+
+    @Test
+    fun fiftyEditsOfOneItem_areOneMutation() = runTest {
+        repeat(50) { repo.enqueue(m("item", "a", """{"name":"n$it"}""")) }
+        assertEquals(1, rows().size)
+        assertEquals(fieldsOf("""{"name":"n49"}"""), fieldsOf(rows().single().fieldsJson))
+    }
+
+    @Test
+    fun createThenUpdate_isOneCreate() = runTest {
+        val c = repo.enqueue(m("item", "n", """{"name":"New"}""", base = 0))
+        repo.enqueue(m("item", "n", """{"description":"x"}""", base = 0))
+        val only = rows().single()
+        assertEquals(c.mutationId, only.mutationId)
+        assertEquals(0L, only.baseVersion)
+        assertEquals(fieldsOf("""{"name":"New","description":"x"}"""), fieldsOf(only.fieldsJson))
+    }
+
+    @Test
+    fun stockAdjustmentAndItemLabel_neverCoalesce() = runTest {
+        repo.enqueue(m("stock_adjustment", "s1", """{"delta":1}""", base = 0))
+        repo.enqueue(m("stock_adjustment", "s1", """{"delta":2}""", base = 0))
+        repo.enqueue(m("item_label", "e", """{"label_id":"x"}"""))
+        repo.enqueue(m("item_label", "e", """{"label_id":"y"}"""))
+        assertEquals(4, rows().size)
+    }
+
+    @Test
+    fun deleteOpNeverCoalesces() = runTest {
+        repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        val d = repo.enqueue(m("item", "a", "{}", op = "delete"))
+        assertFalse(d.coalesced)
+        assertEquals(2, rows().size)
+    }
+
+    @Test
+    fun enqueueWhileInFlight_isHeld_andNextBatchSkipsIt() = runTest {
+        val a = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        repo.markInFlight(listOf(a.mutationId))
+        val held = repo.enqueue(m("item", "a", """{"name":"A2"}""", base = 1))
+        assertEquals(OutboxState.HELD, held.state)
+        assertFalse(held.coalesced)
+        assertTrue(repo.nextBatch().isEmpty())
+    }
+
+    @Test
+    fun heldRowsCoalesceIntoOneHeldTail() = runTest {
+        val a = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        repo.markInFlight(listOf(a.mutationId))
+        val h1 = repo.enqueue(m("item", "a", """{"name":"A2"}"""))
+        val h2 = repo.enqueue(m("item", "a", """{"description":"d"}"""))
+        assertTrue(h2.coalesced)
+        assertEquals(h1.mutationId, h2.mutationId)
+        assertEquals(2, rows().size)
+    }
+
+    @Test
+    fun createUpdateInFlightUpdateAck_rebasesHeldOntoAppliedVersion() = runTest {
+        val create = repo.enqueue(m("item", "n", """{"name":"New"}""", base = 0))
+        repo.enqueue(m("item", "n", """{"description":"d"}""", base = 0))
+        assertEquals(1, rows().size)
+        repo.markInFlight(listOf(create.mutationId))
+        val held = repo.enqueue(m("item", "n", """{"name":"Newer"}""", base = 0))
+        assertEquals(OutboxState.HELD, held.state)
+
+        repo.ack(create.mutationId, version = 1)
+
+        val left = rows().single()
+        assertEquals(held.mutationId, left.mutationId)
+        assertEquals(OutboxState.PENDING, left.state)
+        assertEquals(1L, left.baseVersion)
+        assertEquals(listOf(held.mutationId), repo.nextBatch().map { it.mutationId })
+    }
+
+    @Test
+    fun ack_deletesRow_andIgnoresUnknownId() = runTest {
+        val a = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        repo.markInFlight(listOf(a.mutationId))
+        repo.ack("nope", 5)
+        assertEquals(1, rows().size)
+        repo.ack(a.mutationId, 5)
+        assertTrue(rows().isEmpty())
+    }
+
+    @Test
+    fun ackSkipped_deletes_followersStayHeldUntilReleaseHeld() = runTest {
+        val a = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        repo.markInFlight(listOf(a.mutationId))
+        val h = repo.enqueue(m("item", "a", """{"name":"A2"}"""))
+        repo.ackSkipped(a.mutationId)
+        assertEquals(OutboxState.HELD, row(h.mutationId).state)
+        assertTrue(repo.nextBatch().isEmpty())
+
+        repo.releaseHeld { _, _ -> null }
+        assertEquals(OutboxState.HELD, row(h.mutationId).state)
+
+        repo.releaseHeld { t, id -> if (t == "item" && id == "a") 7L else null }
+        val released = row(h.mutationId)
+        assertEquals(OutboxState.PENDING, released.state)
+        assertEquals(7L, released.baseVersion)
+    }
+
+    @Test
+    fun releaseHeld_doesNothingWhileHeadStillInFlight() = runTest {
+        val a = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        repo.markInFlight(listOf(a.mutationId))
+        val h = repo.enqueue(m("item", "a", """{"name":"A2"}"""))
+        repo.releaseHeld { _, _ -> 9L }
+        assertEquals(OutboxState.HELD, row(h.mutationId).state)
+    }
+
+    @Test
+    fun quarantine_failsRow_neverBatched_keepsError_releasesFollowerWithOwnBase() = runTest {
+        val a = repo.enqueue(m("item", "a", """{"name":"A"}""", base = 4))
+        val other = repo.enqueue(m("item", "b", """{"name":"B"}"""))
+        repo.markInFlight(listOf(a.mutationId))
+        val h = repo.enqueue(m("item", "a", """{"name":"A2"}""", base = 4))
+        repo.quarantine(a.mutationId, "mutations[0]: bad field")
+
+        val failed = row(a.mutationId)
+        assertEquals(OutboxState.FAILED, failed.state)
+        assertEquals("mutations[0]: bad field", failed.lastError)
+        assertEquals(setOf(h.mutationId, other.mutationId), repo.nextBatch().map { it.mutationId }.toSet())
+        assertEquals(4L, row(h.mutationId).baseVersion)
+        assertEquals(OutboxState.PENDING, repo.enqueue(m("item", "zz", """{"name":"Z"}""")).state)
+        repo.resetInFlightToPending()
+        assertEquals(OutboxState.FAILED, row(a.mutationId).state)
+    }
+
+    @Test
+    fun processDeathReset_returnsInFlightToPending_keepsHeldHeld_andRowStaysPossiblySent() = runTest {
+        val a = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        repo.markInFlight(listOf(a.mutationId))
+        val h = repo.enqueue(m("item", "a", """{"name":"A2"}"""))
+        assertEquals(1, repo.resetInFlightToPending())
+        assertEquals(OutboxState.PENDING, row(a.mutationId).state)
+        assertEquals(OutboxState.HELD, row(h.mutationId).state)
+        assertEquals(listOf(a.mutationId), repo.nextBatch().map { it.mutationId })
+
+        val late = repo.enqueue(m("item", "a", """{"name":"A3"}"""))
+        assertTrue(late.coalesced)
+        assertEquals(h.mutationId, late.mutationId)
+        assertEquals(fieldsOf("""{"name":"A"}"""), fieldsOf(row(a.mutationId).fieldsJson))
+    }
+
+    @Test
+    fun editAfterResetWithNoHeldTail_isHeldBehindPossiblySentRow() = runTest {
+        val a = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        repo.markInFlight(listOf(a.mutationId))
+        repo.resetInFlightToPending()
+        val e = repo.enqueue(m("item", "a", """{"name":"A2"}"""))
+        assertEquals(OutboxState.HELD, e.state)
+        assertNotEquals(a.mutationId, e.mutationId)
+        assertEquals(fieldsOf("""{"name":"A"}"""), fieldsOf(row(a.mutationId).fieldsJson))
+    }
+
+    @Test
+    fun recordAttempt_incrementsCount_andStoresError() = runTest {
+        val a = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        repo.recordAttempt(a.mutationId, "503")
+        repo.recordAttempt(a.mutationId, "timeout")
+        val r = row(a.mutationId)
+        assertEquals(2, r.attemptCount)
+        assertEquals("timeout", r.lastError)
+        assertTrue(r.lastAttemptAt != null)
+    }
+
+    @Test
+    fun nextBatch_sixtyRows_twoBatches_seqOrder() = runTest {
+        repeat(60) { repo.enqueue(m("item", "e$it", """{"name":"n$it"}""")) }
+        val first = repo.nextBatch()
+        assertEquals(50, first.size)
+        assertEquals(first.map { it.seq }.sorted(), first.map { it.seq })
+        repo.markInFlight(first.map { it.mutationId })
+        val second = repo.nextBatch()
+        assertEquals(10, second.size)
+        assertTrue(second.first().seq > first.last().seq)
+        first.forEach { repo.ack(it.mutationId, 1) }
+        repo.markInFlight(second.map { it.mutationId })
+        second.forEach { repo.ack(it.mutationId, 1) }
+        assertTrue(rows().isEmpty())
+    }
+
+    @Test
+    fun nextBatch_oneRowPerEntity_evenForNeverCoalesceTypes() = runTest {
+        val l1 = repo.enqueue(m("item_label", "e", """{"label_id":"x"}"""))
+        repo.enqueue(m("item_label", "e", """{"label_id":"y"}"""))
+        repo.enqueue(m("item", "i", """{"name":"I"}"""))
+        assertEquals(listOf(l1.mutationId), repo.nextBatch().map { it.mutationId }.take(1))
+        assertEquals(listOf("e", "i"), repo.nextBatch().map { it.entityId })
+    }
+
+    @Test
+    fun observePendingCount_countsLive_notFailed() = runTest {
+        assertEquals(0, repo.observePendingCount().first())
+        val a = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        repo.enqueue(m("item", "b", """{"name":"B"}"""))
+        repo.markInFlight(listOf(a.mutationId))
+        repo.enqueue(m("item", "a", """{"name":"A2"}"""))
+        assertEquals(3, repo.observePendingCount().first())
+        repo.quarantine(a.mutationId, "x")
+        assertEquals(2, repo.observePendingCount().first())
+    }
+
+    @Test
+    fun randomizedSequences_neverHaveTwoInFlightForOneEntity_norTwoUnackedInBatch() = runTest {
+        val rnd = Random(20260930)
+        repeat(30) { round ->
+            rows().forEach { db.outboxDao().deleteBySeq(it.seq) }
+            repeat(120) {
+                val id = "e${rnd.nextInt(4)}"
+                when (rnd.nextInt(7)) {
+                    0, 1, 2 -> repo.enqueue(m(pick(rnd), id, """{"k${rnd.nextInt(3)}":"v$it"}""", base = rnd.nextLong(0, 5)))
+                    3 -> {
+                        val batch = repo.nextBatch(rnd.nextInt(1, 6))
+                        assertEquals(batch.size, batch.map { it.entityType to it.entityId }.toSet().size)
+                        repo.markInFlight(batch.map { it.mutationId })
+                    }
+                    4 -> rows().filter { it.state == OutboxState.IN_FLIGHT }.randomOrNull(rnd)?.let { repo.ack(it.mutationId, rnd.nextLong(1, 50)) }
+                    5 -> if (rnd.nextInt(4) == 0) repo.resetInFlightToPending() else
+                        rows().filter { it.state == OutboxState.IN_FLIGHT }.randomOrNull(rnd)?.let { repo.ackSkipped(it.mutationId) }
+                    else -> if (rnd.nextBoolean()) {
+                        rows().filter { it.state == OutboxState.IN_FLIGHT }.randomOrNull(rnd)?.let { repo.quarantine(it.mutationId, "e") }
+                    } else {
+                        repo.releaseHeld { _, _ -> 3L }
+                    }
+                }
+                val live = rows().filter { it.state != OutboxState.FAILED }
+                val inFlight = live.filter { it.state == OutboxState.IN_FLIGHT }.groupBy { it.entityType to it.entityId }
+                assertTrue("round $round step $it", inFlight.values.all { g -> g.size == 1 })
+                live.filter { it.state == OutboxState.PENDING }.groupBy { it.entityType to it.entityId }.forEach { (k, g) ->
+                    if (k.first == "item" || k.first == "stock_adjustment_x") assertTrue("round $round step $it: two PENDING for $k", g.size <= 1)
+                }
+                val batchKeys = repo.nextBatch().map { it.entityType to it.entityId }
+                assertTrue(batchKeys.none { it in inFlight.keys })
+            }
+        }
+    }
+
+    private fun pick(rnd: Random) = listOf("item", "item", "item_label", "stock_adjustment")[rnd.nextInt(4)]
+
+    @Test
+    fun releaseFollowers_quarantinesACorruptHeldFollowerAndReleasesTheHealthyOnes() = runTest {
+        val head = repo.enqueue(m("item", "a", """{"name":"A"}""", base = 3))
+        repo.markInFlight(listOf(head.mutationId))
+        repo.enqueue(m("item", "a", """{"name":"A2"}""", base = 3))
+        repo.enqueue(m("item", "a", """{"description":"d"}""", base = 3))
+        val dao = db.outboxDao()
+        dao.insert(
+            dao.getByMutationId(head.mutationId)!!.copy(
+                seq = 0, mutationId = "corrupt", state = OutboxState.HELD, fieldsJson = "not json", lastAttemptAt = null,
+            ),
+        )
+        repo.enqueue(m("item", "b", """{"name":"B"}"""))
+
+        repo.ack(head.mutationId, 4)
+
+        val all = rows()
+        val bad = all.single { it.mutationId == "corrupt" }
+        assertEquals(OutboxState.FAILED, bad.state)
+        assertTrue(bad.lastError!!.startsWith("Unreadable local edit: "))
+        assertFalse(bad.lastError!!.contains("not json"))
+        val healthy = all.single { it.entityId == "a" && it.mutationId != "corrupt" }
+        assertEquals(OutboxState.PENDING, healthy.state)
+        assertEquals(4L, healthy.baseVersion)
+        assertEquals(fieldsOf("""{"name":"A2","description":"d"}"""), fieldsOf(healthy.fieldsJson))
+    }
+
+    private suspend fun insertCorruptTail(like: String, state: String): String {
+        val dao = db.outboxDao()
+        dao.insert(
+            dao.getByMutationId(like)!!.copy(
+                seq = 0, mutationId = "corrupt", state = state, fieldsJson = "{secret-raw not json", lastAttemptAt = null,
+            ),
+        )
+        return "corrupt"
+    }
+
+    private fun assertQuarantinedSanitized(bad: dev.hho.android.data.room.OutboxMutationEntity) {
+        assertEquals(OutboxState.FAILED, bad.state)
+        assertTrue(bad.lastError!!.startsWith("Unreadable local edit: "))
+        assertFalse(bad.lastError!!.contains("secret-raw"))
+        assertFalse(bad.lastError!!.contains("{"))
+    }
+
+    @Test
+    fun enqueue_nextToCorruptPendingTail_quarantinesItAndQueuesFreshPending() = runTest {
+        val seed = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        val corrupt = insertCorruptTail(seed.mutationId, OutboxState.PENDING)
+        db.outboxDao().deleteBySeq(seed.seq)
+
+        val r = repo.enqueue(m("item", "a", """{"name":"A2"}"""))
+
+        assertFalse(r.coalesced)
+        assertEquals(OutboxState.PENDING, r.state)
+        assertNotEquals(corrupt, r.mutationId)
+        assertQuarantinedSanitized(row(corrupt))
+        assertEquals(OutboxState.PENDING, row(r.mutationId).state)
+        assertEquals(fieldsOf("""{"name":"A2"}"""), fieldsOf(row(r.mutationId).fieldsJson))
+    }
+
+    @Test
+    fun enqueue_nextToCorruptHeldTailBehindInFlightHead_queuesFreshHeld() = runTest {
+        val head = repo.enqueue(m("item", "a", """{"name":"A"}""", base = 3))
+        repo.markInFlight(listOf(head.mutationId))
+        val corrupt = insertCorruptTail(head.mutationId, OutboxState.HELD)
+
+        val r = repo.enqueue(m("item", "a", """{"name":"A2"}""", base = 3))
+
+        assertFalse(r.coalesced)
+        assertEquals(OutboxState.HELD, r.state)
+        assertQuarantinedSanitized(row(corrupt))
+        assertEquals(OutboxState.IN_FLIGHT, row(head.mutationId).state)
+        assertEquals(OutboxState.HELD, row(r.mutationId).state)
+    }
+
+    @Test
+    fun enqueue_nextToCorruptHeldTailWithNoRemainingHead_queuesPendingNotHeld() = runTest {
+        val seed = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+        val corrupt = insertCorruptTail(seed.mutationId, OutboxState.HELD)
+        db.outboxDao().deleteBySeq(seed.seq)
+
+        val r = repo.enqueue(m("item", "a", """{"name":"A2"}"""))
+
+        assertEquals(OutboxState.PENDING, r.state)
+        assertQuarantinedSanitized(row(corrupt))
+    }
+
+    @Test
+    fun enqueue_nextToCorruptTail_newEditIsSentAndCorruptNeverIs() = runTest {
+        val server = okhttp3.mockwebserver.MockWebServer()
+        val ledger = LedgerFakeServer()
+        server.dispatcher = ledger
+        try {
+            val seed = repo.enqueue(m("item", "a", """{"name":"A"}"""))
+            val corrupt = insertCorruptTail(seed.mutationId, OutboxState.PENDING)
+            db.outboxDao().deleteBySeq(seed.seq)
+            val fresh = repo.enqueue(m("item", "a", """{"name":"A2"}""")).mutationId
+
+            val prefs = java.io.File.createTempFile("outbox-repo", ".preferences_pb").also { it.deleteOnExit() }
+            val dataStore = androidx.datastore.preferences.core.PreferenceDataStoreFactory.create(produceFile = { prefs })
+            dataStore.edit { it[dev.hho.android.data.settings.SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() }
+            val cv = dev.hho.android.data.network.ClientVersionInterceptor()
+            val provider = object : dev.hho.android.data.auth.DeviceTokenProvider {
+                override suspend fun tokenFor(requestUrl: okhttp3.HttpUrl): String? = "tok"
+
+                override suspend fun invalidate(requestUrl: okhttp3.HttpUrl, rejectedToken: String) = Unit
+            }
+            val http = dev.hho.android.di.NetworkModule.provideOkHttpClient(
+                dev.hho.android.data.network.BaseUrlInterceptor(dev.hho.android.data.network.InstanceBaseUrlResolver(dataStore)),
+                dev.hho.android.data.network.AuthHeaderInterceptor(provider),
+                cv,
+            )
+            val api = dev.hho.android.data.apiclient.HhoApiClient(http, dev.hho.android.di.NetworkModule.provideProbeOkHttpClient(http, cv))
+            val syncer = dev.hho.android.data.sync.OutboxSyncer(db, api, repo, clock = { now++ })
+
+            val outcome = syncer.push("dev-1")
+
+            assertEquals(dev.hho.android.data.sync.PushPhaseOutcome.Drained, outcome)
+            assertEquals(listOf(fresh), ledger.applyOrder)
+            assertEquals("A2", ledger.entityState["item/a"]!!["name"])
+            assertTrue(ledger.sentIds.flatten().none { it == corrupt })
+            assertEquals(listOf(corrupt), rows().map { it.mutationId })
+            assertQuarantinedSanitized(row(corrupt))
+        } finally {
+            server.shutdown()
+        }
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/OutboxWireBodyTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/OutboxWireBodyTest.kt
new file mode 100644
index 0000000..946ad37
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/outbox/OutboxWireBodyTest.kt
@@ -0,0 +1,88 @@
+package dev.hho.android.data.outbox
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class OutboxWireBodyTest {
+    private val server = MockWebServer()
+    private lateinit var db: HhoDatabase
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+    }
+
+    @After
+    fun tearDown() {
+        server.shutdown()
+        db.close()
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val file = File.createTempFile("hho-outbox-wire", ".preferences_pb").also { it.deleteOnExit() }
+        val dataStore = PreferenceDataStoreFactory.create(produceFile = { file })
+        runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() } }
+        val cv = ClientVersionInterceptor()
+        val provider = object : DeviceTokenProvider {
+            override suspend fun tokenFor(requestUrl: HttpUrl): String? = null
+
+            override suspend fun invalidate(requestUrl: HttpUrl, rejectedToken: String) = Unit
+        }
+        val http = NetworkModule.provideOkHttpClient(BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore)), AuthHeaderInterceptor(provider), cv)
+        return HhoApiClient(http, NetworkModule.provideProbeOkHttpClient(http, cv))
+    }
+
+    @Test
+    fun pushBodyBuiltFromRows_hasNoTimestampKeys_andOnlyTheWireKeys() = runBlocking {
+        val repo = OutboxRepository(db, clock = { 1_788_000_000_000L })
+        val fields = Json.parseToJsonElement("""{"name":"Drill","location_id":"L1"}""").jsonObject
+        repo.enqueue(LocalMutation("item", "i1", "upsert", 0, fields))
+        repo.enqueue(LocalMutation("stock_adjustment", "s1", "upsert", 0, Json.parseToJsonElement("""{"item_id":"i1","delta":2}""").jsonObject))
+        val batch = repo.nextBatch()
+        assertTrue(batch.all { it.createdAt == 1_788_000_000_000L })
+
+        server.enqueue(MockResponse().setResponseCode(200).setBody("""{"applied":[],"skipped":[],"conflicts":[],"new_watermark":1}"""))
+        apiClient().syncPush("device-1", batch.map { it.toPushMutation() })
+
+        val body = server.takeRequest().body.readUtf8()
+        val mutations = Json.parseToJsonElement(body).jsonObject["mutations"]!!.jsonArray
+        assertEquals(2, mutations.size)
+        mutations.forEach { mm ->
+            assertEquals(setOf("mutation_id", "entity_type", "entity_id", "base_version", "fields", "op"), mm.jsonObject.keys)
+        }
+        assertEquals(setOf("device_id", "mutations"), Json.parseToJsonElement(body).jsonObject.keys)
+        assertFalse(body.contains("1788000000000"))
+        assertFalse(Regex("""(?i)"[a-z_]*(_at|timestamp|time|date)"\s*:""").containsMatchIn(body))
+        assertTrue(mutations.all { (it.jsonObject["fields"] as JsonObject).keys.none { k -> k.endsWith("_at") } })
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/photoqueue/PhotoQueueIndependenceTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/photoqueue/PhotoQueueIndependenceTest.kt
new file mode 100644
index 0000000..dece29c
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/photoqueue/PhotoQueueIndependenceTest.kt
@@ -0,0 +1,286 @@
+package dev.hho.android.data.photoqueue
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.outbox.LocalMutation
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.PhotoState
+import dev.hho.android.data.room.deleteHhoDatabaseFile
+import dev.hho.android.data.room.fileHhoDatabase
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.data.sync.OutboxSyncer
+import dev.hho.android.data.sync.PushPhaseOutcome
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.RecordedRequest
+import okhttp3.mockwebserver.SocketPolicy
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class PhotoQueueIndependenceTest {
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(60)
+
+    private val tmp = TemporaryFolder().also { it.create() }
+    private val server = MockWebServer()
+    private val dbs = mutableListOf<HhoDatabase>()
+    private val dbName = "photo-independence-${System.nanoTime()}"
+    private var now = 1_000L
+
+    private val storedAttachments = mutableListOf<String>()
+    private var postCount = 0
+    private var pushCount = 0
+    private var photoPostMode: (Int) -> MockResponse? = { null }
+    private var pushMode: () -> MockResponse? = { null }
+
+    private lateinit var source: File
+    private lateinit var filesDir: File
+
+    @Before
+    fun setUp() {
+        source = tmp.newFile("cap.jpg").apply { writeText("abc") }
+        filesDir = tmp.newFolder("files")
+        server.dispatcher =
+            object : Dispatcher() {
+                override fun dispatch(request: RecordedRequest): MockResponse {
+                    val path = request.path.orEmpty()
+                    return when {
+                        path.endsWith("/sync/push") -> {
+                            pushCount++
+                            pushMode() ?: applyAll(request)
+                        }
+                        path.endsWith("/attachments") && request.method == "POST" -> {
+                            postCount++
+                            val custom = photoPostMode(postCount)
+                            if (custom != null) return custom
+                            store()
+                            json(201, storedAttachments.last())
+                        }
+                        path.endsWith("/attachments") && request.method == "GET" ->
+                            json(200, """{"attachments":[${storedAttachments.joinToString(",")}]}""")
+                        else -> json(404, """{"title":"x","status":404}""")
+                    }
+                }
+            }
+    }
+
+    @After
+    fun tearDown() {
+        dbs.forEach { runCatching { it.close() } }
+        deleteHhoDatabaseFile(dbName)
+        server.shutdown()
+    }
+
+    @Test
+    fun `data sync and data outbox never reference the photoqueue package`() {
+        val roots = listOf("data/sync", "data/outbox").map { File("src/main/kotlin/dev/hho/android/$it") }
+        val files = roots.flatMap { r -> r.walkTopDown().filter { it.isFile && it.extension == "kt" }.toList() }
+        assertTrue(
+            "Expected Kotlin sources under ${roots.map { it.absolutePath }} but found ${files.size}; " +
+                "the scan would otherwise pass vacuously.",
+            files.size >= 5,
+        )
+        val offenders =
+            files.filter { f -> PHOTOQUEUE_REF.containsMatchIn(stripComments(f.readText())) }
+                .map { it.path }
+        if (offenders.isNotEmpty()) {
+            fail(
+                "data/sync and data/outbox must never import or reference dev.hho.android.data.photoqueue " +
+                    "(FR-122: the queues are independent; use an interface declared in data/sync and " +
+                    "implemented in data/photoqueue). Offending files: $offenders",
+            )
+        }
+    }
+
+    @Test
+    fun `a failing photo upload does not stop an entity sync`() =
+        runBlocking {
+            val c = components(inMemoryHhoDatabase())
+            c.photoRepo.enqueue("item-1", source)
+            c.outbox.enqueue(itemEdit("a"))
+            photoPostMode = { json(503, """{"title":"x","status":503}""") }
+
+            assertEquals(PhotoDrainOutcome.RETRY_LATER, c.uploader.drain { now })
+            assertEquals(PushPhaseOutcome.Drained, c.syncer.push("dev-1"))
+
+            assertTrue("entity outbox drained", c.db.outboxDao().getAllOrdered().isEmpty())
+            assertEquals(1, pushCount)
+            assertEquals(listOf(PhotoState.QUEUED), photoStates(c.db))
+        }
+
+    @Test
+    fun `a failing entity push does not stop photo uploads`() =
+        runBlocking {
+            val c = components(inMemoryHhoDatabase())
+            val entry = c.photoRepo.enqueue("item-1", source)
+            c.outbox.enqueue(itemEdit("a"))
+            pushMode = { json(503, """{"title":"x","status":503}""") }
+
+            assertTrue(c.syncer.push("dev-1") is PushPhaseOutcome.Failed)
+            assertEquals(PhotoDrainOutcome.DRAINED, c.uploader.drain { now })
+
+            assertEquals("one attachment stored", 1, storedAttachments.size)
+            assertTrue("photo row gone", photoStates(c.db).isEmpty())
+            assertTrue("photo file gone", !File(entry.filePath).exists())
+            assertEquals("entity row stays queued for retry", 1, c.db.outboxDao().getAllOrdered().size)
+        }
+
+    @Test
+    fun `kill and reopen keeps queued photos and recovers an UPLOADING entry`() =
+        runBlocking {
+            deleteHhoDatabaseFile(dbName)
+            val before = components(fileHhoDatabase(dbName))
+            val queued = before.photoRepo.enqueue("item-1", source)
+            val inFlight = before.photoRepo.enqueue("item-1", source)
+            assertTrue(before.photoRepo.markUploading(inFlight.id))
+            before.db.close()
+
+            val after = components(fileHhoDatabase(dbName))
+            val rows = after.db.photoQueueDao().getByStates(ALL_STATES)
+            assertEquals(setOf(queued.id, inFlight.id), rows.map { it.id }.toSet())
+            assertEquals(PhotoState.UPLOADING, rows.first { it.id == inFlight.id }.state)
+            assertTrue(File(queued.filePath).isFile && File(inFlight.filePath).isFile)
+
+            assertEquals(PhotoDrainOutcome.DRAINED, after.uploader.drain { now })
+
+            assertEquals("both uploaded after recovery", 2, storedAttachments.size)
+            assertTrue(after.db.photoQueueDao().getByStates(ALL_STATES).isEmpty())
+            assertTrue(!File(queued.filePath).exists() && !File(inFlight.filePath).exists())
+        }
+
+    @Test
+    fun `a lost 201 does not duplicate the attachment`() =
+        runBlocking {
+            val c = components(inMemoryHhoDatabase())
+            val entry = c.photoRepo.enqueue("item-1", source)
+            photoPostMode = { n ->
+                if (n == 1) store()
+                MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AFTER_REQUEST)
+            }
+
+            assertEquals(PhotoDrainOutcome.RETRY_LATER, c.uploader.drain { now })
+            val postsAfterLoss = postCount
+            assertEquals("server holds the attachment", 1, storedAttachments.size)
+            assertEquals(PhotoState.QUEUED, c.db.photoQueueDao().getById(entry.id)?.state)
+
+            photoPostMode = { fail("a second POST was sent after a lost 201"); null }
+            now += photoBackoffMillis(1) + 1
+            assertEquals(PhotoDrainOutcome.DRAINED, c.uploader.drain { now })
+
+            assertEquals("no POST in the reconciling drain", postsAfterLoss, postCount)
+            assertEquals("exactly one attachment on the server", 1, storedAttachments.size)
+            assertTrue(photoStates(c.db).isEmpty())
+            assertTrue(!File(entry.filePath).exists())
+        }
+
+    private class Components(
+        val db: HhoDatabase,
+        val photoRepo: PhotoQueueRepository,
+        val uploader: PhotoUploader,
+        val outbox: OutboxRepository,
+        val syncer: OutboxSyncer,
+    )
+
+    private fun components(db: HhoDatabase): Components {
+        dbs += db
+        val api = apiClient()
+        val photoRepo = PhotoQueueRepository(filesDir, db.photoQueueDao(), { now }) { it.inputStream() }
+        val outbox = OutboxRepository(db, clock = { now++ })
+        return Components(
+            db,
+            photoRepo,
+            PhotoUploader(photoRepo, db.photoQueueDao(), db.outboxDao(), api),
+            outbox,
+            OutboxSyncer(db, api, outbox, clock = { now++ }),
+        )
+    }
+
+    private suspend fun photoStates(db: HhoDatabase) =
+        db.photoQueueDao().getByStates(ALL_STATES).map { it.state }
+
+    private fun itemEdit(id: String) =
+        LocalMutation("item", id, "upsert", 1, Json.parseToJsonElement("""{"name":"N"}""").jsonObject)
+
+    private fun store() {
+        storedAttachments +=
+            """{"id":"a-${storedAttachments.size}","item_id":"item-1","category":"image","original_filename":"x.jpg",""" +
+                """"content_type":"image/jpeg","size_bytes":3,"sha256":"$SHA_ABC","created_at":1700000000000,""" +
+                """"updated_at":1700000000001,"version":1,"has_thumbnail":true}"""
+    }
+
+    private fun applyAll(request: RecordedRequest): MockResponse {
+        val muts = Json.parseToJsonElement(request.body.readUtf8()).jsonObject["mutations"]!!.jsonArray.map { it.jsonObject }
+        val applied =
+            muts.joinToString(",") { m ->
+                """{"mutation_id":"${m["mutation_id"]!!.jsonPrimitive.content}","entity_type":"${m["entity_type"]!!.jsonPrimitive.content}",""" +
+                    """"entity_id":"${m["entity_id"]!!.jsonPrimitive.content}","version":10}"""
+            }
+        return json(200, """{"applied":[$applied],"skipped":[],"conflicts":[],"new_watermark":99}""")
+    }
+
+    private fun json(
+        status: Int,
+        body: String,
+    ) = MockResponse().setResponseCode(status).setHeader("Content-Type", "application/json").setBody(body)
+
+    private fun apiClient(): HhoApiClient {
+        val prefs = File.createTempFile("photo-independence", ".preferences_pb").also { it.deleteOnExit() }
+        val dataStore = PreferenceDataStoreFactory.create(produceFile = { prefs })
+        runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() } }
+        val cv = ClientVersionInterceptor()
+        val provider =
+            object : DeviceTokenProvider {
+                override suspend fun tokenFor(requestUrl: HttpUrl): String? = "tok"
+
+                override suspend fun invalidate(
+                    requestUrl: HttpUrl,
+                    rejectedToken: String,
+                ) = Unit
+            }
+        val http =
+            NetworkModule.provideOkHttpClient(
+                BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore)),
+                AuthHeaderInterceptor(provider),
+                cv,
+            )
+        return HhoApiClient(http, NetworkModule.provideProbeOkHttpClient(http, cv))
+    }
+
+    private fun stripComments(text: String): String =
+        text.replace(Regex("/\\*[\\s\\S]*?\\*/"), "").lines().joinToString("\n") { it.substringBefore("//") }
+
+    private companion object {
+        val ALL_STATES = listOf(PhotoState.QUEUED, PhotoState.UPLOADING, PhotoState.WAITING_PARENT, PhotoState.FAILED)
+        const val SHA_ABC = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+        val PHOTOQUEUE_REF = Regex("""dev\.hho\.android\.data\.photoqueue""")
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/photoqueue/PhotoQueueRepositoryTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/photoqueue/PhotoQueueRepositoryTest.kt
new file mode 100644
index 0000000..542790b
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/photoqueue/PhotoQueueRepositoryTest.kt
@@ -0,0 +1,239 @@
+package dev.hho.android.data.photoqueue
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.PhotoQueueDao
+import dev.hho.android.data.room.PhotoState
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Before
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+import java.io.IOException
+import java.io.InputStream
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class PhotoQueueRepositoryTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var dao: PhotoQueueDao
+    private lateinit var base: File
+    private lateinit var source: File
+    private var now = 1_000L
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        dao = db.photoQueueDao()
+        val tmp = TemporaryFolder().also { it.create() }
+        base = tmp.newFolder("files")
+        source = tmp.newFile("cap.jpg").apply { writeText("abc") }
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+    }
+
+    private fun repo(
+        d: PhotoQueueDao = dao,
+        open: (File) -> InputStream = { it.inputStream() },
+    ) = PhotoQueueRepository(base, d, { now }, open)
+
+    private val queueDir get() = File(base, "photo-queue")
+
+    @Test
+    fun enqueueCopiesAndHashesAgainstKnownSha256() =
+        runTest {
+            val e = repo().enqueue("item-1", source)
+            assertEquals("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", e.sha256)
+            assertEquals(3L, e.sizeBytes)
+            assertEquals(PhotoState.QUEUED, e.state)
+            assertEquals("abc", File(e.filePath).readText())
+            assertTrue(File(e.filePath).parentFile == queueDir)
+            assertTrue("source is caller-owned", source.exists())
+            assertEquals(e, dao.getById(e.id))
+        }
+
+    @Test
+    fun midCopyFailureLeavesNoFileAndNoRow() =
+        runTest {
+            val failing = { f: File ->
+                object : InputStream() {
+                    var n = 0
+
+                    override fun read(): Int = throw IOException("boom")
+
+                    override fun read(b: ByteArray, off: Int, len: Int): Int {
+                        if (n++ == 0) {
+                            b[off] = 1
+                            return 1
+                        }
+                        throw IOException("boom")
+                    }
+                }
+            }
+            try {
+                repo(open = failing).enqueue("i", source)
+                fail("expected IOException")
+            } catch (_: IOException) {
+            }
+            assertEquals(emptyList<String>(), queueDir.list()!!.toList())
+            assertTrue(dao.getAllOrdered().isEmpty())
+        }
+
+    @Test
+    fun rowInsertFailureRemovesCopiedFile() =
+        runTest {
+            val broken =
+                object : PhotoQueueDao by dao {
+                    override suspend fun insert(entry: dev.hho.android.data.room.PhotoQueueEntryEntity) =
+                        throw IllegalStateException("db down")
+                }
+            try {
+                repo(broken).enqueue("i", source)
+                fail("expected failure")
+            } catch (_: IllegalStateException) {
+            }
+            assertEquals(0, queueDir.list()!!.size)
+        }
+
+    @Test
+    fun staleStagingFilesAreSweptOnConstruction() {
+        queueDir.mkdirs()
+        File(queueDir, "x.part").writeText("junk")
+        repo()
+        assertFalse(File(queueDir, "x.part").exists())
+    }
+
+    @Test
+    fun transitionsAndUploadedDeletesRowAndFile() =
+        runTest {
+            val r = repo()
+            val e = r.enqueue("i", source)
+            assertEquals(e, r.nextDue())
+            assertTrue(r.markUploading(e.id))
+            assertEquals(PhotoState.UPLOADING, dao.getById(e.id)!!.state)
+            assertFalse("not QUEUED any more", r.markUploading(e.id))
+            assertNull(r.nextDue())
+            r.markWaitingParent(e.id)
+            assertEquals(PhotoState.WAITING_PARENT, dao.getById(e.id)!!.state)
+            assertNull(r.nextDue())
+            assertEquals(1, r.releaseWaitingParent())
+            assertEquals(PhotoState.QUEUED, dao.getById(e.id)!!.state)
+            assertTrue(r.markUploading(e.id))
+            r.markUploaded(e.id)
+            assertNull(dao.getById(e.id))
+            assertFalse(File(e.filePath).exists())
+        }
+
+    @Test
+    fun backoffScheduleValues() {
+        val expected = listOf(30_000L, 60_000, 120_000, 240_000, 480_000, 960_000, 1_800_000, 1_800_000)
+        assertEquals(expected, (1..8).map { photoBackoffMillis(it) })
+        assertEquals(1_800_000L, photoBackoffMillis(500))
+    }
+
+    @Test
+    fun retryableFailureSchedulesBackoffAndHidesUntilDue() =
+        runTest {
+            val r = repo()
+            val e = r.enqueue("i", source)
+            r.recordFailure(e.id, "503", retryable = true, now = 10_000)
+            var row = dao.getById(e.id)!!
+            assertEquals(1, row.attemptCount)
+            assertEquals(PhotoState.QUEUED, row.state)
+            assertEquals(40_000L, row.nextAttemptAt)
+            assertEquals("503", row.lastError)
+            assertNull(r.nextDue(39_999))
+            assertNotNull(r.nextDue(40_000))
+            r.recordFailure(e.id, "503", true, now = 40_000)
+            row = dao.getById(e.id)!!
+            assertEquals(100_000L, row.nextAttemptAt)
+        }
+
+    @Test
+    fun eighthAttemptFailsAndKeepsFile() =
+        runTest {
+            val r = repo()
+            val e = r.enqueue("i", source)
+            repeat(7) { r.recordFailure(e.id, "5xx", true, now = 0) }
+            assertEquals(PhotoState.QUEUED, dao.getById(e.id)!!.state)
+            r.recordFailure(e.id, "5xx", true, now = 0)
+            val row = dao.getById(e.id)!!
+            assertEquals(PhotoState.FAILED, row.state)
+            assertEquals(8, row.attemptCount)
+            assertNull(row.nextAttemptAt)
+            assertTrue(File(e.filePath).exists())
+            assertNull(r.nextDue(Long.MAX_VALUE))
+        }
+
+    @Test
+    fun nonRetryable413FailsImmediately() =
+        runTest {
+            val r = repo()
+            val e = r.enqueue("i", source)
+            r.recordFailure(e.id, "413 too large", retryable = false)
+            val row = dao.getById(e.id)!!
+            assertEquals(PhotoState.FAILED, row.state)
+            assertEquals(1, row.attemptCount)
+            assertEquals("413 too large", row.lastError)
+            assertTrue(File(e.filePath).exists())
+        }
+
+    @Test
+    fun missingFileBecomesFailedNotCrash() =
+        runTest {
+            val r = repo()
+            val e = r.enqueue("i", source)
+            val e2 = r.enqueue("i", source)
+            File(e.filePath).delete()
+            assertEquals(e2.id, r.nextDue()!!.id)
+            val row = dao.getById(e.id)!!
+            assertEquals(PhotoState.FAILED, row.state)
+            assertTrue(row.lastError!!.contains("missing"))
+            File(e2.filePath).delete()
+            assertFalse(r.markUploading(e2.id))
+            assertEquals(PhotoState.FAILED, dao.getById(e2.id)!!.state)
+        }
+
+    @Test
+    fun processDeathResetReturnsUploadingToQueuedKeepingAttempts() =
+        runTest {
+            val r = repo()
+            val e = r.enqueue("i", source)
+            r.recordFailure(e.id, "x", true, now = 0)
+            dao.updateProgress(e.id, PhotoState.UPLOADING, 1, null, "x")
+            assertEquals(1, r.resetUploadingToQueued())
+            val row = dao.getById(e.id)!!
+            assertEquals(PhotoState.QUEUED, row.state)
+            assertEquals(1, row.attemptCount)
+        }
+
+    @Test
+    fun nextDueIsOldestFirstAndObserversReport() =
+        runTest {
+            val r = repo()
+            now = 1
+            val a = r.enqueue("i", source)
+            now = 2
+            val b = r.enqueue("i", source)
+            assertEquals(a.id, r.nextDue()!!.id)
+            r.recordFailure(a.id, "x", false)
+            assertEquals(b.id, r.nextDue()!!.id)
+            assertEquals(listOf(a.id, b.id), r.observeEntries().first().map { it.id })
+            assertEquals(1, r.observePendingCount().first())
+            assertEquals(1, r.observeFailedCount().first())
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/photoqueue/PhotoSchedulerAndWorkerTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/photoqueue/PhotoSchedulerAndWorkerTest.kt
new file mode 100644
index 0000000..ff9d2ec
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/photoqueue/PhotoSchedulerAndWorkerTest.kt
@@ -0,0 +1,139 @@
+package dev.hho.android.data.photoqueue
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.work.BackoffPolicy
+import androidx.work.Configuration
+import androidx.work.ListenableWorker
+import androidx.work.NetworkType
+import androidx.work.WorkInfo
+import androidx.work.WorkManager
+import androidx.work.WorkerFactory
+import androidx.work.WorkerParameters
+import androidx.work.testing.TestListenableWorkerBuilder
+import androidx.work.testing.WorkManagerTestInitHelper
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.domain.AuthRepository
+import dev.hho.android.domain.AuthState
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.test.runTest
+import okhttp3.OkHttpClient
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+import java.util.concurrent.Executors
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class PhotoSchedulerAndWorkerTest {
+    private val context = ApplicationProvider.getApplicationContext<Context>()
+    private lateinit var db: HhoDatabase
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        WorkManagerTestInitHelper.initializeTestWorkManager(
+            context,
+            Configuration.Builder().setExecutor(Executors.newSingleThreadExecutor()).build(),
+        )
+    }
+
+    @After
+    fun tearDown() = db.close()
+
+    @Test
+    fun `schedule enqueues unique work constrained to CONNECTED`() {
+        PhotoScheduler(context).schedule()
+        val infos = WorkManager.getInstance(context).getWorkInfosForUniqueWork(PhotoScheduler.UNIQUE_WORK_NAME).get()
+        val info = infos.single()
+        assertEquals(WorkInfo.State.ENQUEUED, info.state)
+        assertTrue(info.tags.contains(PhotoUploadWorker::class.java.name))
+        assertEquals(NetworkType.CONNECTED, info.constraints.requiredNetworkType)
+    }
+
+    @Test
+    fun `schedule twice keeps a single unique work`() {
+        val s = PhotoScheduler(context)
+        s.schedule()
+        s.schedule()
+        val live =
+            WorkManager.getInstance(context).getWorkInfosForUniqueWork(PhotoScheduler.UNIQUE_WORK_NAME).get()
+                .filter { it.state != WorkInfo.State.CANCELLED }
+        assertEquals(1, live.size)
+    }
+
+    @Test
+    fun `request uses exponential backoff`() {
+        val spec = PhotoScheduler.buildRequest().workSpec
+        assertEquals(BackoffPolicy.EXPONENTIAL, spec.backoffPolicy)
+        assertEquals(NetworkType.CONNECTED, spec.constraints.requiredNetworkType)
+    }
+
+    private class FakeAuth(initial: AuthState) : AuthRepository {
+        override val authState: Flow<AuthState> = MutableStateFlow(initial)
+
+        override suspend fun login(
+            username: String,
+            password: String,
+        ): Result<Unit> = error("unused")
+
+        override suspend fun logout() = error("unused")
+    }
+
+    private class FakeUploader(private val outcome: PhotoDrainOutcome, repo: PhotoQueueRepository, db: HhoDatabase) :
+        PhotoUploader(repo, db.photoQueueDao(), db.outboxDao(), unusedApi()) {
+        var calls = 0
+
+        override suspend fun drain(clock: () -> Long): PhotoDrainOutcome {
+            calls++
+            return outcome
+        }
+    }
+
+    private fun worker(
+        outcome: PhotoDrainOutcome,
+        auth: AuthState,
+    ): Pair<PhotoUploadWorker, FakeUploader> {
+        val repo = PhotoQueueRepository(File(context.cacheDir, "pq"), db.photoQueueDao(), { 0L }) { it.inputStream() }
+        val uploader = FakeUploader(outcome, repo, db)
+        val w =
+            TestListenableWorkerBuilder<PhotoUploadWorker>(context)
+                .setWorkerFactory(
+                    object : WorkerFactory() {
+                        override fun createWorker(
+                            appContext: Context,
+                            workerClassName: String,
+                            workerParameters: WorkerParameters,
+                        ): ListenableWorker = PhotoUploadWorker(appContext, workerParameters, uploader, FakeAuth(auth))
+                    },
+                ).build()
+        return w to uploader
+    }
+
+    @Test
+    fun `logged out is a no-op success that never drains`() =
+        runTest {
+            val (w, u) = worker(PhotoDrainOutcome.DRAINED, AuthState.LoggedOut)
+            assertEquals(ListenableWorker.Result.success(), w.doWork())
+            assertEquals(0, u.calls)
+        }
+
+    @Test
+    fun `outcome mapping`() =
+        runTest {
+            assertEquals(ListenableWorker.Result.success(), worker(PhotoDrainOutcome.DRAINED, AuthState.LoggedIn).first.doWork())
+            assertEquals(ListenableWorker.Result.retry(), worker(PhotoDrainOutcome.RETRY_LATER, AuthState.LoggedIn).first.doWork())
+            assertEquals(ListenableWorker.Result.retry(), worker(PhotoDrainOutcome.BLOCKED, AuthState.LoggedIn).first.doWork())
+        }
+}
+
+private fun unusedApi(): HhoApiClient = HhoApiClient(OkHttpClient(), OkHttpClient())
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/photoqueue/PhotoUploaderTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/photoqueue/PhotoUploaderTest.kt
new file mode 100644
index 0000000..3117a04
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/photoqueue/PhotoUploaderTest.kt
@@ -0,0 +1,329 @@
+package dev.hho.android.data.photoqueue
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.OutboxMutationEntity
+import dev.hho.android.data.room.OutboxState
+import dev.hho.android.data.room.PhotoState
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.SocketPolicy
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class PhotoUploaderTest {
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(30)
+
+    private val server = MockWebServer()
+    private lateinit var db: HhoDatabase
+    private lateinit var repo: PhotoQueueRepository
+    private lateinit var uploader: PhotoUploader
+    private lateinit var source: File
+    private var now = 1_000L
+
+    private val sha = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        val tmp = TemporaryFolder().also { it.create() }
+        source = tmp.newFile("cap.jpg").apply { writeText("abc") }
+        repo = PhotoQueueRepository(tmp.newFolder("files"), db.photoQueueDao(), { now }) { it.inputStream() }
+        uploader = PhotoUploader(repo, db.photoQueueDao(), db.outboxDao(), apiClient())
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+        server.shutdown()
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val prefs = File.createTempFile("photo-uploader", ".preferences_pb").also { it.deleteOnExit() }
+        val dataStore = PreferenceDataStoreFactory.create(produceFile = { prefs })
+        runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() } }
+        val cv = ClientVersionInterceptor()
+        val provider =
+            object : DeviceTokenProvider {
+                override suspend fun tokenFor(requestUrl: HttpUrl): String? = "tok"
+
+                override suspend fun invalidate(
+                    requestUrl: HttpUrl,
+                    rejectedToken: String,
+                ) = Unit
+            }
+        val http =
+            NetworkModule.provideOkHttpClient(
+                BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore)),
+                AuthHeaderInterceptor(provider),
+                cv,
+            )
+        return HhoApiClient(http, NetworkModule.provideProbeOkHttpClient(http, cv))
+    }
+
+    private fun attachmentJson(
+        sha256: String = sha,
+        size: Long = 3,
+    ) = """{"id":"a-1","item_id":"item-1","category":"image","original_filename":"x.jpg","content_type":"image/jpeg",""" +
+        """"size_bytes":$size,"sha256":"$sha256","created_at":1700000000000,"updated_at":1700000000001,"version":1,"has_thumbnail":true}"""
+
+    private fun created() = MockResponse().setResponseCode(201).setHeader("Content-Type", "application/json").setBody(attachmentJson())
+
+    private fun list(vararg items: String) =
+        MockResponse().setResponseCode(200).setHeader("Content-Type", "application/json")
+            .setBody("""{"attachments":[${items.joinToString(",")}]}""")
+
+    private fun status(code: Int) =
+        MockResponse().setResponseCode(code).setHeader("Content-Type", "application/problem+json")
+            .setBody("""{"title":"x","status":$code}""")
+
+    private suspend fun enqueue() = repo.enqueue("item-1", source)
+
+    private suspend fun drain() = uploader.drain { now }
+
+    private fun insertCreate(
+        state: String = OutboxState.PENDING,
+        baseVersion: Long = 0,
+        entityType: String = "item",
+        entityId: String = "item-1",
+        op: String = "upsert",
+    ) = runBlocking {
+        db.outboxDao().insert(
+            OutboxMutationEntity(
+                mutationId = "m-${System.nanoTime()}",
+                entityType = entityType,
+                entityId = entityId,
+                op = op,
+                baseVersion = baseVersion,
+                fieldsJson = "{}",
+                state = state,
+                createdAt = 1,
+            ),
+        )
+    }
+
+    @Test
+    fun `201 deletes the entry and its file, sends the queue file name`() =
+        runTest {
+            val e = enqueue()
+            server.enqueue(created())
+            assertEquals(PhotoDrainOutcome.DRAINED, drain())
+            assertNull(db.photoQueueDao().getById(e.id))
+            assertFalse(File(e.filePath).exists())
+            assertEquals(1, server.requestCount)
+            val req = server.takeRequest()
+            assertEquals("/api/v1/items/item-1/attachments", req.path)
+            assertTrue(req.body.readUtf8().contains("filename=\"${File(e.filePath).name}\""))
+        }
+
+    @Test
+    fun `network failure then reconcile hit does not upload again`() =
+        runTest {
+            val e = enqueue()
+            server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AFTER_REQUEST))
+            assertEquals(PhotoDrainOutcome.RETRY_LATER, drain())
+            val after = db.photoQueueDao().getById(e.id)!!
+            assertEquals(PhotoState.QUEUED, after.state)
+            assertEquals(1, after.attemptCount)
+
+            now += 60_000
+            server.enqueue(list(attachmentJson()))
+            assertEquals(PhotoDrainOutcome.DRAINED, drain())
+            assertNull(db.photoQueueDao().getById(e.id))
+            assertFalse(File(e.filePath).exists())
+            assertEquals("one upload + one list, no second upload", 2, server.requestCount)
+            server.takeRequest()
+            assertEquals("GET", server.takeRequest().method)
+        }
+
+    @Test
+    fun `network failure then reconcile miss (same sha, different size) re-uploads`() =
+        runTest {
+            val e = enqueue()
+            server.enqueue(MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AFTER_REQUEST))
+            drain()
+            now += 60_000
+            server.enqueue(list(attachmentJson(size = 4), attachmentJson(sha256 = "00".repeat(32))))
+            server.enqueue(created())
+            assertEquals(PhotoDrainOutcome.DRAINED, drain())
+            assertNull(db.photoQueueDao().getById(e.id))
+            assertEquals(3, server.requestCount)
+            assertEquals(listOf("POST", "GET", "POST"), List(3) { server.takeRequest().method })
+        }
+
+    @Test
+    fun `entry found UPLOADING after process death reconciles first - hit`() =
+        runTest {
+            val e = enqueue()
+            repo.markUploading(e.id)
+            server.enqueue(list(attachmentJson()))
+            assertEquals(PhotoDrainOutcome.DRAINED, drain())
+            assertNull(db.photoQueueDao().getById(e.id))
+            assertEquals(1, server.requestCount)
+            assertEquals("GET", server.takeRequest().method)
+        }
+
+    @Test
+    fun `entry found UPLOADING after process death reconciles first - miss uploads`() =
+        runTest {
+            val e = enqueue()
+            repo.markUploading(e.id)
+            server.enqueue(list())
+            server.enqueue(created())
+            assertEquals(PhotoDrainOutcome.DRAINED, drain())
+            assertNull(db.photoQueueDao().getById(e.id))
+            assertEquals(listOf("GET", "POST"), List(2) { server.takeRequest().method })
+        }
+
+    @Test
+    fun `404 eight times ends FAILED and keeps the file`() =
+        runTest {
+            val e = enqueue()
+            repeat(8) {
+                server.enqueue(status(404))
+                drain()
+                now += 2 * PHOTO_BACKOFF_CAP_MS
+            }
+            val after = db.photoQueueDao().getById(e.id)!!
+            assertEquals(PhotoState.FAILED, after.state)
+            assertEquals(8, after.attemptCount)
+            assertTrue(File(e.filePath).exists())
+            assertEquals(8, server.requestCount)
+        }
+
+    @Test
+    fun `404 before the eighth attempt stays QUEUED with backoff`() =
+        runTest {
+            val e = enqueue()
+            server.enqueue(status(404))
+            assertEquals(PhotoDrainOutcome.RETRY_LATER, drain())
+            val after = db.photoQueueDao().getById(e.id)!!
+            assertEquals(PhotoState.QUEUED, after.state)
+            assertEquals(now + photoBackoffMillis(1), after.nextAttemptAt)
+            drain()
+            assertEquals(1, server.requestCount)
+        }
+
+    @Test
+    fun `413 fails at once without retry`() =
+        runTest {
+            val e = enqueue()
+            server.enqueue(status(413))
+            assertEquals(PhotoDrainOutcome.DRAINED, drain())
+            val after = db.photoQueueDao().getById(e.id)!!
+            assertEquals(PhotoState.FAILED, after.state)
+            assertEquals(1, after.attemptCount)
+            assertTrue(File(e.filePath).exists())
+        }
+
+    @Test
+    fun `other 4xx is terminal but 5xx is retryable`() =
+        runTest {
+            val bad = enqueue()
+            server.enqueue(status(422))
+            drain()
+            assertEquals(PhotoState.FAILED, db.photoQueueDao().getById(bad.id)!!.state)
+            val srv = enqueue()
+            server.enqueue(status(503))
+            drain()
+            assertEquals(PhotoState.QUEUED, db.photoQueueDao().getById(srv.id)!!.state)
+        }
+
+    @Test
+    fun `waits for a pending item create then uploads after it is acknowledged`() =
+        runTest {
+            val e = enqueue()
+            val seq = insertCreate()
+            drain()
+            assertEquals(0, server.requestCount)
+            val parked = db.photoQueueDao().getById(e.id)!!
+            assertEquals(PhotoState.WAITING_PARENT, parked.state)
+            assertEquals(0, parked.attemptCount)
+
+            drain()
+            assertEquals(0, server.requestCount)
+            assertEquals(PhotoState.WAITING_PARENT, db.photoQueueDao().getById(e.id)!!.state)
+
+            db.outboxDao().deleteBySeq(seq)
+            server.enqueue(created())
+            assertEquals(PhotoDrainOutcome.DRAINED, drain())
+            assertNull(db.photoQueueDao().getById(e.id))
+            assertEquals(1, server.requestCount)
+        }
+
+    @Test
+    fun `hasPendingCreate matches only live item creates`() =
+        runTest {
+            val dao = db.outboxDao()
+            assertFalse(dao.hasPendingCreate("item-1"))
+            insertCreate(baseVersion = 3)
+            insertCreate(entityType = "label")
+            insertCreate(op = "delete")
+            insertCreate(entityId = "other")
+            insertCreate(state = OutboxState.FAILED)
+            assertFalse(dao.hasPendingCreate("item-1"))
+            for (s in listOf(OutboxState.PENDING, OutboxState.IN_FLIGHT, OutboxState.HELD)) {
+                val seq = insertCreate(state = s)
+                assertTrue(s, dao.hasPendingCreate("item-1"))
+                dao.deleteBySeq(seq)
+            }
+        }
+
+    @Test
+    fun `401 stops the run without counting an attempt and leaves later entries untouched`() =
+        runTest {
+            val first = enqueue()
+            now += 1
+            val second = enqueue()
+            server.enqueue(status(401))
+            assertEquals(PhotoDrainOutcome.BLOCKED, drain())
+            val a = db.photoQueueDao().getById(first.id)!!
+            assertEquals(PhotoState.QUEUED, a.state)
+            assertEquals(0, a.attemptCount)
+            assertNull(a.nextAttemptAt)
+            assertEquals(PhotoState.QUEUED, db.photoQueueDao().getById(second.id)!!.state)
+            assertEquals(1, server.requestCount)
+        }
+
+    @Test
+    fun `426 also blocks without counting an attempt`() =
+        runTest {
+            val e = enqueue()
+            server.enqueue(
+                MockResponse().setResponseCode(426).setHeader("Content-Type", "application/problem+json")
+                    .setBody("""{"type":"urn:hho:problem:upgrade-required","title":"Upgrade Required","status":426,"minimum_version":"9.9.9"}"""),
+            )
+            assertEquals(PhotoDrainOutcome.BLOCKED, drain())
+            assertEquals(0, db.photoQueueDao().getById(e.id)!!.attemptCount)
+            assertNotNull(db.photoQueueDao().getById(e.id))
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/receiving/ReceivingRepositoryTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/receiving/ReceivingRepositoryTest.kt
new file mode 100644
index 0000000..b9a3724
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/receiving/ReceivingRepositoryTest.kt
@@ -0,0 +1,260 @@
+package dev.hho.android.data.receiving
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ReceivingStatus
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import kotlinx.coroutines.async
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.time.LocalDate
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ReceivingRepositoryTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var repo: ReceivingRepository
+    private var ids = 0
+    private var now = 1_000L
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        repo = ReceivingRepository(db, { "s-${ids++}" }, { now++ })
+    }
+
+    @After
+    fun tearDown() = db.close()
+
+    private suspend fun mirror(vararg itemIds: String) =
+        itemIds.forEach { db.itemDao().upsert(ItemEntity(it, 1, "n-$it", null, null, 0, null, null, null, 1)) }
+
+    private suspend fun open(): String {
+        mirror("a", "b", "c")
+        return repo.startSession("Acme", "PO-1", LocalDate.of(2026, 9, 1)).id
+    }
+
+    @Test
+    fun startSessionStoresTrimmedHeader() = runTest {
+        val s = repo.startSession("  Acme ", " PO-9 ", LocalDate.of(2026, 9, 1))
+        assertEquals("s-0", s.id)
+        assertEquals("Acme", s.vendor)
+        assertEquals("PO-9", s.orderReference)
+        assertEquals(ReceivingStatus.OPEN, db.receivingDao().getSession(s.id)?.status)
+        assertNull(repo.startSession("V", "  ").orderReference)
+        assertEquals(2, repo.observeOpenSessions().first().size)
+    }
+
+    @Test
+    fun blankVendorRejected() = runTest {
+        assertThrows(ReceivingException.InvalidArgument::class.java) { kotlinx.coroutines.runBlocking { repo.startSession("  ") } }
+    }
+
+    @Test
+    fun addExpectedIsIdempotentAndKeepsReceived() = runTest {
+        val s = open()
+        repo.addExpected(s, "a", 3)
+        repo.recordScan(s, "a")
+        repo.addExpected(s, "a", 3)
+        assertEquals(1, repo.observeLines(s).first().size)
+        assertEquals(1, db.receivingDao().getLine(s, "a")?.receivedQty)
+        repo.addExpected(s, "a", 5)
+        assertEquals(5, db.receivingDao().getLine(s, "a")?.expectedQty)
+        assertEquals(1, db.receivingDao().getLine(s, "a")?.receivedQty)
+    }
+
+    @Test
+    fun addExpectedRejectsBadQtyAndUnknownItem() = runTest {
+        val s = open()
+        assertThrows(ReceivingException.InvalidArgument::class.java) { kotlinx.coroutines.runBlocking { repo.addExpected(s, "a", 0) } }
+        assertThrows(ReceivingException.UnknownItem::class.java) { kotlinx.coroutines.runBlocking { repo.addExpected(s, "zzz", 1) } }
+        assertTrue(repo.observeLines(s).first().isEmpty())
+    }
+
+    @Test
+    fun scanExpectedIncrements() = runTest {
+        val s = open()
+        repo.addExpected(s, "a", 2)
+        repo.recordScan(s, "a")
+        val out = repo.recordScan(s, "a") as ScanOutcome.Counted
+        assertEquals(2, out.line.receivedQty)
+        assertEquals(2, out.line.expectedQty)
+    }
+
+    @Test
+    fun scanUnexpectedWritesNothingUntilConfirmed() = runTest {
+        val s = open()
+        repo.addExpected(s, "a", 1)
+        assertEquals(ScanOutcome.Unexpected("b"), repo.recordScan(s, "b"))
+        assertNull(db.receivingDao().getLine(s, "b"))
+        val line = repo.confirmUnexpected(s, "b")
+        assertNull(line.expectedQty)
+        assertEquals(1, line.receivedQty)
+        assertEquals(2, (repo.recordScan(s, "b") as ScanOutcome.Counted).line.receivedQty)
+        assertEquals(3, repo.confirmUnexpected(s, "b").receivedQty)
+    }
+
+    @Test
+    fun unexpectedCanBePromotedToExpected() = runTest {
+        val s = open()
+        repo.confirmUnexpected(s, "b")
+        val promoted = repo.addExpected(s, "b", 4)
+        assertEquals(4, promoted.expectedQty)
+        assertEquals(1, promoted.receivedQty)
+    }
+
+    @Test
+    fun scanUnknownItemRejected() = runTest {
+        val s = open()
+        assertThrows(ReceivingException.UnknownItem::class.java) { kotlinx.coroutines.runBlocking { repo.recordScan(s, "nope") } }
+        assertThrows(ReceivingException.UnknownItem::class.java) { kotlinx.coroutines.runBlocking { repo.confirmUnexpected(s, "nope") } }
+        assertTrue(repo.observeLines(s).first().isEmpty())
+    }
+
+    @Test
+    fun manualAdjustSetsAndBounds() = runTest {
+        val s = open()
+        repo.addExpected(s, "a", 2)
+        assertEquals(7, repo.setReceived(s, "a", 7).receivedQty)
+        assertEquals(0, repo.setReceived(s, "a", 0).receivedQty)
+        assertThrows(ReceivingException.InvalidArgument::class.java) { kotlinx.coroutines.runBlocking { repo.setReceived(s, "a", -1) } }
+        assertThrows(ReceivingException.LineNotFound::class.java) { kotlinx.coroutines.runBlocking { repo.setReceived(s, "b", 1) } }
+        assertEquals(0, db.receivingDao().getLine(s, "a")?.receivedQty)
+    }
+
+    @Test
+    fun discrepancyClassesAndTotals() = runTest {
+        val s = open()
+        repo.addExpected(s, "a", 2)
+        repo.addExpected(s, "b", 2)
+        repo.addExpected(s, "c", 2)
+        repo.recordScan(s, "a")
+        repo.setReceived(s, "b", 3)
+        repo.setReceived(s, "c", 2)
+        mirror("d")
+        repo.confirmUnexpected(s, "d")
+        val sum = repo.summary(s)
+        assertEquals(listOf("a"), sum.shortLines.map { it.itemId })
+        assertEquals(-1, sum.shortLines.single().difference)
+        assertEquals(listOf("b"), sum.overLines.map { it.itemId })
+        assertEquals(1, sum.overLines.single().difference)
+        assertEquals(listOf("d"), sum.unexpectedLines.map { it.itemId })
+        assertNull(sum.unexpectedLines.single().difference)
+        assertEquals(1, sum.matchedCount)
+        assertEquals(6, sum.totalExpected)
+        assertEquals(7, sum.totalReceived)
+        assertEquals(false, sum.isClean)
+        assertEquals(sum, repo.observeSummary(s).first())
+    }
+
+    @Test
+    fun cleanSummaryWhenAllMatch() = runTest {
+        val s = open()
+        repo.addExpected(s, "a", 1)
+        repo.recordScan(s, "a")
+        assertTrue(repo.summary(s).isClean)
+    }
+
+    @Test
+    fun cancelKeepsLinesAndIsIdempotent() = runTest {
+        val s = open()
+        repo.addExpected(s, "a", 1)
+        repo.cancel(s)
+        val row = db.receivingDao().getSession(s)!!
+        assertEquals(ReceivingStatus.CANCELLED, row.status)
+        assertTrue(row.completedAt != null)
+        assertEquals(1, repo.summary(s).lines.size)
+        repo.cancel(s)
+        assertTrue(repo.observeOpenSessions().first().isEmpty())
+    }
+
+    @Test
+    fun closedSessionsRejectMutations() = runTest {
+        val s = open()
+        repo.addExpected(s, "a", 1)
+        repo.cancel(s)
+        assertThrows(ReceivingException.SessionNotOpen::class.java) { kotlinx.coroutines.runBlocking { repo.addExpected(s, "b", 1) } }
+        assertThrows(ReceivingException.SessionNotOpen::class.java) { kotlinx.coroutines.runBlocking { repo.recordScan(s, "a") } }
+        assertThrows(ReceivingException.SessionNotOpen::class.java) { kotlinx.coroutines.runBlocking { repo.confirmUnexpected(s, "b") } }
+        assertThrows(ReceivingException.SessionNotOpen::class.java) { kotlinx.coroutines.runBlocking { repo.setReceived(s, "a", 1) } }
+        assertEquals(0, db.receivingDao().getLine(s, "a")?.receivedQty)
+        assertNull(db.receivingDao().getLine(s, "b"))
+    }
+
+    @Test
+    fun completedSessionRejectsCancelAndScan() = runTest {
+        val s = open()
+        val row = db.receivingDao().getSession(s)!!
+        db.receivingDao().updateSession(row.copy(status = ReceivingStatus.COMPLETED))
+        val e = assertThrows(ReceivingException.SessionNotOpen::class.java) { kotlinx.coroutines.runBlocking { repo.cancel(s) } }
+        assertEquals(ReceivingStatus.COMPLETED, e.status)
+        assertThrows(ReceivingException.SessionNotOpen::class.java) { kotlinx.coroutines.runBlocking { repo.recordScan(s, "a") } }
+    }
+
+    @Test
+    fun missingSession() = runTest {
+        assertThrows(ReceivingException.SessionNotFound::class.java) { kotlinx.coroutines.runBlocking { repo.cancel("ghost") } }
+        assertThrows(ReceivingException.SessionNotFound::class.java) { kotlinx.coroutines.runBlocking { repo.recordScan("ghost", "a") } }
+    }
+
+    @Test
+    fun flowsEmitUpdates() = runTest {
+        val s = open()
+        repo.addExpected(s, "a", 2)
+        repo.recordScan(s, "a")
+        assertEquals(1, repo.observeLines(s).first().single().receivedQty)
+        assertEquals("Acme", repo.observeSession(s).first()?.vendor)
+        assertNull(repo.observeSession("ghost").first())
+    }
+
+    @Test
+    fun concurrentAdjustsLandExactly() = kotlinx.coroutines.runBlocking {
+        val scope = this
+        val s = open()
+        repo.addExpected(s, "a", 100)
+        (1..50).map { scope.async(kotlinx.coroutines.Dispatchers.IO) { repo.adjustReceived(s, "a", 1) } }
+            .forEach { it.await() }
+        assertEquals(50, db.receivingDao().getLine(s, "a")?.receivedQty)
+        (1..80).map { scope.async(kotlinx.coroutines.Dispatchers.IO) { repo.adjustReceived(s, "a", -1) } }
+            .forEach { it.await() }
+        assertEquals(0, db.receivingDao().getLine(s, "a")?.receivedQty)
+    }
+
+    @Test
+    fun adjustNeverGoesBelowZeroAndReturnsLine() = runTest {
+        val s = open()
+        repo.addExpected(s, "a", 2)
+        assertEquals(0, repo.adjustReceived(s, "a", -1).receivedQty)
+        assertEquals(3, repo.adjustReceived(s, "a", 3).receivedQty)
+        assertEquals(0, repo.adjustReceived(s, "a", -9).receivedQty)
+    }
+
+    @Test
+    fun adjustRefusesClosedSessionMissingLineAndUnknownSession() = runTest {
+        val s = open()
+        repo.addExpected(s, "a", 2)
+        repo.adjustReceived(s, "a", 2)
+        assertThrows(ReceivingException.LineNotFound::class.java) {
+            kotlinx.coroutines.runBlocking { repo.adjustReceived(s, "b", 1) }
+        }
+        assertThrows(ReceivingException.SessionNotFound::class.java) {
+            kotlinx.coroutines.runBlocking { repo.adjustReceived("ghost", "a", 1) }
+        }
+        repo.cancel(s)
+        val e = assertThrows(ReceivingException.SessionNotOpen::class.java) {
+            kotlinx.coroutines.runBlocking { repo.adjustReceived(s, "a", 1) }
+        }
+        assertEquals(ReceivingStatus.CANCELLED, e.status)
+        assertEquals(2, db.receivingDao().getLine(s, "a")?.receivedQty)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/room/OutboxDaoTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/room/OutboxDaoTest.kt
new file mode 100644
index 0000000..5b08275
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/room/OutboxDaoTest.kt
@@ -0,0 +1,76 @@
+package dev.hho.android.data.room
+
+import android.database.sqlite.SQLiteConstraintException
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertThrows
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class OutboxDaoTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var dao: OutboxDao
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        dao = db.outboxDao()
+    }
+
+    @After
+    fun tearDown() = db.close()
+
+    @Test
+    fun insert_assignsIncreasingSeq_andReadsBackFifo() = runTest {
+        val s1 = dao.insert(sample("m-1", "a"))
+        val s2 = dao.insert(sample("m-2", "b"))
+        val s3 = dao.insert(sample("m-3", "a"))
+        assertEquals(listOf(1L, 2L, 3L), listOf(s1, s2, s3))
+        assertEquals(listOf("m-1", "m-2", "m-3"), dao.getAllOrdered().map { it.mutationId })
+    }
+
+    @Test
+    fun getByState_filtersAndLimitsInSeqOrder() = runTest {
+        dao.insert(sample("m-1", "a"))
+        dao.insert(sample("m-2", "b", OutboxState.HELD))
+        dao.insert(sample("m-3", "c"))
+        dao.insert(sample("m-4", "d"))
+        assertEquals(listOf("m-1", "m-3"), dao.getByState(OutboxState.PENDING, 2).map { it.mutationId })
+    }
+
+    @Test
+    fun getForEntity_returnsOnlyThatEntityInFifo() = runTest {
+        dao.insert(sample("m-1", "a"))
+        dao.insert(sample("m-2", "b"))
+        dao.insert(sample("m-3", "a", OutboxState.HELD))
+        assertEquals(listOf("m-1", "m-3"), dao.getForEntity("item", "a").map { it.mutationId })
+        assertEquals(emptyList<OutboxMutationEntity>(), dao.getForEntity("stock_adjustment", "a"))
+    }
+
+    @Test
+    fun duplicateMutationId_isRejected() = runTest {
+        dao.insert(sample("m-1", "a"))
+        assertThrows(SQLiteConstraintException::class.java) {
+            kotlinx.coroutines.runBlocking { dao.insert(sample("m-1", "b")) }
+        }
+    }
+
+    @Test
+    fun updateDeleteLookupAndCount() = runTest {
+        val s = dao.insert(sample("m-1", "a"))
+        dao.insert(sample("m-2", "b"))
+        dao.updateState(s, OutboxState.IN_FLIGHT)
+        assertEquals(OutboxState.IN_FLIGHT, dao.getByMutationId("m-1")?.state)
+        assertEquals(1, dao.observeCount(listOf(OutboxState.PENDING)).first())
+        dao.deleteBySeq(s)
+        assertNull(dao.getByMutationId("m-1"))
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/room/OutboxMigrationTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/room/OutboxMigrationTest.kt
new file mode 100644
index 0000000..65ffa39
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/room/OutboxMigrationTest.kt
@@ -0,0 +1,139 @@
+package dev.hho.android.data.room
+
+import androidx.room.testing.MigrationTestHelper
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class OutboxMigrationTest {
+
+    @get:Rule
+    val helper = MigrationTestHelper(
+        InstrumentationRegistry.getInstrumentation(),
+        HhoDatabase::class.java,
+    )
+
+    private fun indexNames(db: androidx.sqlite.db.SupportSQLiteDatabase, table: String): Set<String> =
+        db.query("SELECT name FROM sqlite_master WHERE type = 'index' AND tbl_name = '$table'").use { c ->
+            buildSet { while (c.moveToNext()) add(c.getString(0)) }
+        }
+
+    @Test
+    fun migration1To2_keepsV1Data_andCreatesOutboxWithIndexes() {
+        helper.createDatabase(DB, 1).use { v1 ->
+            v1.execSQL(
+                "INSERT INTO item (id, group_change_seq, name, version) VALUES ('item-1', 7, 'Hammer', 3)",
+            )
+            v1.execSQL("INSERT INTO sync_state (id, watermark, lastSyncedAt) VALUES (0, 42, 1000)")
+        }
+
+        val v2 = helper.runMigrationsAndValidate(DB, 2, true, MIGRATION_1_2)
+
+        v2.query("SELECT name, version, group_change_seq FROM item WHERE id = 'item-1'").use { c ->
+            assertTrue(c.moveToFirst())
+            assertEquals("Hammer", c.getString(0))
+            assertEquals(3, c.getInt(1))
+            assertEquals(7, c.getInt(2))
+        }
+        v2.query("SELECT watermark FROM sync_state WHERE id = 0").use { c ->
+            assertTrue(c.moveToFirst())
+            assertEquals(42L, c.getLong(0))
+        }
+        v2.query("SELECT COUNT(*) FROM outbox_mutation").use { c ->
+            assertTrue(c.moveToFirst())
+            assertEquals(0, c.getInt(0))
+        }
+        assertEquals(
+            setOf(
+                "index_outbox_mutation_mutation_id",
+                "index_outbox_mutation_state_seq",
+                "index_outbox_mutation_entity_type_entity_id",
+            ),
+            indexNames(v2, "outbox_mutation"),
+        )
+        v2.close()
+    }
+
+    @Test
+    fun migration1To2_createsEveryPhase4TableWithItsIndexes() {
+        helper.createDatabase(DB, 1).close()
+        val v2 = helper.runMigrationsAndValidate(DB, 2, true, MIGRATION_1_2)
+
+        val expected = mapOf(
+            "receiving_session" to setOf("index_receiving_session_status"),
+            "receiving_line" to emptySet(),
+            "photo_queue_entry" to setOf(
+                "index_photo_queue_entry_state_created_at",
+                "index_photo_queue_entry_item_id",
+            ),
+            "conflict_record" to setOf("index_conflict_record_mutation_id_entity_id_field_name"),
+            "sync_run_state" to emptySet(),
+        )
+        for ((table, indexes) in expected) {
+            v2.query("SELECT COUNT(*) FROM $table").use { c ->
+                assertTrue("$table missing", c.moveToFirst())
+                assertEquals(0, c.getInt(0))
+            }
+            assertEquals(table, indexes, indexNames(v2, table).filterNot { it.startsWith("sqlite_autoindex") }.toSet())
+        }
+        v2.execSQL("INSERT INTO sync_run_state (id) VALUES (0)")
+        v2.query("SELECT reconcile_pending FROM sync_run_state WHERE id = 0").use { c ->
+            assertTrue(c.moveToFirst())
+            assertEquals(0, c.getInt(0))
+        }
+        v2.execSQL(
+            "INSERT INTO conflict_record (mutation_id, entity_type, entity_id, field_name, detected_at, origin) " +
+                "VALUES ('m', 'item', 'e', 'name', 1, 'LOCAL_PUSH')",
+        )
+        val dup = runCatching {
+            v2.execSQL(
+                "INSERT INTO conflict_record (mutation_id, entity_type, entity_id, field_name, detected_at, origin) " +
+                    "VALUES ('m', 'item', 'e', 'name', 2, 'SERVER_LOG')",
+            )
+        }
+        assertTrue("unique (mutation_id, entity_id, field_name) not enforced", dup.exceptionOrNull() is android.database.sqlite.SQLiteConstraintException)
+        v2.close()
+    }
+
+    @Test
+    fun migratedDatabase_opensThroughRoom_andOutboxIsUsable() = runTest {
+        helper.createDatabase(DB, 1).close()
+        helper.runMigrationsAndValidate(DB, 2, true, MIGRATION_1_2).close()
+
+        val room = androidx.room.Room.databaseBuilder(
+            androidx.test.core.app.ApplicationProvider.getApplicationContext(),
+            HhoDatabase::class.java,
+            DB,
+        ).addMigrations(MIGRATION_1_2).build()
+        try {
+            val seq = room.outboxDao().insert(sample("m-1", "e-1"))
+            assertEquals(1L, seq)
+        } finally {
+            room.close()
+        }
+    }
+
+    private companion object {
+        const val DB = "migration-test"
+    }
+}
+
+internal fun sample(mutationId: String, entityId: String, state: String = OutboxState.PENDING) =
+    OutboxMutationEntity(
+        mutationId = mutationId,
+        entityType = "item",
+        entityId = entityId,
+        op = "upsert",
+        baseVersion = 0,
+        fieldsJson = "{}",
+        state = state,
+        createdAt = 1L,
+    )
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/room/Phase4DaoTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/room/Phase4DaoTest.kt
new file mode 100644
index 0000000..c30968d
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/room/Phase4DaoTest.kt
@@ -0,0 +1,172 @@
+package dev.hho.android.data.room
+
+import android.database.sqlite.SQLiteConstraintException
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertThrows
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.time.LocalDate
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class Phase4DaoTest {
+    private lateinit var db: HhoDatabase
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+    }
+
+    @After
+    fun tearDown() = db.close()
+
+    private fun session(id: String, status: String = ReceivingStatus.OPEN, createdAt: Long = 1) =
+        ReceivingSessionEntity(
+            id = id,
+            vendor = "Acme",
+            orderReference = "PO-1",
+            purchasedOn = LocalDate.of(2026, 3, 4),
+            status = status,
+            createdAt = createdAt,
+        )
+
+    @Test
+    fun receiving_sessionRoundTrips_andObservesByStatusNewestFirst() = runTest {
+        val dao = db.receivingDao()
+        dao.insertSession(session("s1", createdAt = 1))
+        dao.insertSession(session("s2", createdAt = 2))
+        dao.insertSession(session("s3", ReceivingStatus.COMPLETED, 3))
+        assertEquals(LocalDate.of(2026, 3, 4), dao.getSession("s1")?.purchasedOn)
+        assertEquals(listOf("s2", "s1"), dao.observeByStatus(ReceivingStatus.OPEN).first().map { it.id })
+        dao.updateSession(dao.getSession("s1")!!.copy(status = ReceivingStatus.COMPLETED, completedAt = 9))
+        assertEquals(listOf("s2"), dao.observeByStatus(ReceivingStatus.OPEN).first().map { it.id })
+        assertEquals(9L, dao.getSession("s1")?.completedAt)
+    }
+
+    @Test
+    fun receiving_linePkIsSessionAndItem_upsertReplaces_andAddReceivedIncrements() = runTest {
+        val dao = db.receivingDao()
+        dao.insertSession(session("s1"))
+        dao.upsertLine(ReceivingLineEntity("s1", "i1", expectedQty = 5, receivedQty = 0))
+        dao.upsertLine(ReceivingLineEntity("s1", "i2"))
+        dao.upsertLine(ReceivingLineEntity("s1", "i1", expectedQty = 6, receivedQty = 1))
+        assertEquals(listOf("i1", "i2"), dao.getLines("s1").map { it.itemId })
+        assertEquals(6, dao.getLines("s1").first().expectedQty)
+        assertNull(dao.getLines("s1")[1].expectedQty)
+
+        assertEquals(1, dao.addReceived("s1", "i1", 2))
+        assertEquals(3, dao.getLines("s1").first().receivedQty)
+        assertEquals(0, dao.addReceived("s1", "missing", 1))
+
+        dao.deleteLines("s1")
+        dao.deleteSession("s1")
+        assertEquals(emptyList<ReceivingLineEntity>(), dao.getLines("s1"))
+        assertNull(dao.getSession("s1"))
+    }
+
+    private fun photo(id: String, state: String = PhotoState.QUEUED, createdAt: Long = 1, next: Long? = null) =
+        PhotoQueueEntryEntity(
+            id = id,
+            itemId = "i1",
+            filePath = "/f/$id.jpg",
+            sha256 = "ab",
+            sizeBytes = 10,
+            category = "image",
+            state = state,
+            nextAttemptAt = next,
+            createdAt = createdAt,
+        )
+
+    @Test
+    fun photoQueue_ordersOldestFirst_filtersByState_andHonoursBackoff() = runTest {
+        val dao = db.photoQueueDao()
+        dao.insert(photo("p2", createdAt = 2))
+        dao.insert(photo("p1", createdAt = 1, next = 500))
+        dao.insert(photo("p3", PhotoState.WAITING_PARENT, 3))
+        dao.insert(photo("p4", PhotoState.FAILED, 4))
+        assertEquals(listOf("p1", "p2", "p3", "p4"), dao.getAllOrdered().map { it.id })
+        val eligible = listOf(PhotoState.QUEUED, PhotoState.WAITING_PARENT)
+        assertEquals(listOf("p1", "p2", "p3"), dao.getByStates(eligible).map { it.id })
+        assertEquals(listOf("p2", "p3"), dao.getDue(eligible, now = 100).map { it.id })
+        assertEquals(listOf("p1", "p2", "p3"), dao.getDue(eligible, now = 500).map { it.id })
+        assertEquals(1, dao.observeCount(listOf(PhotoState.FAILED)).first())
+    }
+
+    @Test
+    fun photoQueue_updateProgress_andDelete() = runTest {
+        val dao = db.photoQueueDao()
+        dao.insert(photo("p1"))
+        dao.updateProgress("p1", PhotoState.FAILED, 8, null, "413")
+        val row = dao.getById("p1")!!
+        assertEquals(PhotoState.FAILED, row.state)
+        assertEquals(8, row.attemptCount)
+        assertEquals("413", row.lastError)
+        dao.deleteById("p1")
+        assertNull(dao.getById("p1"))
+    }
+
+    @Test
+    fun photoQueue_duplicateIdIsRejected() = runTest {
+        val dao = db.photoQueueDao()
+        dao.insert(photo("p1"))
+        assertThrows(SQLiteConstraintException::class.java) { kotlinx.coroutines.runBlocking { dao.insert(photo("p1")) } }
+    }
+
+    private fun conflict(mutationId: String, entityId: String, field: String, origin: String = ConflictOrigin.LOCAL_PUSH, at: Long = 1) =
+        ConflictRecordEntity(
+            mutationId = mutationId,
+            entityType = "item",
+            entityId = entityId,
+            fieldName = field,
+            detectedAt = at,
+            origin = origin,
+        )
+
+    @Test
+    fun conflict_uniqueOnWireKey_secondInsertIsIgnored() = runTest {
+        val dao = db.conflictRecordDao()
+        val first = dao.insertIgnore(conflict("m1", "e1", "name"))
+        assertNotEquals(-1L, first)
+        assertEquals(-1L, dao.insertIgnore(conflict("m1", "e1", "name", ConflictOrigin.SERVER_LOG)))
+        assertNotEquals(-1L, dao.insertIgnore(conflict("m1", "e1", "description")))
+        assertNotEquals(-1L, dao.insertIgnore(conflict("m1", "e2", "name")))
+        assertNotEquals(-1L, dao.insertIgnore(conflict("m2", "e1", "name")))
+        assertEquals(4, dao.getAll().size)
+        assertEquals(ConflictOrigin.LOCAL_PUSH, dao.find("m1", "e1", "name")?.origin)
+    }
+
+    @Test
+    fun conflict_enrichFillsValues_andListIsNewestFirst() = runTest {
+        val dao = db.conflictRecordDao()
+        dao.insertIgnore(conflict("m1", "e1", "name", at = 10))
+        dao.insertIgnore(conflict("m2", "e1", "name", at = 20))
+        assertEquals(1, dao.enrich("m1", "e1", "name", "\"mine\"", "\"theirs\""))
+        assertEquals(0, dao.enrich("nope", "e1", "name", null, null))
+        val found = dao.find("m1", "e1", "name")!!
+        assertEquals("\"mine\"", found.losingValueJson)
+        assertEquals("\"theirs\"", found.serverValueJson)
+        assertEquals(listOf("m2", "m1"), dao.observeAll().first().map { it.mutationId })
+    }
+
+    @Test
+    fun syncRunState_isAbsentUntilWritten_andUpsertReplacesTheSingleton() = runTest {
+        val dao = db.syncRunStateDao()
+        assertNull(dao.get())
+        dao.upsert(SyncRunStateEntity(lastRunAt = 1, conflictCursor = "c1"))
+        dao.upsert(SyncRunStateEntity(lastRunAt = 2, lastError = "boom", lastErrorAt = 2, conflictCursor = "c2"))
+        val row = dao.observe().first()!!
+        assertEquals(SyncRunStateEntity.SINGLETON_ID, row.id)
+        assertEquals(2L, row.lastRunAt)
+        assertEquals("c2", row.conflictCursor)
+        assertNull(row.lastPushAt)
+        assertNull(db.syncStateDao().get())
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/room/RoomDaoTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/room/RoomDaoTest.kt
new file mode 100644
index 0000000..4aa58ba
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/room/RoomDaoTest.kt
@@ -0,0 +1,534 @@
+package dev.hho.android.data.room
+
+import androidx.room.withTransaction
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.SyncChange
+import dev.hho.android.data.apiclient.generated.models.ItemLabelAssignment
+import dev.hho.android.data.apiclient.generated.models.WarrantyBlock
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class RoomDaoTest {
+
+    private lateinit var db: HhoDatabase
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+    }
+
+    @Test
+    fun `item upsert, replace, deleteById and clearAll`() = runTest {
+        val dao = db.itemDao()
+        dao.upsert(itemFixture("item-1", name = "Drill"))
+        dao.upsert(itemFixture("item-2", name = "Saw"))
+        assertEquals("Drill", dao.getById("item-1")?.name)
+        assertEquals(2, dao.observeAll().first().size)
+
+        dao.upsert(itemFixture("item-1", name = "Drill v2"))
+        assertEquals("Drill v2", dao.getById("item-1")?.name)
+        assertEquals(2, dao.observeAll().first().size)
+
+        dao.deleteById("item-2")
+        assertNull(dao.getById("item-2"))
+        assertEquals(1, dao.observeAll().first().size)
+
+        dao.clearAll()
+        assertTrue(dao.observeAll().first().isEmpty())
+    }
+
+    @Test
+    fun `warranty_block upsert, replace, deleteById and clearAll`() = runTest {
+        val dao = db.warrantyBlockDao()
+        dao.upsert(warrantyFixture("wb-1", itemId = "item-1", holder = "Acme"))
+        dao.upsert(warrantyFixture("wb-2", itemId = "item-2", holder = "Globex"))
+        assertEquals("Acme", dao.getByItemId("item-1")?.holder)
+
+        dao.upsert(warrantyFixture("wb-1", itemId = "item-1", holder = "Acme v2"))
+        assertEquals("Acme v2", dao.getByItemId("item-1")?.holder)
+
+        dao.deleteById("wb-2")
+        assertNull(dao.getByItemId("item-2"))
+
+        dao.clearAll()
+        assertNull(dao.getByItemId("item-1"))
+    }
+
+    @Test
+    fun `sold_to_block upsert, replace, deleteById and clearAll`() = runTest {
+        val dao = db.soldToBlockDao()
+        dao.upsert(soldToFixture("st-1", itemId = "item-1", buyerName = "Jane"))
+        dao.upsert(soldToFixture("st-2", itemId = "item-2", buyerName = "Joe"))
+        assertEquals("Jane", dao.getByItemId("item-1")?.buyerName)
+
+        dao.upsert(soldToFixture("st-1", itemId = "item-1", buyerName = "Jane v2"))
+        assertEquals("Jane v2", dao.getByItemId("item-1")?.buyerName)
+
+        dao.deleteById("st-2")
+        assertNull(dao.getByItemId("item-2"))
+
+        dao.clearAll()
+        assertNull(dao.getByItemId("item-1"))
+    }
+
+    @Test
+    fun `purchased_from_block upsert, replace, deleteById and clearAll`() = runTest {
+        val dao = db.purchasedFromBlockDao()
+        dao.upsert(purchasedFromFixture("pf-1", itemId = "item-1", vendor = "Acme Store"))
+        dao.upsert(purchasedFromFixture("pf-2", itemId = "item-2", vendor = "Other Store"))
+        assertEquals("Acme Store", dao.getByItemId("item-1")?.vendor)
+
+        dao.upsert(purchasedFromFixture("pf-1", itemId = "item-1", vendor = "Acme Store v2"))
+        assertEquals("Acme Store v2", dao.getByItemId("item-1")?.vendor)
+
+        dao.deleteById("pf-2")
+        assertNull(dao.getByItemId("item-2"))
+
+        dao.clearAll()
+        assertNull(dao.getByItemId("item-1"))
+    }
+
+    @Test
+    fun `item_identification upsert, replace, deleteById and clearAll`() = runTest {
+        val dao = db.itemIdentificationDao()
+        dao.upsert(identificationFixture("ident-1", itemId = "item-1", value = "0111111111111"))
+        dao.upsert(identificationFixture("ident-2", itemId = "item-1", value = "0222222222222"))
+        assertEquals(2, dao.observeByItemId("item-1").first().size)
+
+        dao.upsert(identificationFixture("ident-1", itemId = "item-1", value = "0999999999999"))
+        val afterReplace = dao.observeByItemId("item-1").first()
+        assertEquals(2, afterReplace.size)
+        assertEquals("0999999999999", afterReplace.first { it.id == "ident-1" }.value)
+        assertTrue(dao.findByValue("0111111111111").isEmpty())
+
+        dao.deleteById("ident-2")
+        assertEquals(1, dao.observeByItemId("item-1").first().size)
+
+        dao.clearAll()
+        assertTrue(dao.observeByItemId("item-1").first().isEmpty())
+    }
+
+    @Test
+    fun `findByValue returns the matching identification row (FR-113)`() = runTest {
+        val dao = db.itemIdentificationDao()
+        dao.upsert(identificationFixture("ident-1", itemId = "item-1", value = "0111111111111"))
+        dao.upsert(identificationFixture("ident-2", itemId = "item-2", value = "0222222222222"))
+
+        val found = dao.findByValue("0111111111111")
+
+        assertEquals(1, found.size)
+        assertEquals("ident-1", found.single().id)
+        assertEquals("item-1", found.single().itemId)
+    }
+
+    @Test
+    fun `item_custom_field upsert, replace, deleteById and clearAll`() = runTest {
+        val dao = db.itemCustomFieldDao()
+        dao.upsert(customFieldFixture("cf-1", itemId = "item-1", name = "Warranty months"))
+        dao.upsert(customFieldFixture("cf-2", itemId = "item-1", name = "Color"))
+        assertEquals(2, dao.observeByItemId("item-1").first().size)
+
+        dao.upsert(customFieldFixture("cf-1", itemId = "item-1", name = "Warranty months v2"))
+        val afterReplace = dao.observeByItemId("item-1").first()
+        assertEquals(2, afterReplace.size)
+        assertEquals("Warranty months v2", afterReplace.first { it.id == "cf-1" }.name)
+
+        dao.deleteById("cf-2")
+        assertEquals(1, dao.observeByItemId("item-1").first().size)
+
+        dao.clearAll()
+        assertTrue(dao.observeByItemId("item-1").first().isEmpty())
+    }
+
+    @Test
+    fun `stock_adjustment upsert, replace, deleteById and clearAll`() = runTest {
+        val dao = db.stockAdjustmentDao()
+        dao.upsert(stockAdjustmentFixture("sa-1", itemId = "item-1", reason = "sold"))
+        dao.upsert(stockAdjustmentFixture("sa-2", itemId = "item-1", reason = "damaged"))
+        assertEquals(2, dao.observeByItemId("item-1").first().size)
+
+        dao.upsert(stockAdjustmentFixture("sa-1", itemId = "item-1", reason = "sold v2"))
+        val afterReplace = dao.observeByItemId("item-1").first()
+        assertEquals(2, afterReplace.size)
+        assertEquals("sold v2", afterReplace.first { it.id == "sa-1" }.reason)
+
+        dao.deleteById("sa-2")
+        assertEquals(1, dao.observeByItemId("item-1").first().size)
+
+        dao.clearAll()
+        assertTrue(dao.observeByItemId("item-1").first().isEmpty())
+    }
+
+    @Test
+    fun `location upsert, replace, deleteById and clearAll`() = runTest {
+        val dao = db.locationDao()
+        dao.upsert(locationFixture("loc-1", name = "Garage"))
+        dao.upsert(locationFixture("loc-2", name = "Attic"))
+        assertEquals("Garage", dao.getById("loc-1")?.name)
+        assertEquals(2, dao.observeAll().first().size)
+
+        dao.upsert(locationFixture("loc-1", name = "Garage v2"))
+        assertEquals("Garage v2", dao.getById("loc-1")?.name)
+        assertEquals(2, dao.observeAll().first().size)
+
+        dao.deleteById("loc-2")
+        assertNull(dao.getById("loc-2"))
+        assertEquals(1, dao.observeAll().first().size)
+
+        dao.clearAll()
+        assertTrue(dao.observeAll().first().isEmpty())
+    }
+
+    @Test
+    fun `label upsert, replace, deleteById and clearAll`() = runTest {
+        val dao = db.labelDao()
+        dao.upsert(labelFixture("label-1", name = "Fragile"))
+        dao.upsert(labelFixture("label-2", name = "Heavy"))
+        assertEquals("Fragile", dao.getById("label-1")?.name)
+        assertEquals(2, dao.observeAll().first().size)
+
+        dao.upsert(labelFixture("label-1", name = "Fragile v2"))
+        assertEquals("Fragile v2", dao.getById("label-1")?.name)
+        assertEquals(2, dao.observeAll().first().size)
+
+        dao.deleteById("label-2")
+        assertNull(dao.getById("label-2"))
+        assertEquals(1, dao.observeAll().first().size)
+
+        dao.clearAll()
+        assertTrue(dao.observeAll().first().isEmpty())
+    }
+
+    @Test
+    fun `item_label upsert, replace, deleteById and clearAll`() = runTest {
+        val dao = db.itemLabelDao()
+        dao.upsert(itemLabelFixture("il-1", itemId = "item-1", labelId = "label-1"))
+        dao.upsert(itemLabelFixture("il-2", itemId = "item-1", labelId = "label-2"))
+        assertEquals(2, dao.observeByItemId("item-1").first().size)
+
+        dao.upsert(itemLabelFixture("il-1", itemId = "item-1", labelId = "label-3"))
+        val afterReplace = dao.observeByItemId("item-1").first()
+        assertEquals(2, afterReplace.size)
+        assertEquals("label-3", afterReplace.first { it.id == "il-1" }.labelId)
+
+        dao.deleteById("il-2")
+        assertEquals(1, dao.observeByItemId("item-1").first().size)
+
+        dao.clearAll()
+        assertTrue(dao.observeByItemId("item-1").first().isEmpty())
+    }
+
+    @Test
+    fun `attachment upsert, replace, deleteById and clearAll`() = runTest {
+        val dao = db.attachmentDao()
+        dao.upsert(attachmentFixture("att-1", itemId = "item-1", filename = "a.jpg"))
+        dao.upsert(attachmentFixture("att-2", itemId = "item-1", filename = "b.jpg"))
+        assertEquals("a.jpg", dao.getById("att-1")?.originalFilename)
+
+        dao.upsert(attachmentFixture("att-1", itemId = "item-1", filename = "a-v2.jpg"))
+        assertEquals("a-v2.jpg", dao.getById("att-1")?.originalFilename)
+        assertEquals(2, dao.observeByItemId("item-1").first().size)
+
+        dao.deleteById("att-2")
+        assertEquals(1, dao.observeByItemId("item-1").first().size)
+
+        dao.clearAll()
+        assertTrue(dao.observeByItemId("item-1").first().isEmpty())
+    }
+
+    @Test
+    fun `sync_state get() is null before anything, round-trips, then clear() deletes the row`() = runTest {
+        val dao = db.syncStateDao()
+        assertNull(dao.get())
+
+        dao.upsert(SyncStateEntity(watermark = 10L, lastSyncedAt = 100L))
+        assertEquals(SyncStateEntity(watermark = 10L, lastSyncedAt = 100L), dao.get())
+
+        dao.upsert(SyncStateEntity(watermark = 20L, lastSyncedAt = 200L))
+        assertEquals(20L, dao.get()?.watermark)
+
+        dao.clear()
+        assertNull(dao.get())
+    }
+
+    @Test
+    fun `warranty_block PK persisted is the envelope id, never data itemId`() = runTest {
+        val dao = db.warrantyBlockDao()
+        val change =
+            SyncChange.WarrantyBlockChange(
+                id = "warranty-envelope-1",
+                groupChangeSeq = 1L,
+                data = warrantyBlockData(itemId = "item-alpha", holder = "H"),
+            )
+
+        dao.upsert(change.toEntity())
+
+        val persisted = dao.getByItemId("item-alpha")
+        assertEquals("warranty-envelope-1", persisted?.id)
+        assertNotEquals("item-alpha", persisted?.id)
+    }
+
+    @Test
+    fun `item_label PK persisted is the envelope id, never data itemId or labelId`() = runTest {
+        val dao = db.itemLabelDao()
+        val change =
+            SyncChange.ItemLabelChange(
+                id = "assignment-envelope-1",
+                groupChangeSeq = 1L,
+                data = ItemLabelAssignment(itemId = "item-beta", labelId = "label-beta"),
+            )
+
+        dao.upsert(change.toEntity())
+
+        val persisted = dao.observeByItemId("item-beta").first().single()
+        assertEquals("assignment-envelope-1", persisted.id)
+        assertNotEquals("item-beta", persisted.id)
+        assertNotEquals("label-beta", persisted.id)
+    }
+
+    @Test
+    fun `two warranty blocks for two different items persist independently, keyed by envelope id`() = runTest {
+        val dao = db.warrantyBlockDao()
+        val changeA =
+            SyncChange.WarrantyBlockChange(
+                id = "wb-env-a",
+                groupChangeSeq = 1L,
+                data = warrantyBlockData(itemId = "item-a", holder = "A"),
+            )
+        val changeB =
+            SyncChange.WarrantyBlockChange(
+                id = "wb-env-b",
+                groupChangeSeq = 1L,
+                data = warrantyBlockData(itemId = "item-b", holder = "B"),
+            )
+
+        dao.upsert(changeA.toEntity())
+        dao.upsert(changeB.toEntity())
+
+        assertEquals("wb-env-a", dao.getByItemId("item-a")?.id)
+        assertEquals("wb-env-b", dao.getByItemId("item-b")?.id)
+    }
+
+    private class BoomException : RuntimeException("boom")
+
+    @Test
+    fun `a multi-DAO transaction that throws rolls back atomically, including the watermark`() =
+        runTest {
+            val itemDao = db.itemDao()
+            val warrantyDao = db.warrantyBlockDao()
+            val syncStateDao = db.syncStateDao()
+
+            assertNull(syncStateDao.get())
+
+            val thrown =
+                runCatching {
+                    db.withTransaction {
+                        itemDao.upsert(itemFixture("item-tx-1", name = "Drill"))
+                        warrantyDao.upsert(warrantyFixture("wb-tx-1", itemId = "item-tx-1", holder = "H"))
+                        syncStateDao.upsert(SyncStateEntity(watermark = 42L, lastSyncedAt = 1L))
+                        throw BoomException()
+                    }
+                }.exceptionOrNull()
+
+            assertTrue(thrown is BoomException)
+            assertNull(itemDao.getById("item-tx-1"))
+            assertNull(warrantyDao.getByItemId("item-tx-1"))
+            assertNull(syncStateDao.get())
+
+            db.withTransaction {
+                itemDao.upsert(itemFixture("item-tx-1", name = "Drill"))
+                warrantyDao.upsert(warrantyFixture("wb-tx-1", itemId = "item-tx-1", holder = "H"))
+                syncStateDao.upsert(SyncStateEntity(watermark = 42L, lastSyncedAt = 1L))
+            }
+
+            assertEquals("Drill", itemDao.getById("item-tx-1")?.name)
+            assertEquals("H", warrantyDao.getByItemId("item-tx-1")?.holder)
+            assertEquals(42L, syncStateDao.get()?.watermark)
+        }
+
+    @Test
+    fun `applicationContext is a real Robolectric Android context`() {
+        val context = ApplicationProvider.getApplicationContext<android.content.Context>()
+        assertTrue(context is android.app.Application)
+        assertTrue(context.packageName.isNotBlank())
+    }
+}
+
+private fun itemFixture(id: String, name: String) =
+    ItemEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        name = name,
+        description = null,
+        locationId = null,
+        quantity = 1L,
+        shortCode = null,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+private fun warrantyFixture(id: String, itemId: String, holder: String) =
+    WarrantyBlockEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        isLifetime = false,
+        holder = holder,
+        provider = null,
+        startsOn = null,
+        expiresOn = null,
+        notes = null,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+private fun warrantyBlockData(itemId: String, holder: String) =
+    WarrantyBlock(
+        isLifetime = false,
+        itemId = itemId,
+        holder = holder,
+        provider = null,
+        startsOn = null,
+        expiresOn = null,
+        notes = null,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+private fun soldToFixture(id: String, itemId: String, buyerName: String) =
+    SoldToBlockEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        salePriceMinor = 100L,
+        buyerName = buyerName,
+        soldOn = null,
+        notes = null,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+private fun purchasedFromFixture(id: String, itemId: String, vendor: String) =
+    PurchasedFromBlockEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        purchasePriceMinor = 100L,
+        vendor = vendor,
+        purchasedOn = null,
+        orderReference = null,
+        notes = null,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+private fun identificationFixture(id: String, itemId: String, value: String) =
+    ItemIdentificationEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        kind = "barcode",
+        value = value,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+private fun customFieldFixture(id: String, itemId: String, name: String) =
+    ItemCustomFieldEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        name = name,
+        fieldType = "text",
+        fieldDefId = null,
+        textValue = "x",
+        numberValue = null,
+        boolValue = null,
+        dateValue = null,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+private fun stockAdjustmentFixture(id: String, itemId: String, reason: String) =
+    StockAdjustmentEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        delta = -1L,
+        resultingQuantity = 4L,
+        reason = reason,
+        note = null,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+private fun locationFixture(id: String, name: String) =
+    LocationEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        name = name,
+        parentId = null,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+private fun labelFixture(id: String, name: String) =
+    LabelEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        name = name,
+        color = "#ffffff",
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+private fun itemLabelFixture(id: String, itemId: String, labelId: String) =
+    ItemLabelEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        labelId = labelId,
+    )
+
+private fun attachmentFixture(id: String, itemId: String, filename: String) =
+    AttachmentEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        category = "image",
+        originalFilename = filename,
+        contentType = "image/jpeg",
+        sizeBytes = 10L,
+        sha256 = "abc123",
+        hasThumbnail = false,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/room/RoomTestDb.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/room/RoomTestDb.kt
new file mode 100644
index 0000000..31f12e8
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/room/RoomTestDb.kt
@@ -0,0 +1,22 @@
+package dev.hho.android.data.room
+
+import androidx.room.Room
+import androidx.test.core.app.ApplicationProvider
+
+internal fun inMemoryHhoDatabase(): HhoDatabase =
+    Room.inMemoryDatabaseBuilder(
+        ApplicationProvider.getApplicationContext(),
+        HhoDatabase::class.java,
+    ).build()
+
+internal fun fileHhoDatabase(name: String): HhoDatabase =
+    Room.databaseBuilder(
+        ApplicationProvider.getApplicationContext(),
+        HhoDatabase::class.java,
+        name,
+    ).build()
+
+internal fun deleteHhoDatabaseFile(name: String) {
+    val context: android.content.Context = ApplicationProvider.getApplicationContext()
+    context.deleteDatabase(name)
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/room/SyncChangeMappersTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/room/SyncChangeMappersTest.kt
new file mode 100644
index 0000000..ccd32d9
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/room/SyncChangeMappersTest.kt
@@ -0,0 +1,321 @@
+package dev.hho.android.data.room
+
+import dev.hho.android.data.apiclient.SyncChange
+import dev.hho.android.data.apiclient.generated.models.Attachment
+import dev.hho.android.data.apiclient.generated.models.Identification
+import dev.hho.android.data.apiclient.generated.models.Item
+import dev.hho.android.data.apiclient.generated.models.ItemCustomField
+import dev.hho.android.data.apiclient.generated.models.ItemLabelAssignment
+import dev.hho.android.data.apiclient.generated.models.Label
+import dev.hho.android.data.apiclient.generated.models.Location
+import dev.hho.android.data.apiclient.generated.models.PurchaseBlock
+import dev.hho.android.data.apiclient.generated.models.SaleBlock
+import dev.hho.android.data.apiclient.generated.models.StockAdjustment
+import dev.hho.android.data.apiclient.generated.models.WarrantyBlock
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Test
+import java.math.BigDecimal
+import java.time.LocalDate
+
+class SyncChangeMappersTest {
+
+    @Test
+    fun `item entity id and fields come from the envelope and payload`() {
+        val change =
+            SyncChange.ItemChange(
+                id = "item-envelope-id",
+                groupChangeSeq = 7L,
+                data =
+                    Item(
+                        name = "Drill",
+                        id = "item-envelope-id",
+                        description = "Cordless",
+                        locationId = "loc-1",
+                        quantity = 2L,
+                        shortCode = "AB12",
+                        createdAt = 100L,
+                        updatedAt = 200L,
+                        version = 3L,
+                    ),
+            )
+
+        val entity = change.toEntity()
+
+        assertEquals("item-envelope-id", entity.id)
+        assertEquals(7L, entity.groupChangeSeq)
+        assertEquals("Drill", entity.name)
+        assertEquals("Cordless", entity.description)
+        assertEquals("loc-1", entity.locationId)
+        assertEquals(2L, entity.quantity)
+        assertEquals("AB12", entity.shortCode)
+        assertEquals(100L, entity.createdAt)
+        assertEquals(200L, entity.updatedAt)
+        assertEquals(3L, entity.version)
+    }
+
+    @Test
+    fun `warranty block PK comes from the envelope id, never item_id`() {
+        val change =
+            SyncChange.WarrantyBlockChange(
+                id = "warranty-envelope-id",
+                groupChangeSeq = 1L,
+                data =
+                    WarrantyBlock(
+                        isLifetime = true,
+                        itemId = "item-42",
+                        holder = "Acme",
+                        provider = "Acme Warranty Co",
+                        startsOn = LocalDate.of(2026, 1, 1),
+                        expiresOn = LocalDate.of(2028, 1, 1),
+                        notes = "Extended",
+                        createdAt = 10L,
+                        updatedAt = 20L,
+                        version = 1L,
+                    ),
+            )
+
+        val entity = change.toEntity()
+
+        assertEquals("warranty-envelope-id", entity.id)
+        assertNotEquals(entity.id, entity.itemId)
+        assertEquals("item-42", entity.itemId)
+        assertEquals(true, entity.isLifetime)
+        assertEquals("Acme", entity.holder)
+        assertEquals("Acme Warranty Co", entity.provider)
+        assertEquals(LocalDate.of(2026, 1, 1), entity.startsOn)
+        assertEquals(LocalDate.of(2028, 1, 1), entity.expiresOn)
+        assertEquals("Extended", entity.notes)
+    }
+
+    @Test
+    fun `sold_to block PK comes from the envelope id, never item_id`() {
+        val change =
+            SyncChange.SoldToBlockChange(
+                id = "sold-to-envelope-id",
+                groupChangeSeq = 2L,
+                data =
+                    SaleBlock(
+                        salePriceMinor = 5000L,
+                        itemId = "item-7",
+                        buyerName = "Jane",
+                        soldOn = LocalDate.of(2026, 6, 1),
+                        notes = "eBay",
+                    ),
+            )
+
+        val entity = change.toEntity()
+
+        assertEquals("sold-to-envelope-id", entity.id)
+        assertNotEquals(entity.id, entity.itemId)
+        assertEquals("item-7", entity.itemId)
+        assertEquals(5000L, entity.salePriceMinor)
+        assertEquals("Jane", entity.buyerName)
+        assertEquals(LocalDate.of(2026, 6, 1), entity.soldOn)
+    }
+
+    @Test
+    fun `purchased_from block PK comes from the envelope id, never item_id`() {
+        val change =
+            SyncChange.PurchasedFromBlockChange(
+                id = "purchased-from-envelope-id",
+                groupChangeSeq = 3L,
+                data =
+                    PurchaseBlock(
+                        purchasePriceMinor = 12000L,
+                        itemId = "item-9",
+                        vendor = "Acme Store",
+                        purchasedOn = LocalDate.of(2025, 12, 25),
+                        orderReference = "ORD-1",
+                        notes = "Gift",
+                    ),
+            )
+
+        val entity = change.toEntity()
+
+        assertEquals("purchased-from-envelope-id", entity.id)
+        assertNotEquals(entity.id, entity.itemId)
+        assertEquals("item-9", entity.itemId)
+        assertEquals(12000L, entity.purchasePriceMinor)
+        assertEquals("Acme Store", entity.vendor)
+        assertEquals(LocalDate.of(2025, 12, 25), entity.purchasedOn)
+        assertEquals("ORD-1", entity.orderReference)
+    }
+
+    @Test
+    fun `item_identification entity id comes from the envelope, not data id`() {
+        val change =
+            SyncChange.ItemIdentificationChange(
+                id = "envelope-id",
+                groupChangeSeq = 4L,
+                data =
+                    Identification(
+                        kind = Identification.Kind.Barcode,
+                        value = "0123456789",
+                        id = "data-own-id-should-be-unused",
+                        itemId = "item-3",
+                    ),
+            )
+
+        val entity = change.toEntity()
+
+        assertEquals("envelope-id", entity.id)
+        assertNotEquals("data-own-id-should-be-unused", entity.id)
+        assertEquals("item-3", entity.itemId)
+        assertEquals("barcode", entity.kind)
+        assertEquals("0123456789", entity.value)
+    }
+
+    @Test
+    fun `item_custom_field entity id comes from the envelope, not data id`() {
+        val change =
+            SyncChange.ItemCustomFieldChange(
+                id = "envelope-id",
+                groupChangeSeq = 5L,
+                data =
+                    ItemCustomField(
+                        name = "Warranty months",
+                        fieldType = ItemCustomField.FieldType.Number,
+                        id = "data-own-id-should-be-unused",
+                        itemId = "item-5",
+                        fieldDefId = "def-1",
+                        numberValue = BigDecimal("12.50"),
+                    ),
+            )
+
+        val entity = change.toEntity()
+
+        assertEquals("envelope-id", entity.id)
+        assertNotEquals("data-own-id-should-be-unused", entity.id)
+        assertEquals("item-5", entity.itemId)
+        assertEquals("number", entity.fieldType)
+        assertEquals(BigDecimal("12.50"), entity.numberValue)
+        assertEquals("def-1", entity.fieldDefId)
+    }
+
+    @Test
+    fun `stock_adjustment entity id comes from the envelope, not data id`() {
+        val change =
+            SyncChange.StockAdjustmentChange(
+                id = "envelope-id",
+                groupChangeSeq = 6L,
+                data =
+                    StockAdjustment(
+                        delta = -1L,
+                        resultingQuantity = 4L,
+                        id = "data-own-id-should-be-unused",
+                        itemId = "item-6",
+                        reason = "sold",
+                    ),
+            )
+
+        val entity = change.toEntity()
+
+        assertEquals("envelope-id", entity.id)
+        assertNotEquals("data-own-id-should-be-unused", entity.id)
+        assertEquals("item-6", entity.itemId)
+        assertEquals(-1L, entity.delta)
+        assertEquals(4L, entity.resultingQuantity)
+        assertEquals("sold", entity.reason)
+    }
+
+    @Test
+    fun `location entity id comes from the envelope, not data id`() {
+        val change =
+            SyncChange.LocationChange(
+                id = "envelope-id",
+                groupChangeSeq = 8L,
+                data =
+                    Location(
+                        id = "data-own-id-should-be-unused",
+                        name = "Garage",
+                        createdAt = 1L,
+                        updatedAt = 2L,
+                        version = 1L,
+                        parentId = "loc-parent",
+                    ),
+            )
+
+        val entity = change.toEntity()
+
+        assertEquals("envelope-id", entity.id)
+        assertNotEquals("data-own-id-should-be-unused", entity.id)
+        assertEquals("Garage", entity.name)
+        assertEquals("loc-parent", entity.parentId)
+    }
+
+    @Test
+    fun `label entity id comes from the envelope, not data id`() {
+        val change =
+            SyncChange.LabelChange(
+                id = "envelope-id",
+                groupChangeSeq = 9L,
+                data =
+                    Label(
+                        id = "data-own-id-should-be-unused",
+                        name = "Fragile",
+                        color = "#ff0000",
+                        createdAt = 1L,
+                        updatedAt = 2L,
+                        version = 1L,
+                    ),
+            )
+
+        val entity = change.toEntity()
+
+        assertEquals("envelope-id", entity.id)
+        assertNotEquals("data-own-id-should-be-unused", entity.id)
+        assertEquals("Fragile", entity.name)
+        assertEquals("#ff0000", entity.color)
+    }
+
+    @Test
+    fun `item_label PK comes from the envelope id, never item_id or label_id`() {
+        val change =
+            SyncChange.ItemLabelChange(
+                id = "assignment-envelope-id",
+                groupChangeSeq = 10L,
+                data = ItemLabelAssignment(itemId = "item-1", labelId = "label-1"),
+            )
+
+        val entity = change.toEntity()
+
+        assertEquals("assignment-envelope-id", entity.id)
+        assertNotEquals(entity.id, entity.itemId)
+        assertNotEquals(entity.id, entity.labelId)
+        assertEquals("item-1", entity.itemId)
+        assertEquals("label-1", entity.labelId)
+    }
+
+    @Test
+    fun `attachment entity id comes from the envelope, not data id`() {
+        val change =
+            SyncChange.AttachmentChange(
+                id = "envelope-id",
+                groupChangeSeq = 11L,
+                data =
+                    Attachment(
+                        id = "data-own-id-should-be-unused",
+                        itemId = "item-8",
+                        category = Attachment.Category.Image,
+                        originalFilename = "photo.jpg",
+                        contentType = "image/jpeg",
+                        sizeBytes = 1024L,
+                        sha256 = "abc123",
+                        createdAt = 1L,
+                        updatedAt = 2L,
+                        version = 1L,
+                        hasThumbnail = true,
+                    ),
+            )
+
+        val entity = change.toEntity()
+
+        assertEquals("envelope-id", entity.id)
+        assertNotEquals("data-own-id-should-be-unused", entity.id)
+        assertEquals("item-8", entity.itemId)
+        assertEquals("image", entity.category)
+        assertEquals("photo.jpg", entity.originalFilename)
+        assertEquals(true, entity.hasThumbnail)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/scanner/BarcodeFrameAnalyzerTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/scanner/BarcodeFrameAnalyzerTest.kt
new file mode 100644
index 0000000..7373ae5
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/scanner/BarcodeFrameAnalyzerTest.kt
@@ -0,0 +1,117 @@
+package dev.hho.android.data.scanner
+
+import androidx.camera.core.ImageInfo
+import androidx.camera.core.ImageProxy
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class BarcodeFrameAnalyzerTest {
+
+    @Test
+    fun `forwards the frame to the scanner and reports a non-empty result`() =
+        runTest {
+            val expected = listOf(DecodedBarcode("12345", BarcodeFormat.EAN_13))
+            val scanner = FakeBarcodeScanner(expected)
+            var reported: List<DecodedBarcode>? = null
+            val analyzer =
+                BarcodeFrameAnalyzer(
+                    scanner = scanner,
+                    analyzerScope = this,
+                    onBarcodesDetected = { reported = it },
+                    onScanError = { error("unexpected error: $it") },
+                )
+            val imageProxy = FakeImageProxy()
+
+            analyzer.analyze(imageProxy)
+            advanceUntilIdle()
+
+            assertEquals(1, scanner.scanCallCount)
+            assertEquals(expected, reported)
+            assertEquals(1, imageProxy.closeCount)
+        }
+
+    @Test
+    fun `does not report a result when the scanner finds nothing, but still closes the frame once`() =
+        runTest {
+            val scanner = FakeBarcodeScanner(emptyList())
+            var reported: List<DecodedBarcode>? = null
+            val analyzer =
+                BarcodeFrameAnalyzer(
+                    scanner = scanner,
+                    analyzerScope = this,
+                    onBarcodesDetected = { reported = it },
+                )
+            val imageProxy = FakeImageProxy()
+
+            analyzer.analyze(imageProxy)
+            advanceUntilIdle()
+
+            assertEquals(null, reported)
+            assertEquals(1, imageProxy.closeCount)
+        }
+
+    @Test
+    fun `closes the frame exactly once even when the scanner throws`() =
+        runTest {
+            val failure = RuntimeException("decode failed")
+            val scanner = FakeBarcodeScanner(toThrow = failure)
+            var reportedError: Throwable? = null
+            val analyzer =
+                BarcodeFrameAnalyzer(
+                    scanner = scanner,
+                    analyzerScope = this,
+                    onBarcodesDetected = { error("unexpected result: $it") },
+                    onScanError = { reportedError = it },
+                )
+            val imageProxy = FakeImageProxy()
+
+            analyzer.analyze(imageProxy)
+            advanceUntilIdle()
+
+            assertEquals(failure, reportedError)
+            assertEquals(1, imageProxy.closeCount)
+        }
+}
+
+private class FakeBarcodeScanner(
+    private val result: List<DecodedBarcode> = emptyList(),
+    private val toThrow: Throwable? = null,
+) : BarcodeScanner {
+    var scanCallCount = 0
+        private set
+
+    override suspend fun scan(imageProxy: ImageProxy): List<DecodedBarcode> {
+        scanCallCount++
+        toThrow?.let { throw it }
+        return result
+    }
+
+    override fun close() = Unit
+}
+
+private class FakeImageProxy : ImageProxy {
+    var closeCount = 0
+        private set
+
+    override fun close() {
+        closeCount++
+    }
+
+    override fun getCropRect() = throw UnsupportedOperationException("not exercised by this test")
+
+    override fun setCropRect(rect: android.graphics.Rect?) = Unit
+
+    override fun getFormat(): Int = 0
+
+    override fun getHeight(): Int = 0
+
+    override fun getWidth(): Int = 0
+
+    override fun getPlanes(): Array<ImageProxy.PlaneProxy> = emptyArray()
+
+    override fun getImageInfo(): ImageInfo = throw UnsupportedOperationException("not exercised by this test")
+
+    override fun getImage(): android.media.Image? = null
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/scanner/ZxingBarcodeScannerTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/scanner/ZxingBarcodeScannerTest.kt
new file mode 100644
index 0000000..a4074b3
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/scanner/ZxingBarcodeScannerTest.kt
@@ -0,0 +1,183 @@
+package dev.hho.android.data.scanner
+
+import androidx.camera.core.ImageInfo
+import androidx.camera.core.ImageProxy
+import com.google.zxing.EncodeHintType
+import com.google.zxing.qrcode.QRCodeWriter
+import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.nio.ByteBuffer
+import com.google.zxing.BarcodeFormat as ZxingFormat
+
+class ZxingBarcodeScannerTest {
+
+    @Test
+    fun `maps every ZXing format this project names`() {
+        val expected =
+            mapOf(
+                ZxingFormat.QR_CODE to BarcodeFormat.QR_CODE,
+                ZxingFormat.AZTEC to BarcodeFormat.AZTEC,
+                ZxingFormat.DATA_MATRIX to BarcodeFormat.DATA_MATRIX,
+                ZxingFormat.PDF_417 to BarcodeFormat.PDF_417,
+                ZxingFormat.CODE_39 to BarcodeFormat.CODE_39,
+                ZxingFormat.CODE_93 to BarcodeFormat.CODE_93,
+                ZxingFormat.CODE_128 to BarcodeFormat.CODE_128,
+                ZxingFormat.CODABAR to BarcodeFormat.CODABAR,
+                ZxingFormat.ITF to BarcodeFormat.ITF,
+                ZxingFormat.EAN_8 to BarcodeFormat.EAN_8,
+                ZxingFormat.EAN_13 to BarcodeFormat.EAN_13,
+                ZxingFormat.UPC_A to BarcodeFormat.UPC_A,
+                ZxingFormat.UPC_E to BarcodeFormat.UPC_E,
+            )
+        expected.forEach { (zx, ours) -> assertEquals(ours, mapZxingFormat(zx)) }
+    }
+
+    @Test
+    fun `unnamed or null format maps to UNKNOWN`() {
+        assertEquals(BarcodeFormat.UNKNOWN, mapZxingFormat(ZxingFormat.MAXICODE))
+        assertEquals(BarcodeFormat.UNKNOWN, mapZxingFormat(null))
+    }
+
+    @Test
+    fun `null text is dropped and non-null text is mapped`() {
+        assertEquals(null, mapZxingBarcode(null, ZxingFormat.QR_CODE))
+        assertEquals(DecodedBarcode("x", BarcodeFormat.EAN_13), mapZxingBarcode("x", ZxingFormat.EAN_13))
+    }
+
+    @Test
+    fun `repack drops row padding and honours pixel stride`() {
+        val plane = byteArrayOf(1, 9, 2, 9, 9, 3, 9, 4, 9, 9)
+        assertEquals(listOf<Byte>(1, 2, 3, 4), repackLuminance(plane, 2, 2, 5, 2).toList())
+    }
+
+    @Test
+    fun `rotate 90 clockwise turns a 2x3 into a 3x2`() {
+        val (data, w, h) = rotateLuminance(byteArrayOf(1, 2, 3, 4, 5, 6), 2, 3, 90)
+        assertEquals(3 to 2, w to h)
+        assertEquals(listOf<Byte>(5, 3, 1, 6, 4, 2), data.toList())
+        val (d270, _, _) = rotateLuminance(byteArrayOf(1, 2, 3, 4, 5, 6), 2, 3, 270)
+        assertEquals(listOf<Byte>(2, 4, 6, 1, 3, 5), d270.toList())
+        val (d180, _, _) = rotateLuminance(byteArrayOf(1, 2, 3, 4, 5, 6), 2, 3, 180)
+        assertEquals(listOf<Byte>(6, 5, 4, 3, 2, 1), d180.toList())
+    }
+
+    @Test
+    fun `decodes a real QR through the luminance path`() {
+        val q = qrLuminance("HHO-ITEM-42")
+        val result = decodeLuminance(q.data, q.size, q.size, q.size, 1, 0)
+        assertEquals(listOf(DecodedBarcode("HHO-ITEM-42", BarcodeFormat.QR_CODE)), result)
+    }
+
+    @Test
+    fun `decodes with row padding, pixel stride and rotation`() {
+        val q = qrLuminance("rotated-payload")
+        val (ccw, _, _) = rotateLuminance(q.data, q.size, q.size, 270)
+        val pixelStride = 2
+        val rowStride = q.size * pixelStride + 7
+        val strided = ByteArray(rowStride * q.size) { 0x55 }
+        for (y in 0 until q.size) for (x in 0 until q.size) {
+            strided[y * rowStride + x * pixelStride] = ccw[y * q.size + x]
+        }
+        val result = decodeLuminance(strided, q.size, q.size, rowStride, pixelStride, 90)
+        assertEquals(listOf(DecodedBarcode("rotated-payload", BarcodeFormat.QR_CODE)), result)
+    }
+
+    @Test
+    fun `blank frame yields an empty list without throwing`() {
+        assertTrue(decodeLuminance(ByteArray(64 * 64) { 0x80.toByte() }, 64, 64, 64, 1, 0).isEmpty())
+        assertTrue(decodeLuminance(ByteArray(0), 0, 0, 0, 1, 0).isEmpty())
+    }
+
+    @Test
+    fun `scan decodes a real QR from an ImageProxy and never closes it`() =
+        runTest {
+            val q = qrLuminance("via-proxy")
+            val proxy = ZxingFakeImageProxy(q.data, q.size, q.size, q.size, 1, 0)
+            val result = ZxingBarcodeScanner().scan(proxy)
+            assertEquals(listOf(DecodedBarcode("via-proxy", BarcodeFormat.QR_CODE)), result)
+            assertEquals(0, proxy.closeCount)
+        }
+
+    @Test
+    fun `scan on an imageless frame with no planes returns empty and does not close`() =
+        runTest {
+            val proxy = ZxingFakeImageProxy(ByteArray(0), 0, 0, 0, 1, 0, noPlanes = true)
+            assertTrue(ZxingBarcodeScanner().scan(proxy).isEmpty())
+            assertEquals(0, proxy.closeCount)
+        }
+
+    private class Qr(val data: ByteArray, val size: Int)
+
+    private fun qrLuminance(text: String): Qr {
+        val matrix =
+            QRCodeWriter().encode(
+                text,
+                ZxingFormat.QR_CODE,
+                240,
+                240,
+                mapOf(EncodeHintType.ERROR_CORRECTION to ErrorCorrectionLevel.M, EncodeHintType.MARGIN to 4),
+            )
+        val size = matrix.width
+        val data = ByteArray(size * size)
+        for (y in 0 until size) for (x in 0 until size) {
+            data[y * size + x] = if (matrix.get(x, y)) 0x00 else 0xFF.toByte()
+        }
+        return Qr(data, size)
+    }
+}
+
+private class ZxingFakeImageProxy(
+    y: ByteArray,
+    private val w: Int,
+    private val h: Int,
+    rowStride: Int,
+    pixelStride: Int,
+    rotation: Int,
+    noPlanes: Boolean = false,
+) : ImageProxy {
+    var closeCount = 0
+        private set
+
+    private val plane =
+        object : ImageProxy.PlaneProxy {
+            override fun getRowStride() = rowStride
+
+            override fun getPixelStride() = pixelStride
+
+            override fun getBuffer(): ByteBuffer = ByteBuffer.wrap(y)
+        }
+    private val planeArray: Array<ImageProxy.PlaneProxy> = if (noPlanes) emptyArray() else arrayOf(plane)
+    private val info =
+        object : ImageInfo {
+            override fun getRotationDegrees() = rotation
+
+            override fun getTimestamp() = 0L
+
+            override fun getTagBundle() = throw UnsupportedOperationException()
+
+            override fun populateExifData(exifBuilder: androidx.camera.core.impl.utils.ExifData.Builder) = Unit
+        }
+
+    override fun close() {
+        closeCount++
+    }
+
+    override fun getCropRect() = throw UnsupportedOperationException()
+
+    override fun setCropRect(rect: android.graphics.Rect?) = Unit
+
+    override fun getFormat(): Int = 0
+
+    override fun getHeight(): Int = h
+
+    override fun getWidth(): Int = w
+
+    override fun getPlanes(): Array<ImageProxy.PlaneProxy> = planeArray
+
+    override fun getImageInfo(): ImageInfo = info
+
+    override fun getImage(): android.media.Image? = null
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/ConflictLogSyncTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/ConflictLogSyncTest.kt
new file mode 100644
index 0000000..e0d3f0d
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/ConflictLogSyncTest.kt
@@ -0,0 +1,240 @@
+package dev.hho.android.data.sync
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.room.ConflictOrigin
+import dev.hho.android.data.room.ConflictRecordEntity
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.SyncRunStateEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ConflictLogSyncTest {
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(60)
+
+    private lateinit var db: HhoDatabase
+    private lateinit var sync: ConflictLogSync
+    private val server = MockWebServer()
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        sync = ConflictLogSync(apiClient(), db.conflictRecordDao(), SyncRunRecorder(db.syncRunStateDao()))
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+        server.shutdown()
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val file = File.createTempFile("hho-conflict-test", ".preferences_pb").also { it.deleteOnExit() }
+        val dataStore = PreferenceDataStoreFactory.create(produceFile = { file })
+        runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() } }
+        val cv = ClientVersionInterceptor()
+        val provider = object : DeviceTokenProvider {
+            override suspend fun tokenFor(requestUrl: HttpUrl): String? = "tok-secret"
+            override suspend fun invalidate(requestUrl: HttpUrl, rejectedToken: String) = Unit
+        }
+        val http = NetworkModule.provideOkHttpClient(BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore)), AuthHeaderInterceptor(provider), cv)
+        return HhoApiClient(http, NetworkModule.provideProbeOkHttpClient(http, cv))
+    }
+
+    private fun entry(
+        id: String,
+        at: Long,
+        mutation: String? = "m-$id",
+        entity: String = "e-$id",
+        field: String = "name",
+        server: String? = "\"S$id\"",
+        losing: String? = "\"L$id\"",
+    ): String {
+        fun q(v: String?) = v?.let { "\"" + it.replace("\\", "\\\\").replace("\"", "\\\"") + "\"" } ?: "null"
+        return """{"id":"$id","mutation_id":${q(mutation)},"entity_type":"item","entity_id":"$entity","field_name":"$field",""" +
+            """"server_value":${q(server)},"losing_client_value":${q(losing)},"detected_at":$at}"""
+    }
+
+    private fun page(cursor: String?, vararg entries: String) =
+        MockResponse().setResponseCode(200).setHeader("Content-Type", "application/json")
+            .setBody("""{"conflicts":[${entries.joinToString(",")}],"next_cursor":${cursor?.let { "\"$it\"" } ?: "null"}}""")
+
+    private fun problem(status: Int) = MockResponse().setResponseCode(status)
+        .setHeader("Content-Type", "application/problem+json")
+        .setBody("""{"type":"about:blank","title":"t","status":$status,"detail":"x"}""")
+
+    private suspend fun watermark() = db.syncRunStateDao().get()?.conflictCursor
+
+    @Test
+    fun `first sync pages through every page newest first and stores the watermark`() = runBlocking {
+        server.enqueue(page("c1", entry("d", 400), entry("c", 300)))
+        server.enqueue(page("c2", entry("b", 200)))
+        server.enqueue(page(null, entry("a", 100)))
+        val r = sync.sync(pageSize = 2).getOrThrow()
+        assertEquals(ConflictLogSyncResult(4, 4, 0, true), r)
+        assertEquals(4, db.conflictRecordDao().getAll().size)
+        assertTrue(db.conflictRecordDao().getAll().all { it.origin == ConflictOrigin.SERVER_LOG })
+        assertEquals("400", watermark())
+        val r1 = server.takeRequest()
+        assertNull(r1.requestUrl!!.queryParameter("after"))
+        assertEquals("2", r1.requestUrl!!.queryParameter("limit"))
+        assertEquals("c1", server.takeRequest().requestUrl!!.queryParameter("after"))
+        assertEquals("c2", server.takeRequest().requestUrl!!.queryParameter("after"))
+    }
+
+    @Test
+    fun `second sync fetches only newer entries and stops at the known one`() = runBlocking {
+        server.enqueue(page("c1", entry("b", 200)))
+        server.enqueue(page(null, entry("a", 100)))
+        sync.sync(pageSize = 1).getOrThrow()
+        server.takeRequest(); server.takeRequest()
+        server.enqueue(page("n1", entry("e", 400), entry("d", 300)))
+        server.enqueue(page("n2", entry("b", 200), entry("a", 100)))
+        val r = sync.sync(pageSize = 2).getOrThrow()
+        assertEquals(2, r.inserted)
+        assertEquals(1, r.merged)
+        assertEquals(2, server.requestCount - 2)
+        assertEquals(4, db.conflictRecordDao().getAll().size)
+        assertEquals("400", watermark())
+    }
+
+    @Test
+    fun `an up to date sync with a full log stops after the tie page and inserts nothing`() = runBlocking {
+        server.enqueue(page(null, entry("a", 100)))
+        sync.sync().getOrThrow()
+        server.enqueue(page("older", entry("a", 100)))
+        server.enqueue(page(null, entry("0", 50)))
+        val r = sync.sync().getOrThrow()
+        assertEquals(2, server.requestCount - 1)
+        
+        assertEquals(0, r.inserted)
+        assertEquals(1, db.conflictRecordDao().getAll().size)
+    }
+
+    @Test
+    fun `merges into an existing LOCAL_PUSH row without a duplicate`() = runBlocking {
+        db.conflictRecordDao().insertIgnore(
+            ConflictRecordEntity(
+                mutationId = "m-x", entityType = "item", entityId = "e-x", fieldName = "name",
+                losingValueJson = "\"mine\"", serverValueJson = null, detectedAt = 50, origin = ConflictOrigin.LOCAL_PUSH,
+            ),
+        )
+        server.enqueue(page(null, entry("x", 500, server = "\"theirs\"", losing = null)))
+        val r = sync.sync().getOrThrow()
+        assertEquals(1, r.merged)
+        assertEquals(0, r.inserted)
+        val rows = db.conflictRecordDao().getAll()
+        assertEquals(1, rows.size)
+        assertEquals("\"theirs\"", rows[0].serverValueJson)
+        assertEquals("\"mine\"", rows[0].losingValueJson)
+        assertEquals(500L, rows[0].detectedAt)
+        assertEquals(ConflictOrigin.SERVER_LOG, rows[0].origin)
+    }
+
+    @Test
+    fun `null mutation_id entries are idempotent and distinct per log id`() = runBlocking {
+        val a = entry("a", 100, mutation = null, entity = "same", field = "_entity", server = null, losing = null)
+        val b = entry("b", 100, mutation = null, entity = "same", field = "_entity", server = null, losing = null)
+        server.enqueue(page(null, b, a))
+        sync.sync().getOrThrow()
+        server.enqueue(page(null, b, a))
+        val r = sync.sync().getOrThrow()
+        assertEquals(0, r.inserted)
+        assertEquals(2, r.merged)
+        val rows = db.conflictRecordDao().getAll()
+        assertEquals(2, rows.size)
+        assertEquals(setOf("server:a", "server:b"), rows.map { it.mutationId }.toSet())
+        assertTrue(rows.all { it.serverValueJson == null && it.losingValueJson == null })
+    }
+
+    @Test
+    fun `explicit nulls and JSON text values decode and are stored verbatim`() = runBlocking {
+        server.enqueue(page(null, entry("a", 100, server = "{\"k\":[1,2]}", losing = null)))
+        sync.sync().getOrThrow()
+        val row = db.conflictRecordDao().getAll().single()
+        assertEquals("{\"k\":[1,2]}", row.serverValueJson)
+        assertNull(row.losingValueJson)
+    }
+
+    @Test
+    fun `401 and 5xx map to ApiError and do not advance the stored position`() = runBlocking {
+        server.enqueue(page(null, entry("a", 100)))
+        sync.sync().getOrThrow()
+        server.enqueue(problem(401))
+        assertTrue(sync.sync().exceptionOrNull() is ApiError.Unauthorized)
+        server.enqueue(problem(501))
+        assertTrue(sync.sync().exceptionOrNull() is ApiError.Server)
+        server.enqueue(page("c", entry("z", 900)))
+        server.enqueue(problem(503))
+        assertTrue(sync.sync(pageSize = 1).isFailure)
+        assertEquals("100", watermark())
+        server.enqueue(page("c", entry("z", 900)))
+        server.enqueue(page(null, entry("a", 100)))
+        val r = sync.sync(pageSize = 1).getOrThrow()
+        assertEquals(0, r.inserted)
+        assertEquals("900", watermark())
+        assertEquals(2, db.conflictRecordDao().getAll().size)
+    }
+
+    @Test
+    fun `hitting the page cap keeps the rows but does not advance the watermark`() = runBlocking {
+        server.enqueue(page("c1", entry("b", 200)))
+        server.enqueue(page("c2", entry("a", 100)))
+        val r = sync.sync(pageSize = 1, maxPages = 2).getOrThrow()
+        assertFalse(r.complete)
+        assertNull(watermark())
+        assertEquals(2, db.conflictRecordDao().getAll().size)
+    }
+
+    @Test
+    fun `request carries limit, bearer auth and the client version header`() = runBlocking {
+        server.enqueue(page(null))
+        sync.sync(pageSize = 7).getOrThrow()
+        val req = server.takeRequest()
+        assertEquals("/api/v1/sync/conflicts", req.requestUrl!!.encodedPath)
+        assertEquals("GET", req.method)
+        assertEquals("7", req.requestUrl!!.queryParameter("limit"))
+        assertEquals("Bearer tok-secret", req.getHeader("Authorization"))
+        assertTrue(req.getHeader("X-HHO-Client-Version") != null)
+        assertNull(watermark())
+    }
+
+    @Test
+    fun `advancing the watermark preserves the other sync run state`() = runBlocking {
+        db.syncRunStateDao().upsert(SyncRunStateEntity(lastRunAt = 5, lastError = "boom"))
+        server.enqueue(page(null, entry("a", 100)))
+        sync.sync().getOrThrow()
+        val s = db.syncRunStateDao().get()!!
+        assertEquals(5L, s.lastRunAt)
+        assertEquals("boom", s.lastError)
+        assertEquals("100", s.conflictCursor)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/ConflictLogTwoDeviceTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/ConflictLogTwoDeviceTest.kt
new file mode 100644
index 0000000..9297619
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/ConflictLogTwoDeviceTest.kt
@@ -0,0 +1,139 @@
+package dev.hho.android.data.sync
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.outbox.LocalMutation
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.ConflictOrigin
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.RecordedRequest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ConflictLogTwoDeviceTest {
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(30)
+
+    private val server = MockWebServer()
+    private lateinit var db: HhoDatabase
+    private lateinit var outbox: OutboxRepository
+    private var pushed = false
+    private var pushedMutationId: String? = null
+    private val paths = mutableListOf<String>()
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        outbox = OutboxRepository(db)
+        server.dispatcher = object : Dispatcher() {
+            @Synchronized
+            override fun dispatch(request: RecordedRequest): MockResponse {
+                val path = request.path.orEmpty()
+                paths += path.substringBefore('?')
+                return when {
+                    path.contains("/sync/push") -> {
+                        val mutationId = Json.parseToJsonElement(request.body.readUtf8()).jsonObject
+                            .getValue("mutations").let { (it as kotlinx.serialization.json.JsonArray).single() }
+                            .jsonObject.getValue("mutation_id").jsonPrimitive.content
+                        pushed = true
+                        pushedMutationId = mutationId
+                        json(
+                            """{"applied":[],"skipped":[],"conflicts":[{"mutation_id":"$mutationId","entity_type":"item","entity_id":"x","field_name":"name"}],"new_watermark":7}""",
+                        )
+                    }
+                    path.contains("/sync/pull") ->
+                        json(page(if (pushed) change("A-name", 2) else change("Original", 1), if (pushed) 8 else 5))
+                    path.contains("/sync/conflicts") && !pushed -> json("""{"conflicts":[],"next_cursor":null}""")
+                    path.contains("/sync/conflicts") ->
+                        json(
+                            """{"conflicts":[{"id":"log-1","mutation_id":"$pushedMutationId","entity_type":"item","entity_id":"x","field_name":"name","server_value":"\"A-name\"","losing_client_value":"\"B-name\"","detected_at":4242}],"next_cursor":null}""",
+                        )
+                    else -> MockResponse().setResponseCode(404)
+                }
+            }
+        }
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+        server.shutdown()
+    }
+
+    @Test
+    fun sameFieldConflict_appearsInConflictRecordWithBothValues_afterOneRun() = runBlocking {
+        val engine = testSyncEngine(apiClient(), db, outbox, withConflictLog = true)
+        assertTrue(engine.sync("device-b").isSuccess)
+        assertTrue(db.conflictRecordDao().getAll().isEmpty())
+
+        val base = checkNotNull(db.itemDao().getById("x")?.version)
+        val queued = outbox.enqueue(LocalMutation("item", "x", "upsert", base, buildJsonObject { put("name", JsonPrimitive("B-name")) }))
+        paths.clear()
+
+        val result = engine.sync("device-b")
+
+        assertEquals(SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.ConflictReconcile), result.getOrNull())
+        assertEquals(listOf("/sync/push", "/sync/pull", "/sync/conflicts"), paths.map { "/sync" + it.substringAfter("/sync") })
+        val row = db.conflictRecordDao().getAll().single()
+        assertEquals(queued.mutationId, row.mutationId)
+        assertEquals("x", row.entityId)
+        assertEquals("name", row.fieldName)
+        assertEquals("\"B-name\"", row.losingValueJson)
+        assertEquals("\"A-name\"", row.serverValueJson)
+        assertEquals(ConflictOrigin.SERVER_LOG, row.origin)
+        assertEquals("A-name", db.itemDao().getById("x")?.name)
+    }
+
+    private fun json(body: String) =
+        MockResponse().setResponseCode(200).setHeader("Content-Type", "application/json").setBody(body)
+
+    private fun change(name: String, version: Long) =
+        """{"entity_type":"item","id":"x","group_change_seq":$version,"data":{"id":"x","name":"$name","quantity":0,"created_at":1,"updated_at":1,"version":$version}}"""
+
+    private fun page(changes: String, next: Long) =
+        """{"changes":[$changes],"tombstones":[],"next_watermark":$next,"has_more":false}"""
+
+    private fun apiClient(): HhoApiClient {
+        val file = File.createTempFile("hho-two-device", ".preferences_pb").also { it.deleteOnExit() }
+        val dataStore = PreferenceDataStoreFactory.create(produceFile = { file })
+        runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() } }
+        val cv = ClientVersionInterceptor()
+        val provider = object : DeviceTokenProvider {
+            override suspend fun tokenFor(requestUrl: HttpUrl): String? = "tok-secret"
+
+            override suspend fun invalidate(requestUrl: HttpUrl, rejectedToken: String) = Unit
+        }
+        val http = NetworkModule.provideOkHttpClient(BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore)), AuthHeaderInterceptor(provider), cv)
+        return HhoApiClient(http, NetworkModule.provideProbeOkHttpClient(http, cv))
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/ConvergenceTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/ConvergenceTest.kt
new file mode 100644
index 0000000..0da2a14
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/ConvergenceTest.kt
@@ -0,0 +1,452 @@
+package dev.hho.android.data.sync
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.deleteHhoDatabaseFile
+import dev.hho.android.data.room.fileHhoDatabase
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ConvergenceTest {
+
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(30)
+
+    private val server = MockWebServer()
+
+    @Before
+    fun setUp() = Unit
+
+    @After
+    fun tearDown() {
+        server.shutdown()
+    }
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("convergence-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    private fun apiClient(server: MockWebServer = this.server): HhoApiClient {
+        val dataStore = tempDataStore()
+        runBlocking {
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() }
+        }
+        val clientVersionInterceptor = ClientVersionInterceptor()
+        val authHeaderInterceptor =
+            AuthHeaderInterceptor(
+                object : DeviceTokenProvider {
+                    override suspend fun tokenFor(requestUrl: HttpUrl): String? = "device-token"
+
+                    override suspend fun invalidate(
+                        requestUrl: HttpUrl,
+                        rejectedToken: String,
+                    ) = Unit
+                },
+            )
+        val baseUrlInterceptor = BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore))
+        val httpClient =
+            NetworkModule.provideOkHttpClient(baseUrlInterceptor, authHeaderInterceptor, clientVersionInterceptor)
+        val probeHttpClient = NetworkModule.provideProbeOkHttpClient(httpClient, clientVersionInterceptor)
+        return HhoApiClient(httpClient, probeHttpClient)
+    }
+
+    private fun engineFor(
+        db: HhoDatabase,
+        server: MockWebServer = this.server,
+    ): SyncEngine {
+        val client = apiClient(server)
+        return testSyncEngine(client, db)
+    }
+
+    private fun itemChangeJson(
+        id: String,
+        name: String,
+        groupChangeSeq: Long = 1,
+    ) = """
+        {"entity_type":"item","id":"$id","group_change_seq":$groupChangeSeq,
+         "data":{"id":"$id","name":"$name","created_at":1,"updated_at":1,"version":1}}
+        """.trimIndent()
+
+    private fun locationChangeJson(
+        id: String,
+        name: String,
+        groupChangeSeq: Long = 1,
+    ) = """
+        {"entity_type":"location","id":"$id","group_change_seq":$groupChangeSeq,
+         "data":{"id":"$id","name":"$name","created_at":1,"updated_at":1,"version":1}}
+        """.trimIndent()
+
+    private fun labelChangeJson(
+        id: String,
+        name: String,
+        color: String,
+        groupChangeSeq: Long = 1,
+    ) = """
+        {"entity_type":"label","id":"$id","group_change_seq":$groupChangeSeq,
+         "data":{"id":"$id","name":"$name","color":"$color","created_at":1,"updated_at":1,"version":1}}
+        """.trimIndent()
+
+    private fun itemLabelChangeJson(
+        id: String,
+        itemId: String,
+        labelId: String,
+        groupChangeSeq: Long = 1,
+    ) = """
+        {"entity_type":"item_label","id":"$id","group_change_seq":$groupChangeSeq,
+         "data":{"item_id":"$itemId","label_id":"$labelId"}}
+        """.trimIndent()
+
+    private fun warrantyBlockChangeJson(
+        id: String,
+        itemId: String,
+        holder: String,
+        groupChangeSeq: Long = 1,
+    ) = """
+        {"entity_type":"warranty_block","id":"$id","group_change_seq":$groupChangeSeq,
+         "data":{"is_lifetime":false,"item_id":"$itemId","holder":"$holder","created_at":1,"updated_at":1,"version":1}}
+        """.trimIndent()
+
+    private fun tombstoneJson(
+        entityType: String,
+        id: String,
+    ) = """{"entity_type":"$entityType","id":"$id","deleted_at":1}"""
+
+    private fun pageJson(
+        changes: List<String>,
+        tombstones: List<String> = emptyList(),
+        nextWatermark: Long,
+        hasMore: Boolean,
+    ) = """{"changes":[${changes.joinToString(",")}],"tombstones":[${tombstones.joinToString(",")}],"next_watermark":$nextWatermark,"has_more":$hasMore}"""
+
+    private fun errorResponse() =
+        MockResponse().setResponseCode(500).setBody(
+            """{"type":"urn:hho:problem:internal","title":"Internal Server Error","status":500}""",
+        )
+
+    private fun initialPages(): List<String> =
+        listOf(
+            pageJson(changes = listOf(locationChangeJson("loc-1", "Loc 1")), nextWatermark = 10, hasMore = true),
+            pageJson(
+                changes = listOf(itemChangeJson("item-1", "Item 1"), itemChangeJson("item-2", "Item 2")),
+                nextWatermark = 50,
+                hasMore = true,
+            ),
+            pageJson(
+                changes = listOf(itemChangeJson("item-3", "Item 3"), labelChangeJson("label-1", "Label 1", "red")),
+                nextWatermark = 80,
+                hasMore = true,
+            ),
+            pageJson(
+                changes = listOf(itemLabelChangeJson("il-1", "item-1", "label-1")),
+                nextWatermark = 100,
+                hasMore = false,
+            ),
+        )
+
+    private fun round1Pages(): List<String> =
+        listOf(
+            pageJson(changes = listOf(locationChangeJson("loc-2", "Loc 2")), nextWatermark = 101, hasMore = true),
+            pageJson(changes = listOf(itemChangeJson("item-1", "Item 1 updated")), nextWatermark = 102, hasMore = true),
+            pageJson(changes = listOf(warrantyBlockChangeJson("wb-1", "item-2", "Acme")), nextWatermark = 103, hasMore = true),
+            pageJson(
+                changes = emptyList(),
+                tombstones = listOf(tombstoneJson("item", "item-3")),
+                nextWatermark = 104,
+                hasMore = false,
+            ),
+        )
+
+    private fun round2Pages(): List<String> =
+        listOf(
+            pageJson(changes = listOf(itemChangeJson("item-4", "Item 4", groupChangeSeq = 555)), nextWatermark = 105, hasMore = true),
+            pageJson(changes = listOf(itemChangeJson("item-5", "Item 5", groupChangeSeq = 555)), nextWatermark = 106, hasMore = true),
+            pageJson(changes = listOf(itemLabelChangeJson("il-2", "item-4", "label-1")), nextWatermark = 107, hasMore = true),
+            pageJson(changes = listOf(labelChangeJson("label-1", "Label 1", "blue")), nextWatermark = 108, hasMore = true),
+            pageJson(
+                changes = emptyList(),
+                tombstones = listOf(tombstoneJson("location", "loc-1")),
+                nextWatermark = 109,
+                hasMore = false,
+            ),
+        )
+
+    private fun finalStatePages(): List<String> =
+        listOf(
+            pageJson(
+                changes = listOf(locationChangeJson("loc-2", "Loc 2"), itemChangeJson("item-1", "Item 1 updated")),
+                nextWatermark = 40,
+                hasMore = true,
+            ),
+            pageJson(
+                changes = listOf(itemChangeJson("item-2", "Item 2"), itemChangeJson("item-4", "Item 4", groupChangeSeq = 555)),
+                nextWatermark = 70,
+                hasMore = true,
+            ),
+            pageJson(
+                changes =
+                    listOf(
+                        itemChangeJson("item-5", "Item 5", groupChangeSeq = 555),
+                        labelChangeJson("label-1", "Label 1", "blue"),
+                    ),
+                nextWatermark = 95,
+                hasMore = true,
+            ),
+            pageJson(
+                changes =
+                    listOf(
+                        itemLabelChangeJson("il-1", "item-1", "label-1"),
+                        itemLabelChangeJson("il-2", "item-4", "label-1"),
+                        warrantyBlockChangeJson("wb-1", "item-2", "Acme"),
+                    ),
+                nextWatermark = 109,
+                hasMore = false,
+            ),
+        )
+
+    private suspend fun buildFinalStateOracle(): HhoDatabase {
+        val oracleServer = MockWebServer()
+        try {
+            finalStatePages().forEach { oracleServer.enqueue(MockResponse().setResponseCode(200).setBody(it)) }
+            val oracleDb = inMemoryHhoDatabase()
+            val result = engineFor(oracleDb, oracleServer).sync(deviceId = "device-oracle")
+            check(result.isSuccess) { "oracle full pull failed: ${result.exceptionOrNull()}" }
+            return oracleDb
+        } finally {
+            oracleServer.shutdown()
+        }
+    }
+
+    private suspend fun assertMirrorsConverge(
+        expected: HhoDatabase,
+        actual: HhoDatabase,
+    ) {
+        for (id in listOf("item-1", "item-2", "item-4", "item-5")) {
+            assertEquals("item $id", expected.itemDao().getById(id), actual.itemDao().getById(id))
+        }
+        assertNull("item-3 must be gone from the oracle", expected.itemDao().getById("item-3"))
+        assertNull("item-3 must be gone from the actual mirror", actual.itemDao().getById("item-3"))
+
+        assertEquals(expected.locationDao().getById("loc-2"), actual.locationDao().getById("loc-2"))
+        assertNull("loc-1 must be gone from the oracle", expected.locationDao().getById("loc-1"))
+        assertNull("loc-1 must be gone from the actual mirror", actual.locationDao().getById("loc-1"))
+
+        assertEquals(expected.labelDao().getById("label-1"), actual.labelDao().getById("label-1"))
+
+        assertEquals(
+            expected.itemLabelDao().observeByLabelId("label-1").first().sortedBy { it.id },
+            actual.itemLabelDao().observeByLabelId("label-1").first().sortedBy { it.id },
+        )
+        assertEquals(
+            expected.warrantyBlockDao().getByItemId("item-2"),
+            actual.warrantyBlockDao().getByItemId("item-2"),
+        )
+
+        assertEquals(expected.syncStateDao().get()?.watermark, actual.syncStateDao().get()?.watermark)
+    }
+
+    @Test
+    fun `a full pull followed by incremental pulls across several rounds converges to the same mirror and watermark as a single full pull of the final state`() =
+        runTest {
+            val deviceA = inMemoryHhoDatabase()
+            try {
+                (initialPages() + round1Pages() + round2Pages() + finalStatePages()).forEach {
+                    server.enqueue(MockResponse().setResponseCode(200).setBody(it))
+                }
+
+                val engineA = engineFor(deviceA)
+                val initialResult = engineA.sync(deviceId = "device-a")
+                assertTrue(initialResult.isSuccess)
+                assertEquals(
+                    SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.FirstSync),
+                    initialResult.getOrNull(),
+                )
+
+                val round1Result = engineA.sync(deviceId = "device-a")
+                assertTrue(round1Result.isSuccess)
+                assertEquals(SyncRunOutcome.IncrementalPullRan, round1Result.getOrNull())
+
+                val round2Result = engineA.sync(deviceId = "device-a")
+                assertTrue(round2Result.isSuccess)
+                assertEquals(SyncRunOutcome.IncrementalPullRan, round2Result.getOrNull())
+
+                assertEquals(109L, deviceA.syncStateDao().get()?.watermark)
+
+                val deviceB = inMemoryHhoDatabase()
+                try {
+                    val engineB = engineFor(deviceB)
+                    val deviceBResult = engineB.sync(deviceId = "device-b")
+                    assertTrue(deviceBResult.isSuccess)
+                    assertEquals(
+                        SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.FirstSync),
+                        deviceBResult.getOrNull(),
+                    )
+
+                    assertEquals(4 + 4 + 5 + 4, server.requestCount)
+                    assertMirrorsConverge(expected = deviceB, actual = deviceA)
+                } finally {
+                    deviceB.close()
+                }
+            } finally {
+                deviceA.close()
+            }
+        }
+
+    @Test
+    fun `a simulated process death mid-incremental-pull persists exactly page N's watermark, resumes without re-fetching, and converges to the full-pull oracle`() =
+        runTest {
+            val dbName = "t158f-mid-incremental-${System.nanoTime()}"
+            deleteHhoDatabaseFile(dbName)
+            var db = fileHhoDatabase(dbName)
+            try {
+                initialPages().forEach { server.enqueue(MockResponse().setResponseCode(200).setBody(it)) }
+                val initialResult = engineFor(db).sync(deviceId = "device-c")
+                assertTrue(initialResult.isSuccess)
+                repeat(initialPages().size) { server.takeRequest() }
+
+                server.enqueue(MockResponse().setResponseCode(200).setBody(round1Pages()[0]))
+                server.enqueue(MockResponse().setResponseCode(200).setBody(round1Pages()[1]))
+                server.enqueue(errorResponse())
+
+                val firstAttempt = engineFor(db).sync(deviceId = "device-c")
+
+                assertTrue(firstAttempt.isFailure)
+                assertTrue(firstAttempt.exceptionOrNull() is ApiError.Server)
+                assertEquals(102L, db.syncStateDao().get()?.watermark)
+                assertEquals("Loc 2", db.locationDao().getById("loc-2")?.name)
+                assertEquals("Item 1 updated", db.itemDao().getById("item-1")?.name)
+                assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":100"))
+                assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":101"))
+                assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":102"))
+
+                db.close()
+                db = fileHhoDatabase(dbName)
+
+                assertEquals(102L, db.syncStateDao().get()?.watermark)
+                assertEquals("Item 1 updated", db.itemDao().getById("item-1")?.name)
+
+                server.enqueue(MockResponse().setResponseCode(200).setBody(round1Pages()[2]))
+                server.enqueue(MockResponse().setResponseCode(200).setBody(round1Pages()[3]))
+
+                val round1Resumed = engineFor(db).sync(deviceId = "device-c")
+
+                assertTrue(round1Resumed.isSuccess)
+                assertEquals(SyncRunOutcome.IncrementalPullRan, round1Resumed.getOrNull())
+                assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":102"))
+                assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":103"))
+
+                assertEquals(104L, db.syncStateDao().get()?.watermark)
+                assertEquals("Acme", db.warrantyBlockDao().getByItemId("item-2")?.holder)
+                assertNull(db.itemDao().getById("item-3"))
+
+                round2Pages().forEach { server.enqueue(MockResponse().setResponseCode(200).setBody(it)) }
+                val round2Result = engineFor(db).sync(deviceId = "device-c")
+                assertTrue(round2Result.isSuccess)
+                repeat(round2Pages().size) { server.takeRequest() }
+
+                val oracle = buildFinalStateOracle()
+                try {
+                    assertMirrorsConverge(expected = oracle, actual = db)
+                } finally {
+                    oracle.close()
+                }
+            } finally {
+                db.close()
+                deleteHhoDatabaseFile(dbName)
+            }
+        }
+
+    @Test
+    fun `a process death mid-full-pull leaves the empty mirror and absent watermark untouched, and SyncEngine converges via a fresh full pull on restart`() =
+        runTest {
+            val dbName = "t158f-mid-full-${System.nanoTime()}"
+            deleteHhoDatabaseFile(dbName)
+            var db = fileHhoDatabase(dbName)
+            try {
+                server.enqueue(MockResponse().setResponseCode(200).setBody(pageJson(changes = listOf(locationChangeJson("loc-x", "Loc X")), nextWatermark = 10, hasMore = true)))
+                server.enqueue(errorResponse())
+
+                val firstAttempt = engineFor(db).sync(deviceId = "device-d")
+
+                assertTrue(firstAttempt.isFailure)
+                assertTrue(firstAttempt.exceptionOrNull() is ApiError.Server)
+                assertNull(db.locationDao().getById("loc-x"))
+                assertNull(db.syncStateDao().get())
+                server.takeRequest()
+                server.takeRequest()
+
+                db.close()
+                db = fileHhoDatabase(dbName)
+
+                assertNull(db.locationDao().getById("loc-x"))
+                assertNull(db.syncStateDao().get())
+
+                server.enqueue(MockResponse().setResponseCode(200).setBody(pageJson(changes = listOf(itemChangeJson("item-z", "Item Z")), nextWatermark = 5, hasMore = false)))
+
+                val secondAttempt = engineFor(db).sync(deviceId = "device-d")
+
+                assertTrue(secondAttempt.isSuccess)
+                assertEquals(
+                    SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.FirstSync),
+                    secondAttempt.getOrNull(),
+                )
+                assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":0"))
+                assertEquals("Item Z", db.itemDao().getById("item-z")?.name)
+                assertEquals(5L, db.syncStateDao().get()?.watermark)
+            } finally {
+                db.close()
+                deleteHhoDatabaseFile(dbName)
+            }
+        }
+
+    @Test
+    fun `a fresh device with no persisted watermark sends since 0 and is reported as FullPullRan(FirstSync), never an incremental pull`() =
+        runTest {
+            val db = inMemoryHhoDatabase()
+            try {
+                server.enqueue(MockResponse().setResponseCode(200).setBody(pageJson(changes = listOf(itemChangeJson("item-w", "Item W")), nextWatermark = 7, hasMore = false)))
+
+                val result = engineFor(db).sync(deviceId = "device-e")
+
+                assertTrue(result.isSuccess)
+                assertEquals(SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.FirstSync), result.getOrNull())
+                assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":0"))
+                assertEquals("Item W", db.itemDao().getById("item-w")?.name)
+                assertEquals(7L, db.syncStateDao().get()?.watermark)
+            } finally {
+                db.close()
+            }
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/FullSyncCoordinatorTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/FullSyncCoordinatorTest.kt
new file mode 100644
index 0000000..734d554
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/FullSyncCoordinatorTest.kt
@@ -0,0 +1,268 @@
+package dev.hho.android.data.sync
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.apiclient.UnknownSyncEntityTypeException
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.SyncStateEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class FullSyncCoordinatorTest {
+
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(15)
+
+    private val server = MockWebServer()
+    private lateinit var db: HhoDatabase
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+        server.shutdown()
+    }
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("full-sync-coordinator-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val dataStore = tempDataStore()
+        runBlocking {
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() }
+        }
+        val clientVersionInterceptor = ClientVersionInterceptor()
+        val authHeaderInterceptor =
+            AuthHeaderInterceptor(
+                object : DeviceTokenProvider {
+                    override suspend fun tokenFor(requestUrl: HttpUrl): String? = "device-token"
+
+                    override suspend fun invalidate(
+                        requestUrl: HttpUrl,
+                        rejectedToken: String,
+                    ) = Unit
+                },
+            )
+        val baseUrlInterceptor = BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore))
+        val httpClient =
+            NetworkModule.provideOkHttpClient(baseUrlInterceptor, authHeaderInterceptor, clientVersionInterceptor)
+        val probeHttpClient = NetworkModule.provideProbeOkHttpClient(httpClient, clientVersionInterceptor)
+        return HhoApiClient(httpClient, probeHttpClient)
+    }
+
+    private fun coordinator(): FullSyncCoordinator = FullSyncCoordinator(apiClient(), db)
+
+    private fun locationPageJson(
+        id: String,
+        nextWatermark: Long,
+        hasMore: Boolean,
+    ) = """
+        {
+          "changes": [
+            {"entity_type":"location","id":"$id","group_change_seq":1,
+             "data":{"id":"$id","name":"Loc $id","created_at":1,"updated_at":1,"version":1}}
+          ],
+          "tombstones": [],
+          "next_watermark": $nextWatermark,
+          "has_more": $hasMore
+        }
+        """.trimIndent()
+
+    private fun itemPageJson(
+        id: String,
+        nextWatermark: Long,
+        hasMore: Boolean,
+    ) = """
+        {
+          "changes": [
+            {"entity_type":"item","id":"$id","group_change_seq":2,
+             "data":{"id":"$id","name":"Item $id","created_at":1,"updated_at":1,"version":1}}
+          ],
+          "tombstones": [],
+          "next_watermark": $nextWatermark,
+          "has_more": $hasMore
+        }
+        """.trimIndent()
+
+    private fun emptyPageJson(
+        nextWatermark: Long,
+        hasMore: Boolean,
+    ) = """{"changes":[],"tombstones":[],"next_watermark":$nextWatermark,"has_more":$hasMore}"""
+
+    private fun unknownTombstonePageJson(
+        nextWatermark: Long,
+    ) = """
+        {
+          "changes": [],
+          "tombstones": [{"entity_type":"widget","id":"whatever","deleted_at":1}],
+          "next_watermark": $nextWatermark,
+          "has_more": false
+        }
+        """.trimIndent()
+
+    private fun seedPreviousSuccessfulPull(
+        itemId: String = "item-old",
+        watermark: Long = 5L,
+    ) = runBlocking {
+        db.itemDao().upsert(
+            ItemEntity(
+                id = itemId,
+                groupChangeSeq = 1L,
+                name = "Old item",
+                description = null,
+                locationId = null,
+                quantity = 1L,
+                shortCode = null,
+                createdAt = 1L,
+                updatedAt = 1L,
+                version = 1L,
+            ),
+        )
+        db.syncStateDao().upsert(SyncStateEntity(watermark = watermark, lastSyncedAt = 1L))
+    }
+
+    @Test
+    fun `pullFull loops until has_more is false, applying every page and advancing since from each page's own next_watermark`() =
+        runTest {
+            server.enqueue(MockResponse().setResponseCode(200).setBody(locationPageJson("loc-1", nextWatermark = 10, hasMore = true)))
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-1", nextWatermark = 20, hasMore = true)))
+            server.enqueue(MockResponse().setResponseCode(200).setBody(emptyPageJson(nextWatermark = 30, hasMore = false)))
+
+            val result = coordinator().pullFull(deviceId = "device-1")
+
+            assertTrue(result.isSuccess)
+            assertEquals(3, server.requestCount)
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":0"))
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":10"))
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":20"))
+            assertEquals("Loc loc-1", db.locationDao().getById("loc-1")?.name)
+            assertEquals("Item item-1", db.itemDao().getById("item-1")?.name)
+            assertEquals(30L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `a single-page full pull (has_more false immediately) issues exactly one request`() =
+        runTest {
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-1", nextWatermark = 5, hasMore = false)))
+
+            val result = coordinator().pullFull(deviceId = "device-1")
+
+            assertTrue(result.isSuccess)
+            assertEquals(1, server.requestCount)
+            assertEquals(5L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `a full pull always starts at since 0, even when a previous watermark is already stored locally`() =
+        runTest {
+            seedPreviousSuccessfulPull(watermark = 999L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-1", nextWatermark = 5, hasMore = false)))
+
+            coordinator().pullFull(deviceId = "device-1")
+
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":0"))
+        }
+
+    @Test
+    fun `a successful full pull discards mirror rows the incoming pages never mention`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-stale", watermark = 1L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-1", nextWatermark = 5, hasMore = false)))
+
+            val result = coordinator().pullFull(deviceId = "device-1")
+
+            assertTrue(result.isSuccess)
+            assertNull(db.itemDao().getById("item-stale"))
+            assertEquals("Item item-1", db.itemDao().getById("item-1")?.name)
+        }
+
+    @Test
+    fun `an apply-time failure on a later page rolls back the whole pull, including pages already applied in this same transaction, and never advances the watermark`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-old", watermark = 5L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(locationPageJson("loc-1", nextWatermark = 10, hasMore = true)))
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-1", nextWatermark = 20, hasMore = true)))
+            server.enqueue(MockResponse().setResponseCode(200).setBody(unknownTombstonePageJson(nextWatermark = 30)))
+
+            val result = coordinator().pullFull(deviceId = "device-1")
+
+            assertTrue(result.isFailure)
+            assertTrue(result.exceptionOrNull() is UnknownSyncEntityTypeException)
+            assertNull(db.locationDao().getById("loc-1"))
+            assertNull(db.itemDao().getById("item-1"))
+            assertEquals("Old item", db.itemDao().getById("item-old")?.name)
+            assertEquals(5L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `a fetch-time failure on a later page never opens a transaction at all -- the prior mirror and watermark are untouched`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-old", watermark = 5L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(locationPageJson("loc-1", nextWatermark = 10, hasMore = true)))
+            server.enqueue(
+                MockResponse().setResponseCode(500).setBody(
+                    """{"type":"urn:hho:problem:internal","title":"Internal Server Error","status":500}""",
+                ),
+            )
+
+            val result = coordinator().pullFull(deviceId = "device-1")
+
+            assertTrue(result.isFailure)
+            assertTrue(result.exceptionOrNull() is ApiError.Server)
+            assertEquals(2, server.requestCount)
+            assertNull(db.locationDao().getById("loc-1"))
+            assertEquals("Old item", db.itemDao().getById("item-old")?.name)
+            assertEquals(5L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `cursor_too_old on a full pull's own since fails as drift and touches nothing`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-old", watermark = 5L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"cursor_too_old":true}"""))
+
+            val result = coordinator().pullFull(deviceId = "device-1")
+
+            assertTrue(result.isFailure)
+            assertTrue(result.exceptionOrNull() is UnexpectedCursorTooOldDuringFullPullException)
+            assertEquals("Old item", db.itemDao().getById("item-old")?.name)
+            assertEquals(5L, db.syncStateDao().get()?.watermark)
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/IncrementalSyncCoordinatorTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/IncrementalSyncCoordinatorTest.kt
new file mode 100644
index 0000000..ac52e99
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/IncrementalSyncCoordinatorTest.kt
@@ -0,0 +1,280 @@
+package dev.hho.android.data.sync
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.apiclient.UnknownSyncEntityTypeException
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.SyncStateEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class IncrementalSyncCoordinatorTest {
+
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(15)
+
+    private val server = MockWebServer()
+    private lateinit var db: HhoDatabase
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+        server.shutdown()
+    }
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("incremental-sync-coordinator-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val dataStore = tempDataStore()
+        runBlocking {
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() }
+        }
+        val clientVersionInterceptor = ClientVersionInterceptor()
+        val authHeaderInterceptor =
+            AuthHeaderInterceptor(
+                object : DeviceTokenProvider {
+                    override suspend fun tokenFor(requestUrl: HttpUrl): String? = "device-token"
+
+                    override suspend fun invalidate(
+                        requestUrl: HttpUrl,
+                        rejectedToken: String,
+                    ) = Unit
+                },
+            )
+        val baseUrlInterceptor = BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore))
+        val httpClient =
+            NetworkModule.provideOkHttpClient(baseUrlInterceptor, authHeaderInterceptor, clientVersionInterceptor)
+        val probeHttpClient = NetworkModule.provideProbeOkHttpClient(httpClient, clientVersionInterceptor)
+        return HhoApiClient(httpClient, probeHttpClient)
+    }
+
+    private fun coordinator(): IncrementalSyncCoordinator = IncrementalSyncCoordinator(apiClient(), db)
+
+    private fun locationPageJson(
+        id: String,
+        nextWatermark: Long,
+        hasMore: Boolean,
+    ) = """
+        {
+          "changes": [
+            {"entity_type":"location","id":"$id","group_change_seq":1,
+             "data":{"id":"$id","name":"Loc $id","created_at":1,"updated_at":1,"version":1}}
+          ],
+          "tombstones": [],
+          "next_watermark": $nextWatermark,
+          "has_more": $hasMore
+        }
+        """.trimIndent()
+
+    private fun itemPageJson(
+        id: String,
+        nextWatermark: Long,
+        hasMore: Boolean,
+    ) = """
+        {
+          "changes": [
+            {"entity_type":"item","id":"$id","group_change_seq":2,
+             "data":{"id":"$id","name":"Item $id","created_at":1,"updated_at":1,"version":1}}
+          ],
+          "tombstones": [],
+          "next_watermark": $nextWatermark,
+          "has_more": $hasMore
+        }
+        """.trimIndent()
+
+    private fun unknownTombstonePageJson(
+        nextWatermark: Long,
+        hasMore: Boolean = false,
+    ) = """
+        {
+          "changes": [],
+          "tombstones": [{"entity_type":"widget","id":"whatever","deleted_at":1}],
+          "next_watermark": $nextWatermark,
+          "has_more": $hasMore
+        }
+        """.trimIndent()
+
+    private fun seedPreviousSuccessfulPull(
+        itemId: String = "item-old",
+        watermark: Long = 5L,
+    ) = runBlocking {
+        db.itemDao().upsert(
+            ItemEntity(
+                id = itemId,
+                groupChangeSeq = 1L,
+                name = "Old item",
+                description = null,
+                locationId = null,
+                quantity = 1L,
+                shortCode = null,
+                createdAt = 1L,
+                updatedAt = 1L,
+                version = 1L,
+            ),
+        )
+        db.syncStateDao().upsert(SyncStateEntity(watermark = watermark, lastSyncedAt = 1L))
+    }
+
+    @Test
+    fun `pullIncremental starts at the persisted watermark, not zero, and merges onto the existing mirror rather than replacing it`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-old", watermark = 5L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-new", nextWatermark = 10, hasMore = false)))
+
+            val result = coordinator().pullIncremental(deviceId = "device-1")
+
+            assertTrue(result.isSuccess)
+            assertEquals(IncrementalPullOutcome.Applied, result.getOrNull())
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":5"))
+            assertEquals("Old item", db.itemDao().getById("item-old")?.name)
+            assertEquals("Item item-new", db.itemDao().getById("item-new")?.name)
+            assertEquals(10L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `an incremental pull with no persisted watermark starts at since 0`() =
+        runTest {
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-1", nextWatermark = 5, hasMore = false)))
+
+            val result = coordinator().pullIncremental(deviceId = "device-1")
+
+            assertTrue(result.isSuccess)
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":0"))
+            assertEquals(5L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `incremental pull commits each page's changes and watermark separately, never batching two pages into one transaction`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-old", watermark = 0L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(locationPageJson("loc-1", nextWatermark = 10, hasMore = true)))
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-1", nextWatermark = 20, hasMore = false)))
+
+            val result = coordinator().pullIncremental(deviceId = "device-1")
+
+            assertTrue(result.isSuccess)
+            assertEquals(2, server.requestCount)
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":0"))
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":10"))
+            assertEquals("Loc loc-1", db.locationDao().getById("loc-1")?.name)
+            assertEquals("Item item-1", db.itemDao().getById("item-1")?.name)
+            assertEquals(20L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `a simulated process death between page N's commit and page N+1's fetch resumes the next call at exactly page N's watermark`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-old", watermark = 0L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(locationPageJson("loc-1", nextWatermark = 10, hasMore = true)))
+            server.enqueue(
+                MockResponse().setResponseCode(500).setBody(
+                    """{"type":"urn:hho:problem:internal","title":"Internal Server Error","status":500}""",
+                ),
+            )
+
+            val firstCallResult = coordinator().pullIncremental(deviceId = "device-1")
+
+            assertTrue(firstCallResult.isFailure)
+            assertTrue(firstCallResult.exceptionOrNull() is ApiError.Server)
+            assertEquals("Loc loc-1", db.locationDao().getById("loc-1")?.name)
+            assertEquals(10L, db.syncStateDao().get()?.watermark)
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":0"))
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":10"))
+
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-1", nextWatermark = 20, hasMore = false)))
+
+            val secondCallResult = coordinator().pullIncremental(deviceId = "device-1")
+
+            assertTrue(secondCallResult.isSuccess)
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":10"))
+            assertEquals("Item item-1", db.itemDao().getById("item-1")?.name)
+            assertEquals(20L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `an apply-time failure on page N rolls back only page N, leaving every earlier page's own committed transaction intact`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-old", watermark = 0L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(locationPageJson("loc-1", nextWatermark = 10, hasMore = true)))
+            server.enqueue(MockResponse().setResponseCode(200).setBody(unknownTombstonePageJson(nextWatermark = 20, hasMore = false)))
+
+            val result = coordinator().pullIncremental(deviceId = "device-1")
+
+            assertTrue(result.isFailure)
+            assertTrue(result.exceptionOrNull() is UnknownSyncEntityTypeException)
+            assertEquals("Loc loc-1", db.locationDao().getById("loc-1")?.name)
+            assertEquals(10L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `cursor_too_old on the persisted watermark is reported as CursorTooOld and touches neither the mirror nor the watermark`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-old", watermark = 5L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"cursor_too_old":true}"""))
+
+            val result = coordinator().pullIncremental(deviceId = "device-1")
+
+            assertTrue(result.isSuccess)
+            assertEquals(IncrementalPullOutcome.CursorTooOld, result.getOrNull())
+            assertEquals("Old item", db.itemDao().getById("item-old")?.name)
+            assertEquals(5L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `a fetch-time failure on the first page never opens a transaction -- the prior mirror and watermark are untouched`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-old", watermark = 5L)
+            server.enqueue(
+                MockResponse().setResponseCode(500).setBody(
+                    """{"type":"urn:hho:problem:internal","title":"Internal Server Error","status":500}""",
+                ),
+            )
+
+            val result = coordinator().pullIncremental(deviceId = "device-1")
+
+            assertTrue(result.isFailure)
+            assertTrue(result.exceptionOrNull() is ApiError.Server)
+            assertEquals("Old item", db.itemDao().getById("item-old")?.name)
+            assertNull(db.locationDao().getById("loc-1"))
+            assertEquals(5L, db.syncStateDao().get()?.watermark)
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/OutboxSyncerTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/OutboxSyncerTest.kt
new file mode 100644
index 0000000..85d313e
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/OutboxSyncerTest.kt
@@ -0,0 +1,375 @@
+package dev.hho.android.data.sync
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.outbox.LocalMutation
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.ConflictOrigin
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.OutboxState
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.RecordedRequest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class OutboxSyncerTest {
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(60)
+
+    private lateinit var db: HhoDatabase
+    private lateinit var repo: OutboxRepository
+    private lateinit var syncer: OutboxSyncer
+    private val server = MockWebServer()
+    private var now = 5_000L
+
+    private val issuedClockValues = mutableListOf<Long>()
+    private fun tick(): Long = now++.also { issuedClockValues += it }
+    private val requests = mutableListOf<JsonObject>()
+
+    private var responder: (List<JsonObject>) -> MockResponse = { applyAll(it, 10) }
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        repo = OutboxRepository(db, ids = UuidV7Generator(clock = { 1_700_000_000_000L }, random = java.util.Random(42)), clock = ::tick)
+        server.dispatcher = object : Dispatcher() {
+            override fun dispatch(request: RecordedRequest): MockResponse {
+                val body = Json.parseToJsonElement(request.body.readUtf8()).jsonObject
+                requests += body
+                return responder(body["mutations"]!!.jsonArray.map { it.jsonObject })
+            }
+        }
+        syncer = OutboxSyncer(db, apiClient(), repo, clock = ::tick)
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+        server.shutdown()
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val file = File.createTempFile("hho-syncer-test", ".preferences_pb").also { it.deleteOnExit() }
+        val dataStore = PreferenceDataStoreFactory.create(produceFile = { file })
+        runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() } }
+        val cv = ClientVersionInterceptor()
+        val provider = object : DeviceTokenProvider {
+            override suspend fun tokenFor(requestUrl: HttpUrl): String? = null
+            override suspend fun invalidate(requestUrl: HttpUrl, rejectedToken: String) = Unit
+        }
+        val http = NetworkModule.provideOkHttpClient(BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore)), AuthHeaderInterceptor(provider), cv)
+        return HhoApiClient(http, NetworkModule.provideProbeOkHttpClient(http, cv))
+    }
+
+    private fun ids(muts: List<JsonObject>) = muts.map { it["mutation_id"]!!.jsonPrimitive.content }
+
+    private fun applyAll(muts: List<JsonObject>, version: Long) = json(
+        200,
+        """{"applied":[${muts.joinToString(",") { m ->
+            """{"mutation_id":"${m["mutation_id"]!!.jsonPrimitive.content}","entity_type":"${m["entity_type"]!!.jsonPrimitive.content}",""" +
+                """"entity_id":"${m["entity_id"]!!.jsonPrimitive.content}","version":$version}"""
+        }}],"skipped":[],"conflicts":[],"new_watermark":99}""",
+    )
+
+    private fun json(status: Int, body: String) =
+        MockResponse().setResponseCode(status).setHeader("Content-Type", "application/json").setBody(body)
+
+    private fun problem(status: Int, detail: String) = MockResponse().setResponseCode(status)
+        .setHeader("Content-Type", "application/problem+json")
+        .setBody("""{"type":"about:blank","title":"t","status":$status,"detail":${JsonPrimitive(detail)}}""")
+
+    private fun structural(id: String, index: Int = 0) = problem(400, """mutations[$index] (mutation_id="$id"): bad thing""")
+
+    private fun m(type: String, id: String, fields: String, base: Long = 1) =
+        LocalMutation(type, id, "upsert", base, Json.parseToJsonElement(fields).jsonObject)
+
+    private suspend fun enqueueItem(id: String, name: String = "N", base: Long = 1) = repo.enqueue(m("item", id, """{"name":"$name"}""", base))
+
+    private suspend fun rows() = db.outboxDao().getAllOrdered()
+
+    private suspend fun putItem(id: String, version: Long? = 1) =
+        db.itemDao().upsert(ItemEntity(id, 0, "old", null, null, 0, null, null, null, version))
+
+    @Test
+    fun applied_acksStampsMirrorVersion_releasesHeld_andDrains() = runBlocking {
+        putItem("a", 1)
+        val first = enqueueItem("a", "first")
+        val held = enqueueItem("a", "second")
+        assertTrue(held.coalesced)
+        repo.markInFlight(listOf(first.mutationId))
+        val follower = enqueueItem("a", "third")
+        assertEquals(OutboxState.HELD, follower.state)
+        repo.resetInFlightToPending()
+        responder = { applyAll(it, 7) }
+
+        val out = syncer.push("dev-1")
+
+        assertEquals(PushPhaseOutcome.Drained, out)
+        assertEquals(7L, db.itemDao().getById("a")!!.version)
+        assertEquals(2, requests.size)
+        assertEquals(7L, requests[1]["mutations"]!!.jsonArray.single().jsonObject["base_version"]!!.jsonPrimitive.content.toLong())
+        assertTrue(rows().isEmpty())
+        assertEquals("dev-1", requests[0]["device_id"]!!.jsonPrimitive.content)
+    }
+
+    @Test
+    fun skipped_acksButKeepsFollowersHeld() = runBlocking {
+        val first = enqueueItem("a", "first")
+        repo.markInFlight(listOf(first.mutationId))
+        val follower = enqueueItem("a", "second")
+        repo.resetInFlightToPending()
+        responder = { json(200, """{"applied":[],"skipped":[{"mutation_id":"${first.mutationId}"}],"conflicts":[],"new_watermark":1}""") }
+
+        val out = syncer.push("d")
+
+        assertEquals(PushPhaseOutcome.Drained, out)
+        val left = rows().single()
+        assertEquals(follower.mutationId, left.mutationId)
+        assertEquals(OutboxState.HELD, left.state)
+        assertEquals(1, requests.size)
+    }
+
+    @Test
+    fun conflicts_writeRecordPerField_deleteRow_needsReconcile() = runBlocking {
+        val e = repo.enqueue(m("item", "a", """{"name":"Mine","description":"D","location_id":"L"}"""))
+        responder = {
+            json(
+                200,
+                """{"applied":[],"skipped":[],"conflicts":[""" +
+                    """{"mutation_id":"${e.mutationId}","entity_type":"item","entity_id":"a","field_name":"name"},""" +
+                    """{"mutation_id":"${e.mutationId}","entity_type":"item","entity_id":"a","field_name":"description"}],"new_watermark":1}""",
+            )
+        }
+
+        val out = syncer.push("d")
+
+        assertEquals(PushPhaseOutcome.NeedsReconcile, out)
+        assertTrue(rows().isEmpty())
+        val recs = db.conflictRecordDao().getAll().sortedBy { it.fieldName }
+        assertEquals(listOf("description", "name"), recs.map { it.fieldName })
+        assertEquals(listOf("\"D\"", "\"Mine\""), recs.map { it.losingValueJson })
+        assertTrue(recs.all { it.origin == ConflictOrigin.LOCAL_PUSH && it.serverValueJson == null && it.mutationId == e.mutationId })
+    }
+
+    @Test
+    fun entitySentinelConflict_keepsWholeFields() = runBlocking {
+        val e = repo.enqueue(m("item", "gone", """{"name":"X"}"""))
+        responder = { json(200, """{"applied":[],"skipped":[],"conflicts":[{"mutation_id":"${e.mutationId}","entity_type":"item","entity_id":"gone","field_name":"_entity"}],"new_watermark":1}""") }
+
+        assertEquals(PushPhaseOutcome.NeedsReconcile, syncer.push("d"))
+        val rec = db.conflictRecordDao().getAll().single()
+        assertEquals("_entity", rec.fieldName)
+        assertEquals("""{"name":"X"}""", rec.losingValueJson)
+    }
+
+    @Test
+    fun structuralRejection_quarantinesOffender_resendsRest() = runBlocking {
+        val a = enqueueItem("a")
+        val b = enqueueItem("b")
+        val c = enqueueItem("c")
+        responder = { muts ->
+            if (ids(muts).contains(b.mutationId)) structural(b.mutationId, ids(muts).indexOf(b.mutationId)) else applyAll(muts, 3)
+        }
+
+        val out = syncer.push("d")
+
+        assertEquals(PushPhaseOutcome.Drained, out)
+        assertEquals(2, requests.size)
+        assertEquals(listOf(a.mutationId, c.mutationId), ids(requests[1]["mutations"]!!.jsonArray.map { it.jsonObject }))
+        val left = rows().single()
+        assertEquals(b.mutationId, left.mutationId)
+        assertEquals(OutboxState.FAILED, left.state)
+        assertTrue(left.lastError!!.contains("bad thing"))
+    }
+
+    @Test
+    fun unparseableStructural_isolatesBySingletons_findsOffender() = runBlocking {
+        val a = enqueueItem("a")
+        val b = enqueueItem("b")
+        val c = enqueueItem("c")
+        responder = { muts ->
+            when {
+                ids(muts).contains(b.mutationId) && muts.size > 1 -> problem(400, "mutations[?] garbled")
+                ids(muts) == listOf(b.mutationId) -> problem(400, "mutations[0] garbled")
+                else -> applyAll(muts, 3)
+            }
+        }
+
+        val out = syncer.push("d")
+
+        assertEquals(PushPhaseOutcome.Drained, out)
+        val left = rows().single()
+        assertEquals(b.mutationId, left.mutationId)
+        assertEquals(OutboxState.FAILED, left.state)
+        assertEquals(listOf(3, 1, 1, 1), requests.map { it["mutations"]!!.jsonArray.size })
+    }
+
+    @Test
+    fun envelope400_isUnattributable_failsAndKeepsAllRows() = runBlocking {
+        enqueueItem("a")
+        enqueueItem("b")
+        responder = { problem(400, "device_id is required") }
+
+        val out = syncer.push("d")
+
+        assertTrue(out is PushPhaseOutcome.Failed && out.cause is ApiError.Validation)
+        assertEquals(1, requests.size)
+        assertEquals(listOf(OutboxState.PENDING, OutboxState.PENDING), rows().map { it.state })
+        assertEquals(listOf(1, 1), rows().map { it.attemptCount })
+    }
+
+    @Test
+    fun unauthorized_blocksAuth_recordsAttempt_rowsStayPending() = runBlocking {
+        val a = enqueueItem("a")
+        responder = { problem(401, "no") }
+
+        val out = syncer.push("d")
+
+        assertEquals(PushPhaseOutcome.Blocked(BlockedReason.AUTH), out)
+        val row = rows().single()
+        assertEquals(a.mutationId, row.mutationId)
+        assertEquals(OutboxState.PENDING, row.state)
+        assertEquals(1, row.attemptCount)
+        assertTrue(row.lastAttemptAt != null)
+    }
+
+    @Test
+    fun upgradeRequired_blocks() = runBlocking {
+        enqueueItem("a")
+        responder = {
+            MockResponse().setResponseCode(426).setHeader("Content-Type", "application/problem+json")
+                .setBody("""{"type":"about:blank","title":"t","status":426,"detail":"old","minimum_version":"9.9.9"}""")
+        }
+
+        val out = syncer.push("d")
+
+        assertTrue(out is PushPhaseOutcome.Blocked && out.reason == BlockedReason.UPGRADE_REQUIRED)
+        assertEquals(1, rows().single().attemptCount)
+    }
+
+    @Test
+    fun serverError_failsThenRetrySucceeds() = runBlocking {
+        val a = enqueueItem("a")
+        responder = { problem(503, "down") }
+
+        val first = syncer.push("d")
+
+        assertTrue(first is PushPhaseOutcome.Failed && first.cause is ApiError.Server)
+        val row = rows().single()
+        assertEquals(OutboxState.PENDING, row.state)
+        assertEquals(1, row.attemptCount)
+        assertEquals(a.mutationId, row.mutationId)
+
+        responder = { applyAll(it, 2) }
+        assertEquals(PushPhaseOutcome.Drained, syncer.push("d"))
+        assertTrue(rows().isEmpty())
+        assertEquals(ids(requests[0]["mutations"]!!.jsonArray.map { it.jsonObject }), ids(requests[1]["mutations"]!!.jsonArray.map { it.jsonObject }))
+    }
+
+    @Test
+    fun transportFailure_failsWithNetwork() = runBlocking {
+        enqueueItem("a")
+        server.shutdown()
+
+        val out = syncer.push("d")
+
+        assertTrue(out is PushPhaseOutcome.Failed && out.cause is ApiError.Network)
+        assertEquals(1, rows().single().attemptCount)
+    }
+
+    @Test
+    fun multiBatchDrain_60Rows_inFifoOrder() = runBlocking {
+        val all = (1..60).map { enqueueItem("e$it").mutationId }
+
+        val out = syncer.push("d")
+
+        assertEquals(PushPhaseOutcome.Drained, out)
+        assertEquals(listOf(50, 10), requests.map { it["mutations"]!!.jsonArray.size })
+        assertEquals(all, requests.flatMap { r -> ids(r["mutations"]!!.jsonArray.map { it.jsonObject }) })
+        assertTrue(rows().isEmpty())
+    }
+
+    @Test
+    fun conflictThenTransientFailure_reportsReconcilePending() = runBlocking {
+        val a = enqueueItem("a")
+        enqueueItem("b")
+        var call = 0
+        responder = { muts ->
+            if (call++ == 0) {
+                json(200, """{"applied":[],"skipped":[],"conflicts":[{"mutation_id":"${a.mutationId}","entity_type":"item","entity_id":"a","field_name":"name"}],"new_watermark":1}""")
+            } else {
+                problem(503, "x")
+            }
+        }
+        val out = syncer.push("d")
+        assertTrue(out is PushPhaseOutcome.Failed && out.reconcilePending)
+    }
+
+    @Test
+    fun noRequestBodyCarriesAClientTimestamp() = runBlocking {
+        putItem("a")
+        enqueueItem("a")
+        repo.enqueue(m("stock_adjustment", "s1", """{"item_id":"a","delta":2}""", 0))
+        syncer.push("d")
+
+        assertTrue(requests.isNotEmpty())
+        assertTrue("clock was never consulted; test proves nothing", issuedClockValues.isNotEmpty())
+        val timestampKey = Regex("(_at|At)$|time|date", RegexOption.IGNORE_CASE)
+        val clockNumbers = issuedClockValues.map { it.toString() }.toSet()
+        fun walk(e: JsonElement, path: String) {
+            when (e) {
+                is JsonObject -> e.forEach { (k, v) ->
+                    assertFalse("timestamp-like key at $path.$k", timestampKey.containsMatchIn(k))
+                    walk(v, "$path.$k")
+                }
+                is JsonArray -> e.forEachIndexed { i, v -> walk(v, "$path[$i]") }
+                is JsonPrimitive -> assertFalse("clock value ${e.content} at $path", e.content in clockNumbers)
+            }
+        }
+        requests.forEachIndexed { i, body -> walk(body, "request[$i]") }
+    }
+
+    @Test
+    fun emptyOutbox_drainsWithoutRequest() = runBlocking {
+        assertEquals(PushPhaseOutcome.Drained, syncer.push("d"))
+        assertTrue(requests.isEmpty())
+        assertNull(server.takeRequest(10, java.util.concurrent.TimeUnit.MILLISECONDS))
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/PullInterplayTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/PullInterplayTest.kt
new file mode 100644
index 0000000..ce776c2
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/PullInterplayTest.kt
@@ -0,0 +1,324 @@
+package dev.hho.android.data.sync
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.apiclient.UnknownSyncEntityTypeException
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.outbox.OutboxOverlay
+import dev.hho.android.data.room.OutboxMutationEntity
+import dev.hho.android.data.room.OutboxState
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.SyncStateEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class PullInterplayTest {
+
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(15)
+
+    private val server = MockWebServer()
+    private lateinit var db: HhoDatabase
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+        server.shutdown()
+    }
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("incremental-sync-coordinator-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val dataStore = tempDataStore()
+        runBlocking {
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() }
+        }
+        val clientVersionInterceptor = ClientVersionInterceptor()
+        val authHeaderInterceptor =
+            AuthHeaderInterceptor(
+                object : DeviceTokenProvider {
+                    override suspend fun tokenFor(requestUrl: HttpUrl): String? = "device-token"
+
+                    override suspend fun invalidate(
+                        requestUrl: HttpUrl,
+                        rejectedToken: String,
+                    ) = Unit
+                },
+            )
+        val baseUrlInterceptor = BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore))
+        val httpClient =
+            NetworkModule.provideOkHttpClient(baseUrlInterceptor, authHeaderInterceptor, clientVersionInterceptor)
+        val probeHttpClient = NetworkModule.provideProbeOkHttpClient(httpClient, clientVersionInterceptor)
+        return HhoApiClient(httpClient, probeHttpClient)
+    }
+
+    private fun incremental() = IncrementalSyncCoordinator(apiClient(), db)
+
+    private fun full() = FullSyncCoordinator(apiClient(), db)
+
+    private fun page(changes: String = "", tombstones: String = "", next: Long, hasMore: Boolean = false) =
+        """{"changes":[$changes],"tombstones":[$tombstones],"next_watermark":$next,"has_more":$hasMore}"""
+
+    private fun itemChange(id: String, name: String, quantity: Long = 0, version: Long = 2) =
+        """{"entity_type":"item","id":"$id","group_change_seq":2,"data":{"id":"$id","name":"$name","quantity":$quantity,"created_at":1,"updated_at":1,"version":$version}}"""
+
+    private fun tomb(type: String, id: String) = """{"entity_type":"$type","id":"$id","deleted_at":1}"""
+
+    private fun enqueueBody(json: String) {
+        server.enqueue(MockResponse().setResponseCode(200).setBody(json))
+    }
+
+    private var n = 0
+
+    private suspend fun queue(
+        type: String, id: String, fields: String, base: Long = 0, state: String = OutboxState.PENDING,
+    ) = db.outboxDao().insert(
+        OutboxMutationEntity(
+            mutationId = "m-${n++}", entityType = type, entityId = id, op = "upsert", baseVersion = base,
+            fieldsJson = fields, state = state, createdAt = 0,
+        ),
+    )
+
+    private suspend fun seedItem(id: String, name: String, quantity: Long = 5, version: Long = 1) {
+        db.itemDao().upsert(ItemEntity(id, 1, name, null, null, quantity, "SC", 1, 1, version))
+    }
+
+    private suspend fun seedWatermark(w: Long) = db.syncStateDao().upsert(SyncStateEntity(watermark = w, lastSyncedAt = 1L))
+
+    @Test
+    fun `a full pull with a pending create keeps the not-yet-pushed item`() = runTest {
+        queue("item", "new-1", """{"name":"Local only"}""", base = 0)
+        enqueueBody(page(changes = itemChange("srv-1", "Server"), next = 9))
+
+        assertTrue(full().pullFull("d").isSuccess)
+
+        assertEquals("Local only", db.itemDao().getById("new-1")?.name)
+        assertEquals("Server", db.itemDao().getById("srv-1")?.name)
+        assertEquals(9L, db.syncStateDao().get()?.watermark)
+    }
+
+    @Test
+    fun `a full pull with a pending edit shows the edit over the pulled row`() = runTest {
+        queue("item", "i1", """{"name":"Edited"}""", base = 1)
+        enqueueBody(page(changes = itemChange("i1", "Server name"), next = 9))
+
+        assertTrue(full().pullFull("d").isSuccess)
+
+        assertEquals("Edited", db.itemDao().getById("i1")?.name)
+    }
+
+    @Test
+    fun `a pending create survives a full re-pull after cursor_too_old`() = runTest {
+        seedWatermark(3)
+        queue("item", "new-1", """{"name":"Local only"}""", base = 0)
+        enqueueBody("""{"cursor_too_old":true}""")
+        assertEquals(IncrementalPullOutcome.CursorTooOld, incremental().pullIncremental("d").getOrNull())
+        enqueueBody(page(changes = itemChange("srv-1", "Server"), next = 20))
+        assertTrue(full().pullFull("d").isSuccess)
+
+        assertEquals("Local only", db.itemDao().getById("new-1")?.name)
+        assertEquals("Server", db.itemDao().getById("srv-1")?.name)
+    }
+
+    @Test
+    fun `a pending edit survives an incremental page that updates the same row`() = runTest {
+        seedItem("i1", "Old")
+        seedWatermark(5)
+        queue("item", "i1", """{"name":"Mine"}""", base = 1)
+        enqueueBody(page(changes = itemChange("i1", "Theirs", version = 2), next = 10))
+
+        assertTrue(incremental().pullIncremental("d").isSuccess)
+
+        val row = db.itemDao().getById("i1")!!
+        assertEquals("Mine", row.name)
+        assertEquals(2L, row.version)
+        assertEquals(10L, db.syncStateDao().get()?.watermark)
+    }
+
+    @Test
+    fun `a tombstone beats a pending update and the orphan outbox row is left in place`() = runTest {
+        seedItem("i1", "Old")
+        seedWatermark(5)
+        queue("item", "i1", """{"name":"Mine"}""", base = 1)
+        enqueueBody(page(tombstones = tomb("item", "i1"), next = 10))
+
+        assertTrue(incremental().pullIncremental("d").isSuccess)
+
+        assertNull(db.itemDao().getById("i1"))
+        assertEquals(1, db.outboxDao().getAllOrdered().size)
+    }
+
+    @Test
+    fun `a tombstone and a same-page change for one id both leave a pending update skipped`() = runTest {
+        seedWatermark(5)
+        queue("item", "i1", """{"name":"Mine"}""", base = 1)
+        enqueueBody(page(changes = itemChange("i1", "Theirs"), tombstones = tomb("item", "i1"), next = 10))
+
+        assertTrue(incremental().pullIncremental("d").isSuccess)
+
+        assertNull(db.itemDao().getById("i1"))
+    }
+
+    @Test
+    fun `a pending create whose id arrives as a tombstone is re-applied`() = runTest {
+        seedWatermark(5)
+        queue("item", "c1", """{"name":"Created here"}""", base = 0, state = OutboxState.IN_FLIGHT)
+        enqueueBody(page(tombstones = tomb("item", "c1"), next = 10))
+
+        assertTrue(incremental().pullIncremental("d").isSuccess)
+
+        assertEquals("Created here", db.itemDao().getById("c1")?.name)
+    }
+
+    @Test
+    fun `an acked adjustment plus pulled quantity is not double counted, a still-pending one is added once`() = runTest {
+        seedItem("i1", "Drill", quantity = 5)
+        seedWatermark(5)
+        queue("stock_adjustment", "adj-2", """{"item_id":"i1","delta":2}""")
+        enqueueBody(page(changes = itemChange("i1", "Drill", quantity = 8), next = 10))
+
+        assertTrue(incremental().pullIncremental("d").isSuccess)
+
+        assertEquals(8L, db.itemDao().getById("i1")?.quantity)
+        assertEquals(10L, OutboxOverlay.derivedQuantity(db, "i1"))
+    }
+
+    @Test
+    fun `an acked adjustment alone leaves the derived quantity equal to the pulled one`() = runTest {
+        seedItem("i1", "Drill", quantity = 5)
+        seedWatermark(5)
+        enqueueBody(page(changes = itemChange("i1", "Drill", quantity = 8), next = 10))
+
+        assertTrue(incremental().pullIncremental("d").isSuccess)
+
+        assertEquals(8L, OutboxOverlay.derivedQuantity(db, "i1"))
+    }
+
+    private fun failReplayWrites() {
+        db.openHelper.writableDatabase.execSQL(
+            "CREATE TRIGGER fail_replay BEFORE INSERT ON stock_adjustment BEGIN SELECT RAISE(ABORT, 'boom'); END",
+        )
+    }
+
+    @Test
+    fun `the replay runs inside the page transaction, so a failing replay rolls back the page and its watermark`() = runTest {
+        seedItem("i1", "Old")
+        seedWatermark(5)
+        queue("stock_adjustment", "adj-1", """{"item_id":"i1","delta":2}""")
+        failReplayWrites()
+        enqueueBody(page(changes = itemChange("i1", "Theirs"), next = 10))
+
+        val result = incremental().pullIncremental("d")
+
+        assertTrue(result.isFailure)
+        assertEquals("Old", db.itemDao().getById("i1")?.name)
+        assertEquals(5L, db.syncStateDao().get()?.watermark)
+        assertEquals(OutboxState.PENDING, db.outboxDao().getAllOrdered().single().state)
+    }
+
+    @Test
+    fun `a failing replay rolls back a whole full pull, mirror and watermark`() = runTest {
+        seedItem("i1", "Old")
+        seedWatermark(5)
+        queue("stock_adjustment", "adj-1", """{"item_id":"i1","delta":2}""")
+        failReplayWrites()
+        enqueueBody(page(changes = itemChange("srv-1", "Server"), next = 10))
+
+        val result = full().pullFull("d")
+
+        assertTrue(result.isFailure)
+        assertEquals("Old", db.itemDao().getById("i1")?.name)
+        assertNull(db.itemDao().getById("srv-1"))
+        assertEquals(5L, db.syncStateDao().get()?.watermark)
+    }
+
+    private suspend fun queueCorruptHeldFollower() {
+        queue("item", "i1", """{"name":"Mine"}""", base = 1)
+        queue("item", "i1", "not json", base = 1, state = OutboxState.HELD)
+    }
+
+    private suspend fun assertCorruptQuarantined() {
+        val rows = db.outboxDao().getAllOrdered()
+        val bad = rows.single { it.fieldsJson == "not json" }
+        assertEquals(OutboxState.FAILED, bad.state)
+        assertTrue(bad.lastError!!.startsWith("Unreadable local edit: "))
+        assertEquals(OutboxState.PENDING, rows.single { it.fieldsJson != "not json" }.state)
+    }
+
+    @Test
+    fun `a corrupt HELD follower does not block an incremental pull and is quarantined`() = runTest {
+        seedItem("i1", "Old")
+        seedWatermark(5)
+        queueCorruptHeldFollower()
+        enqueueBody(page(changes = itemChange("i1", "Theirs"), next = 10))
+
+        assertTrue(incremental().pullIncremental("d").isSuccess)
+
+        assertEquals("Mine", db.itemDao().getById("i1")?.name)
+        assertEquals(10L, db.syncStateDao().get()?.watermark)
+        assertCorruptQuarantined()
+    }
+
+    @Test
+    fun `a corrupt HELD follower does not block a full pull and is quarantined`() = runTest {
+        seedItem("i1", "Old")
+        seedWatermark(5)
+        queue("item", "new-1", """{"name":"Local only"}""", base = 0)
+        queue("item", "new-1", "not json", base = 0, state = OutboxState.HELD)
+        enqueueBody(page(changes = itemChange("srv-1", "Server"), next = 10))
+
+        assertTrue(full().pullFull("d").isSuccess)
+
+        assertEquals("Server", db.itemDao().getById("srv-1")?.name)
+        assertEquals("Local only", db.itemDao().getById("new-1")?.name)
+        assertEquals(10L, db.syncStateDao().get()?.watermark)
+        assertCorruptQuarantined()
+    }
+
+    @Test
+    fun `a corrupt live stock adjustment does not break the derived quantity`() = runTest {
+        seedItem("i1", "Drill", quantity = 5)
+        queue("stock_adjustment", "adj-1", "not json")
+        queue("stock_adjustment", "adj-2", """{"item_id":"i1","delta":2}""")
+
+        assertEquals(7L, OutboxOverlay.derivedQuantity(db, "i1"))
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/StocktakeOfflineTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/StocktakeOfflineTest.kt
new file mode 100644
index 0000000..37d8787
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/StocktakeOfflineTest.kt
@@ -0,0 +1,429 @@
+package dev.hho.android.data.sync
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.outbox.LedgerFakeServer
+import dev.hho.android.data.outbox.OutboxOverlay
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.outbox.ledgerApiClient
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemLabelEntity
+import dev.hho.android.data.room.LabelEntity
+import dev.hho.android.data.room.LocationEntity
+import dev.hho.android.data.room.OutboxState
+import dev.hho.android.data.room.deleteHhoDatabaseFile
+import dev.hho.android.data.room.fileHhoDatabase
+import dev.hho.android.domain.EditRepository
+import dev.hho.android.domain.EditResult
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.longOrNull
+import okhttp3.Interceptor
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.Random
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class StocktakeOfflineTest {
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(120)
+
+    private val server = MockWebServer()
+    private val ledger = LedgerFakeServer()
+    private val httpCalls = AtomicInteger()
+    private val dbs = mutableListOf<HhoDatabase>()
+    private val dbName = "stocktake-offline-${System.nanoTime()}"
+
+    private val entityIds = UuidV7Generator(clock = { ID_EPOCH_MS }, random = Random(170_001))
+    private val mutationIds = UuidV7Generator(clock = { ID_EPOCH_MS + 1 }, random = Random(170_002))
+    private var tick = 1_000L
+
+    @Before
+    fun setUp() {
+        deleteHhoDatabaseFile(dbName)
+        server.dispatcher = ledger
+    }
+
+    @After
+    fun tearDown() {
+        dbs.forEach { runCatching { it.close() } }
+        deleteHhoDatabaseFile(dbName)
+        server.shutdown()
+    }
+
+    @Test
+    fun `50 offline edits survive a process death and a lost response, applied exactly once`() =
+        runBlocking {
+            val expected = Model.seed()
+            val edits = scenario()
+            assertEquals(50, edits.size)
+            edits.forEach { it.applyTo(expected) }
+
+            val tripwire = Interceptor { chain ->
+                httpCalls.incrementAndGet()
+                chain.proceed(chain.request())
+            }
+            val api = ledgerApiClient(server, listOf(tripwire))
+
+            var db = open()
+            seedMirror(db)
+            var syncTriggers = 0
+            val firstHalf = editRepo(db, onSync = { syncTriggers++ })
+            edits.take(25).forEach { it.perform(firstHalf) }
+            val beforeDeath = db.outboxDao().getAllOrdered()
+            assertEquals(25, beforeDeath.size)
+            db.close()
+
+            db = open()
+            val survivors = db.outboxDao().getAllOrdered()
+            assertEquals("no queued edit lost across the kill", beforeDeath.map { it.mutationId }, survivors.map { it.mutationId })
+            assertTrue(survivors.all { it.state == OutboxState.PENDING })
+            val secondHalf = editRepo(db, onSync = { syncTriggers++ })
+            edits.drop(25).forEach { it.perform(secondHalf) }
+
+            val queued = db.outboxDao().getAllOrdered()
+            assertEquals("every edit is one queued mutation", 50, queued.size)
+            assertEquals(50, queued.map { it.mutationId }.toSet().size)
+            assertEquals(queued.map { it.seq }.sorted(), queued.map { it.seq })
+            assertTrue(queued.all { it.state == OutboxState.PENDING })
+            assertEquals("each edit asked for a sync", 50, syncTriggers)
+            assertEquals("HhoApiClient must not be called offline (interceptor)", 0, httpCalls.get())
+            assertEquals("no request reached the server", 0, server.requestCount)
+            assertEquals(0, ledger.pushRequests)
+            assertMirror(db, expected)
+            expected.items.forEach { (id, m) ->
+                assertEquals("derived quantity of $id", m.quantity, OutboxOverlay.derivedQuantity(db, id))
+            }
+
+            ledger.faults += LedgerFakeServer.Fault.APPLY_THEN_DROP_RESPONSE
+            val first = OutboxSyncer(db, api, OutboxRepository(db, mutationIds, { tick++ }), clock = { tick++ }).push(DEVICE)
+            assertTrue("lost response surfaces as Failed: $first", first is PushPhaseOutcome.Failed)
+            assertEquals(1, ledger.pushRequests)
+            assertEquals("the server already applied all 50", 50, ledger.appliedCount.size)
+            assertTrue(ledger.appliedCount.values.all { it == 1 })
+            val afterLoss = db.outboxDao().getAllOrdered()
+            assertEquals("all rows survive the lost response", queued.map { it.mutationId }, afterLoss.map { it.mutationId })
+            assertTrue(afterLoss.all { it.attemptCount == 1 && it.state == OutboxState.PENDING })
+            db.close()
+
+            db = open()
+            val second = OutboxSyncer(db, api, OutboxRepository(db, mutationIds, { tick++ }), clock = { tick++ }).push(DEVICE)
+            assertEquals(PushPhaseOutcome.Drained, second)
+
+            assertTrue("outbox empty: ${db.outboxDao().getAllOrdered()}", db.outboxDao().getAllOrdered().isEmpty())
+            assertEquals(2, ledger.pushRequests)
+            assertEquals("replay = identical request bytes", ledger.requestBodies[0], ledger.requestBodies[1])
+            assertEquals(queued.map { it.mutationId }, ledger.sentIds[1])
+            assertEquals(queued.map { it.mutationId }.toSet(), ledger.appliedCount.keys)
+            assertTrue("applied exactly once", ledger.appliedCount.values.all { it == 1 })
+            assertEquals(queued.map { it.mutationId }.toSet(), ledger.skippedCount.keys)
+            assertTrue("skipped exactly once", ledger.skippedCount.values.all { it == 1 })
+            assertEquals(queued.map { it.mutationId }, ledger.applyOrder)
+
+            val wire = Json.parseToJsonElement(ledger.requestBodies[0]).jsonObject
+            assertPushRequestShape(wire)
+            assertEquals(DEVICE, wire["device_id"]!!.jsonPrimitive.content)
+            val serverSide = Model.seed()
+            ledger.applyOrder.forEach { id ->
+                val m = wire["mutations"]!!.jsonArray.map { it.jsonObject }.single { it["mutation_id"]!!.jsonPrimitive.content == id }
+                serverSide.applyWire(m)
+            }
+            assertEquals("server state == independently computed expectation", expected.describe(), serverSide.describe())
+            assertMirror(db, expected)
+
+            val seedRequest = seedPushRequest()
+            checkGolden("stocktake-seed-push-request.json", pretty(seedRequest))
+            checkGolden("stocktake-push-request.json", pretty(wire))
+            checkGolden("stocktake-expected-state.json", pretty(expected.toJson()))
+        }
+
+    private sealed interface Edit {
+        suspend fun perform(repo: EditRepository)
+
+        fun applyTo(model: Model)
+    }
+
+    private data class Adjust(val item: String, val delta: Long) : Edit {
+        override suspend fun perform(repo: EditRepository) {
+            repo.adjustStock(item, delta, reason = "stocktake").ok()
+        }
+
+        override fun applyTo(model: Model) {
+            model.items.getValue(item).quantity += delta
+        }
+    }
+
+    private data class Rename(val item: String, val name: String, val description: String) : Edit {
+        override suspend fun perform(repo: EditRepository) {
+            repo.editItem(item, name = name, description = description).ok()
+        }
+
+        override fun applyTo(model: Model) {
+            val target = model.items.getValue(item)
+            target.name = name
+            target.description = description
+        }
+    }
+
+    private data class Move(val item: String, val location: String) : Edit {
+        override suspend fun perform(repo: EditRepository) {
+            repo.moveItem(item, location).ok()
+        }
+
+        override fun applyTo(model: Model) {
+            model.items.getValue(item).location = location
+        }
+    }
+
+    private data class Attach(val item: String, val label: String) : Edit {
+        override suspend fun perform(repo: EditRepository) {
+            repo.attachLabel(item, label).ok()
+        }
+
+        override fun applyTo(model: Model) {
+            check(model.edges.add(item to label)) { "scenario attaches an existing edge" }
+        }
+    }
+
+    private data class Detach(val item: String, val label: String) : Edit {
+        override suspend fun perform(repo: EditRepository) {
+            repo.detachLabel(item, label).ok()
+        }
+
+        override fun applyTo(model: Model) {
+            check(model.edges.remove(item to label)) { "scenario detaches a missing edge" }
+        }
+    }
+
+    private fun scenario(): List<Edit> {
+        val deltas = listOf(4L, -3, 7, -2, 5, -1, 3, -4, 6, 2, -5, 8, 1, -6, 9)
+        val adjusts = deltas.mapIndexed { n, d -> Adjust(item(1 + n % 5), d) }
+        val renames = (6..17).map { Rename(item(it), "Item ${two(it)} (counted)", "recounted ${two(it)}") }
+        val moves = (18..27).map { Move(item(it), location(2 + it % 3)) }
+        val attaches = listOf(28 to 3, 28 to 4, 29 to 3, 29 to 4, 30 to 3, 30 to 4, 1 to 1, 2 to 1)
+            .map { (i, l) -> Attach(item(i), label(l)) }
+        val detaches = SEED_EDGES.map { (i, l) -> Detach(item(i), label(l)) }
+        val queues = listOf(adjusts, renames, moves, attaches, detaches).map { ArrayDeque(it) }
+        return buildList {
+            while (queues.any { it.isNotEmpty() }) queues.forEach { q -> q.removeFirstOrNull()?.let(::add) }
+        }
+    }
+
+    private class ItemModel(var name: String, var description: String, var location: String?, var quantity: Long)
+
+    private class Model(val items: MutableMap<String, ItemModel>, val edges: MutableSet<Pair<String, String>>) {
+        fun applyWire(m: JsonObject) {
+            val type = m["entity_type"]!!.jsonPrimitive.content
+            val entity = m["entity_id"]!!.jsonPrimitive.content
+            val op = m["op"]?.jsonPrimitive?.content ?: "upsert"
+            val f = m["fields"]!!.jsonObject
+            when (type) {
+                "item" -> items.getValue(entity).apply {
+                    f["name"]?.let { name = it.jsonPrimitive.content }
+                    f["description"]?.let { description = it.jsonPrimitive.content }
+                    f["location_id"]?.let { location = (it as? JsonPrimitive)?.takeIf { p -> p !is JsonNull }?.content }
+                }
+                "stock_adjustment" -> items.getValue(f["item_id"]!!.jsonPrimitive.content).quantity += f["delta"]!!.jsonPrimitive.longOrNull!!
+                "item_label" -> {
+                    val edge = f["item_id"]!!.jsonPrimitive.content to f["label_id"]!!.jsonPrimitive.content
+                    if (op == "delete") check(edges.remove(edge)) else check(edges.add(edge))
+                }
+                else -> error("unexpected entity_type $type")
+            }
+        }
+
+        fun describe(): String =
+            items.toSortedMap().entries.joinToString("\n") { (id, m) -> "$id|${m.name}|${m.description}|${m.location}|${m.quantity}" } +
+                "\n" + edges.sortedWith(compareBy({ it.first }, { it.second })).joinToString(",")
+
+        fun toJson(): JsonObject =
+            buildJsonObject {
+                put(
+                    "items",
+                    JsonArray(
+                        items.toSortedMap().map { (id, m) ->
+                            buildJsonObject {
+                                put("id", JsonPrimitive(id))
+                                put("name", JsonPrimitive(m.name))
+                                put("description", JsonPrimitive(m.description))
+                                put("location_id", m.location?.let(::JsonPrimitive) ?: JsonNull)
+                                put("quantity", JsonPrimitive(m.quantity))
+                            }
+                        },
+                    ),
+                )
+                put(
+                    "item_labels",
+                    JsonArray(
+                        edges.sortedWith(compareBy({ it.first }, { it.second })).map { (i, l) ->
+                            buildJsonObject {
+                                put("item_id", JsonPrimitive(i))
+                                put("label_id", JsonPrimitive(l))
+                            }
+                        },
+                    ),
+                )
+            }
+
+        companion object {
+            fun seed() = Model(
+                (1..ITEM_COUNT).associate { item(it) to ItemModel("Item ${two(it)}", "seed", location(1), SEED_QUANTITY) }.toMutableMap(),
+                SEED_EDGES.map { (i, l) -> item(i) to label(l) }.toMutableSet(),
+            )
+        }
+    }
+
+    private suspend fun seedMirror(db: HhoDatabase) {
+        (1..4).forEach { db.locationDao().upsert(LocationEntity(location(it), 1, "Location $it", null, 1, 1, 1)) }
+        (1..4).forEach { db.labelDao().upsert(LabelEntity(label(it), 1, "Label $it", "#00000$it", 1, 1, 1)) }
+        (1..ITEM_COUNT).forEach {
+            db.itemDao().upsert(
+                ItemEntity(item(it), 1, "Item ${two(it)}", "seed", location(1), SEED_QUANTITY, "S${two(it)}", 1, 1, SEED_VERSION),
+            )
+        }
+        SEED_EDGES.forEachIndexed { n, (i, l) -> db.itemLabelDao().upsert(ItemLabelEntity(edge(n + 1), 1, item(i), label(l))) }
+    }
+
+    private fun seedPushRequest(): JsonObject {
+        val muts = ArrayList<JsonObject>()
+
+        fun add(type: String, id: String, fields: Map<String, JsonElement>) {
+            muts += buildJsonObject {
+                put("mutation_id", JsonPrimitive(seedMutationId(muts.size + 1)))
+                put("entity_type", JsonPrimitive(type))
+                put("entity_id", JsonPrimitive(id))
+                put("base_version", JsonPrimitive(0))
+                put("fields", JsonObject(fields))
+            }
+        }
+        (1..4).forEach { add("location", location(it), mapOf("name" to JsonPrimitive("Location $it"))) }
+        (1..4).forEach { add("label", label(it), mapOf("name" to JsonPrimitive("Label $it"), "color" to JsonPrimitive("#00000$it"))) }
+        (1..ITEM_COUNT).forEach {
+            add(
+                "item",
+                item(it),
+                mapOf(
+                    "name" to JsonPrimitive("Item ${two(it)}"),
+                    "description" to JsonPrimitive("seed"),
+                    "location_id" to JsonPrimitive(location(1)),
+                    "quantity" to JsonPrimitive(SEED_QUANTITY),
+                ),
+            )
+        }
+        SEED_EDGES.forEachIndexed { n, (i, l) ->
+            add("item_label", edge(n + 1), mapOf("item_id" to JsonPrimitive(item(i)), "label_id" to JsonPrimitive(label(l))))
+        }
+        return buildJsonObject {
+            put("device_id", JsonPrimitive("stocktake-seed-device"))
+            put("mutations", JsonArray(muts))
+        }
+    }
+
+    private suspend fun assertMirror(db: HhoDatabase, expected: Model) {
+        val items = db.itemDao().observeAll().first().associateBy { it.id }
+        assertEquals(expected.items.keys, items.keys)
+        expected.items.forEach { (id, m) ->
+            val row = items.getValue(id)
+            assertEquals("name of $id", m.name, row.name)
+            assertEquals("description of $id", m.description, row.description)
+            assertEquals("location of $id", m.location, row.locationId)
+        }
+        val edges = (1..4).flatMap { l -> db.itemLabelDao().observeByLabelId(label(l)).first() }.map { it.itemId to it.labelId }
+        assertEquals("label edges", expected.edges, edges.toSet())
+        assertEquals("no duplicate edges", edges.size, edges.toSet().size)
+    }
+
+    private fun assertPushRequestShape(root: JsonObject) {
+        assertEquals(setOf("device_id", "mutations"), root.keys)
+        val closedSet = setOf("item", "stock_adjustment", "item_label")
+        for (m in root["mutations"]!!.jsonArray.map { it.jsonObject }) {
+            assertTrue(m.keys.containsAll(setOf("mutation_id", "entity_type", "entity_id", "base_version", "fields")))
+            assertTrue("no unknown keys: ${m.keys}", m.keys.all { it in setOf("mutation_id", "entity_type", "entity_id", "base_version", "fields", "op") })
+            assertTrue(m["base_version"]!!.jsonPrimitive.longOrNull != null)
+            assertTrue(m["op"]?.jsonPrimitive?.content in setOf(null, "upsert", "delete"))
+            val type = m["entity_type"]!!.jsonPrimitive.content
+            assertTrue(type in closedSet)
+            val f = m["fields"]!!.jsonObject
+            when (type) {
+                "item" -> {
+                    assertTrue("item never carries quantity (A177)", "quantity" !in f)
+                    assertTrue(f.keys.all { it in setOf("name", "description", "location_id") })
+                }
+                "stock_adjustment" -> assertTrue("item_id" in f && f["delta"]!!.jsonPrimitive.longOrNull != null)
+                "item_label" -> {
+                    assertEquals(setOf("item_id", "label_id"), f.keys)
+                    if (m["op"]?.jsonPrimitive?.content != "delete") assertEquals(0L, m["base_version"]!!.jsonPrimitive.longOrNull)
+                }
+            }
+        }
+    }
+
+    private fun checkGolden(name: String, actual: String) {
+        val file = File(GOLDEN_DIR, name)
+        if (UPDATE_GOLDEN) {
+            file.parentFile!!.mkdirs()
+            file.writeText(actual)
+            return
+        }
+        assertTrue("golden $file is missing; regenerate deliberately with HHO_UPDATE_GOLDEN=1", file.isFile)
+        assertEquals("golden $name differs from what the app now sends; if intended, regenerate with HHO_UPDATE_GOLDEN=1 and review", file.readText(), actual)
+    }
+
+    private fun pretty(e: JsonElement): String = PRETTY.encodeToString(JsonElement.serializer(), e) + "\n"
+
+    private fun open(): HhoDatabase = fileHhoDatabase(dbName).also { dbs += it }
+
+    private fun editRepo(db: HhoDatabase, onSync: () -> Unit = {}): EditRepository =
+        EditRepository(db, OutboxRepository(db, mutationIds, { tick++ }), entityIds, onSync)
+
+    private companion object {
+        const val DEVICE = "stocktake-device-1"
+        const val ID_EPOCH_MS = 1_780_000_000_000L
+        const val ITEM_COUNT = 30
+        const val SEED_QUANTITY = 10L
+        const val SEED_VERSION = 1L
+        val SEED_EDGES = listOf(28 to 1, 28 to 2, 29 to 1, 29 to 2, 30 to 1)
+        val GOLDEN_DIR = File("src/test/resources/golden")
+        val UPDATE_GOLDEN = System.getenv("HHO_UPDATE_GOLDEN") == "1" || System.getProperty("hho.updateGolden") == "true"
+        val PRETTY = Json { prettyPrint = true; prettyPrintIndent = "  " }
+
+        fun two(n: Int) = n.toString().padStart(2, '0')
+
+        fun uuid(kind: Int, n: Int) = "00000000-0000-7000-8000-${kind.toString().padStart(4, '0')}${n.toString().padStart(8, '0')}"
+
+        fun item(n: Int) = uuid(1, n)
+
+        fun location(n: Int) = uuid(2, n)
+
+        fun label(n: Int) = uuid(3, n)
+
+        fun edge(n: Int) = uuid(4, n)
+
+        fun seedMutationId(n: Int) = uuid(5, n)
+
+        fun <T> EditResult<T>.ok(): T =
+            (this as? EditResult.Success<T>)?.value ?: error("edit refused: $this")
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncEngineRunTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncEngineRunTest.kt
new file mode 100644
index 0000000..093770e
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncEngineRunTest.kt
@@ -0,0 +1,462 @@
+package dev.hho.android.data.sync
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.outbox.LocalMutation
+import dev.hho.android.data.outbox.OptimisticApplier
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.OutboxState
+import dev.hho.android.data.room.SyncRunStateEntity
+import dev.hho.android.data.room.SyncStateEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.async
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.delay
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonObject
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.RecordedRequest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+import java.util.concurrent.CopyOnWriteArrayList
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class SyncEngineRunTest {
+
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(20)
+
+    private val server = MockWebServer()
+    private lateinit var db: HhoDatabase
+    private lateinit var outbox: OutboxRepository
+
+    private val paths = CopyOnWriteArrayList<String>()
+    private val pullBodies = CopyOnWriteArrayList<String>()
+    private var pushResponder: (String) -> MockResponse = { ok("""{"applied":[],"skipped":[],"conflicts":[],"new_watermark":1}""") }
+    private var pullResponder: () -> MockResponse = { ok(page("", 5)) }
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        outbox = OutboxRepository(db)
+        server.dispatcher = object : Dispatcher() {
+            override fun dispatch(request: RecordedRequest): MockResponse {
+                val path = request.path.orEmpty()
+                paths += path
+                val body = request.body.readUtf8()
+                return if (path.endsWith("/sync/push")) {
+                    pushResponder(body)
+                } else {
+                    pullBodies += body
+                    pullResponder()
+                }
+            }
+        }
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+        server.shutdown()
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val file = File.createTempFile("hho-engine-run-test", ".preferences_pb").also { it.deleteOnExit() }
+        val dataStore = PreferenceDataStoreFactory.create(produceFile = { file })
+        runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() } }
+        val cv = ClientVersionInterceptor()
+        val provider = object : DeviceTokenProvider {
+            override suspend fun tokenFor(requestUrl: HttpUrl): String? = null
+
+            override suspend fun invalidate(requestUrl: HttpUrl, rejectedToken: String) = Unit
+        }
+        val http = NetworkModule.provideOkHttpClient(BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore)), AuthHeaderInterceptor(provider), cv)
+        return HhoApiClient(http, NetworkModule.provideProbeOkHttpClient(http, cv))
+    }
+
+    private fun ok(body: String) = MockResponse().setResponseCode(200).setHeader("Content-Type", "application/json").setBody(body)
+
+    private fun problem(status: Int, extra: String = "") = MockResponse().setResponseCode(status)
+        .setHeader("Content-Type", "application/problem+json")
+        .setBody("""{"type":"about:blank","title":"t","status":$status,"detail":"d"$extra}""")
+
+    private fun page(changes: String, next: Long) = """{"changes":[$changes],"tombstones":[],"next_watermark":$next,"has_more":false}"""
+
+    private fun itemChange(id: String, name: String, version: Long) =
+        """{"entity_type":"item","id":"$id","group_change_seq":2,"data":{"id":"$id","name":"$name","quantity":0,"created_at":1,"updated_at":1,"version":$version}}"""
+
+    private fun mutation(type: String, id: String, fields: String, base: Long) =
+        LocalMutation(type, id, "upsert", base, Json.parseToJsonElement(fields).jsonObject)
+
+    private fun conflictResponse(mutationId: String, id: String, field: String) =
+        ok("""{"applied":[],"skipped":[],"conflicts":[{"mutation_id":"$mutationId","entity_type":"item","entity_id":"$id","field_name":"$field"}],"new_watermark":1}""")
+
+    private suspend fun seedWatermark() = db.syncStateDao().upsert(SyncStateEntity(watermark = 5L, lastSyncedAt = 1L))
+
+    private suspend fun seedItem(id: String, version: Long = 1) =
+        db.itemDao().upsert(ItemEntity(id, 1, "old", null, null, 0, null, 1, 1, version))
+
+    private fun scripted(vararg outcomes: PushPhaseOutcome): suspend (String) -> PushPhaseOutcome {
+        val queue = ArrayDeque(outcomes.toList())
+        return { queue.removeFirst() }
+    }
+
+    private val failed = PushPhaseOutcome.Failed(ApiError.Unknown(RuntimeException("boom")))
+
+    @Test
+    fun pushRunsBeforePull_andBothHappen() = runBlocking {
+        seedWatermark()
+        seedItem("a")
+        val row = outbox.enqueue(mutation("item", "a", """{"name":"New"}""", 1))
+        pushResponder = { ok("""{"applied":[{"mutation_id":"${row.mutationId}","entity_type":"item","entity_id":"a","version":2}],"skipped":[],"conflicts":[],"new_watermark":9}""") }
+
+        val result = testSyncEngine(apiClient(), db, outbox).sync("d")
+
+        assertEquals(SyncRunOutcome.IncrementalPullRan, result.getOrNull())
+        assertEquals(listOf("/sync/push", "/sync/pull"), paths.map { it.substringAfterLast("/sync").let { s -> "/sync$s" } })
+        assertTrue(db.outboxDao().getAllOrdered().isEmpty())
+    }
+
+    @Test
+    fun failedPush_skipsPull_returnsFailure_keepsRowsQueued() = runBlocking {
+        seedWatermark()
+        outbox.enqueue(mutation("item", "a", """{"name":"New"}""", 1))
+        pushResponder = { problem(500) }
+        val hook = CountingHook()
+
+        val result = testSyncEngine(apiClient(), db, outbox, hooks = setOf(hook)).sync("d")
+
+        assertTrue(result.isFailure)
+        assertEquals(1, paths.size)
+        assertEquals(0, hook.calls)
+        assertEquals(OutboxState.PENDING, db.outboxDao().getAllOrdered().single().state)
+        assertNotNull(db.syncRunStateDao().get()?.lastError)
+    }
+
+    @Test
+    fun needsReconcile_forcesFullPull_evenWithWatermark() = runBlocking {
+        seedWatermark()
+        seedItem("a")
+        val row = outbox.enqueue(mutation("item", "a", """{"name":"Mine"}""", 1))
+        pushResponder = { conflictResponse(row.mutationId, "a", "name") }
+        pullResponder = { ok(page(itemChange("a", "Server", 3), 12)) }
+
+        val result = testSyncEngine(apiClient(), db, outbox).sync("d")
+
+        assertEquals(SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.ConflictReconcile), result.getOrNull())
+        assertTrue(pullBodies.single().contains("\"since\":0"))
+        assertEquals("Server", db.itemDao().getById("a")?.name)
+        assertFalse(db.syncRunStateDao().get()!!.reconcilePending)
+    }
+
+    @Test
+    fun reconcileDebt_survivesFailedRun_andForcesFullPullNextRun() = runBlocking {
+        seedWatermark()
+        val engine = testSyncEngine(apiClient(), db, outbox, push = scripted(failed.copy(reconcilePending = true), PushPhaseOutcome.Drained))
+
+        assertTrue(engine.sync("d").isFailure)
+        assertTrue(db.syncRunStateDao().get()!!.reconcilePending)
+        assertTrue(paths.isEmpty())
+
+        val second = engine.sync("d")
+
+        assertEquals(SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.ConflictReconcile), second.getOrNull())
+        assertTrue(pullBodies.single().contains("\"since\":0"))
+        assertFalse(db.syncRunStateDao().get()!!.reconcilePending)
+    }
+
+    @Test
+    fun reconcileDebt_survivesFailedReconcilePull() = runBlocking {
+        seedWatermark()
+        val engine = testSyncEngine(apiClient(), db, outbox, push = scripted(PushPhaseOutcome.NeedsReconcile, PushPhaseOutcome.Drained))
+        pullResponder = { problem(500) }
+
+        assertTrue(engine.sync("d").isFailure)
+        assertTrue(db.syncRunStateDao().get()!!.reconcilePending)
+
+        pullResponder = { ok(page("", 8)) }
+        assertEquals(
+            SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.ConflictReconcile),
+            engine.sync("d").getOrNull(),
+        )
+        assertFalse(db.syncRunStateDao().get()!!.reconcilePending)
+    }
+
+    @Test
+    fun blockedAuth_andUpgrade_skipPull_mapToOutcomes_andKeepDebt() = runBlocking {
+        seedWatermark()
+        val engine = testSyncEngine(
+            apiClient(), db, outbox,
+            push = scripted(
+                PushPhaseOutcome.Blocked(BlockedReason.AUTH, reconcilePending = true),
+                PushPhaseOutcome.Blocked(BlockedReason.UPGRADE_REQUIRED, "9.9.9"),
+            ),
+        )
+
+        assertEquals(SyncRunOutcome.AuthRequired, engine.sync("d").getOrNull())
+        assertTrue(db.syncRunStateDao().get()!!.reconcilePending)
+        assertEquals(SyncRunOutcome.UpgradeRequired("9.9.9"), engine.sync("d").getOrNull())
+        val state = db.syncRunStateDao().get()!!
+        assertTrue(state.reconcilePending)
+        assertTrue(state.lastError!!.contains("9.9.9"))
+        assertTrue(paths.isEmpty())
+    }
+
+    @Test
+    fun releaseHeld_afterPull_releasesFollowerOfSkippedAckedMutation() = runBlocking {
+        seedWatermark()
+        seedItem("a")
+        val first = outbox.enqueue(mutation("item", "a", """{"name":"first"}""", 1))
+        outbox.markInFlight(listOf(first.mutationId))
+        val follower = outbox.enqueue(mutation("item", "a", """{"name":"second"}""", 1))
+        assertEquals(OutboxState.HELD, follower.state)
+        outbox.resetInFlightToPending()
+        pushResponder = { ok("""{"applied":[],"skipped":[{"mutation_id":"${first.mutationId}"}],"conflicts":[],"new_watermark":1}""") }
+        pullResponder = { ok(page(itemChange("a", "first", 7), 9)) }
+
+        assertTrue(testSyncEngine(apiClient(), db, outbox).sync("d").isSuccess)
+
+        val left = db.outboxDao().getAllOrdered().single()
+        assertEquals(follower.mutationId, left.mutationId)
+        assertEquals(OutboxState.PENDING, left.state)
+        assertEquals(7L, left.baseVersion)
+    }
+
+    @Test
+    fun concurrentSyncCalls_neverOverlapPushes_secondWaitsThenRuns() = runBlocking {
+        var active = 0
+        var maxActive = 0
+        var pushes = 0
+        val gate = CompletableDeferred<Unit>()
+        val engine = testSyncEngine(apiClient(), db, outbox, push = {
+            pushes++
+            active++
+            maxActive = maxOf(maxActive, active)
+            gate.await()
+            active--
+            PushPhaseOutcome.Drained
+        })
+
+        val a = async { engine.sync("d") }
+        val b = async { engine.sync("d") }
+        while (pushes < 1) delay(10)
+        delay(300)
+        assertEquals("second call must wait while the first push is in flight", 1, pushes)
+        gate.complete(Unit)
+
+        assertTrue(a.await().isSuccess)
+        assertTrue(b.await().isSuccess)
+        assertEquals(2, pushes)
+        assertEquals(1, maxActive)
+    }
+
+    @Test
+    fun fu59_pendingCreateAnsweredAsConflict_leavesNoGhostRowAfterForcedFullPull() = runBlocking {
+        seedWatermark()
+        seedItem("keep")
+        val create = mutation("item", "ghost", """{"name":"Ghost"}""", 0)
+        val queued = outbox.enqueue(create)
+        OptimisticApplier.apply(db, create)
+        assertNotNull(db.itemDao().getById("ghost"))
+        pushResponder = { conflictResponse(queued.mutationId, "ghost", "_entity") }
+        pullResponder = { ok(page(itemChange("keep", "Server keep", 2), 20)) }
+
+        val result = testSyncEngine(apiClient(), db, outbox).sync("d")
+
+        assertEquals(SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.ConflictReconcile), result.getOrNull())
+        assertTrue(db.outboxDao().getAllOrdered().isEmpty())
+        assertNull("optimistic create must not linger", db.itemDao().getById("ghost"))
+        assertEquals("Server keep", db.itemDao().getById("keep")?.name)
+    }
+
+    @Test
+    fun hooks_runOnceAfterSuccessfulPull_andFailureNeverFailsTheSync() = runBlocking {
+        val failing = CountingHook(IllegalStateException("photo problem"))
+        val fine = CountingHook()
+
+        val result = testSyncEngine(apiClient(), db, outbox, hooks = setOf(failing, fine)).sync("d")
+
+        assertTrue(result.isSuccess)
+        assertEquals(1, failing.calls)
+        assertEquals(1, fine.calls)
+    }
+
+    @Test
+    fun hooks_notRunWhenPullFails() = runBlocking {
+        pullResponder = { problem(500) }
+        val hook = CountingHook()
+
+        assertTrue(testSyncEngine(apiClient(), db, outbox, hooks = setOf(hook)).sync("d").isFailure)
+
+        assertEquals(0, hook.calls)
+    }
+
+    @Test
+    fun successfulRun_clearsLastError() = runBlocking {
+        db.syncRunStateDao().upsert(SyncRunStateEntity(lastError = "old", lastErrorAt = 1))
+
+        assertTrue(testSyncEngine(apiClient(), db, outbox).sync("d").isSuccess)
+
+        assertNull(db.syncRunStateDao().get()!!.lastError)
+    }
+
+    @Test
+    fun lastPushAt_setOnlyWhenPushReachedServer_andRunRecordingKeepsCursorAndDebt() = runBlocking {
+        seedWatermark()
+        db.syncRunStateDao().upsert(SyncRunStateEntity(conflictCursor = "999"))
+
+        assertTrue(testSyncEngine(apiClient(), db, outbox, push = scripted(failed)).sync("d").isFailure)
+        assertNull(db.syncRunStateDao().get()!!.lastPushAt)
+        assertNotNull(db.syncRunStateDao().get()!!.lastError)
+
+        val blocked = PushPhaseOutcome.Blocked(BlockedReason.UPGRADE_REQUIRED, minimumVersion = "9.9.9")
+        assertTrue(testSyncEngine(apiClient(), db, outbox, push = scripted(blocked)).sync("d").isSuccess)
+        assertNull(db.syncRunStateDao().get()!!.lastPushAt)
+
+        assertTrue(testSyncEngine(apiClient(), db, outbox, push = scripted(PushPhaseOutcome.Drained)).sync("d").isSuccess)
+        val row = db.syncRunStateDao().get()!!
+        assertEquals(1_000L, row.lastPushAt)
+        assertEquals(1_000L, row.lastRunAt)
+        assertNull(row.lastError)
+        assertEquals("999", row.conflictCursor)
+    }
+
+    @Test
+    fun needsReconcile_stampsLastPushAt_evenWhenThePullFails() = runBlocking {
+        seedWatermark()
+        pullResponder = { problem(500) }
+
+        val result = testSyncEngine(apiClient(), db, outbox, push = scripted(PushPhaseOutcome.NeedsReconcile)).sync("d")
+
+        assertTrue(result.isFailure)
+        val row = db.syncRunStateDao().get()!!
+        assertEquals(1_000L, row.lastPushAt)
+        assertTrue(row.reconcilePending)
+        assertNotNull(row.lastError)
+    }
+
+    @Test
+    fun conflictLog_runsOnceAfterNormalIncrementalPull() = runBlocking {
+        seedWatermark()
+        var calls = 0
+        var pullsSeenAtCall = -1
+        val step: suspend () -> Unit = {
+            calls++
+            pullsSeenAtCall = paths.count { it.endsWith("/sync/pull") }
+        }
+
+        val result = testSyncEngine(apiClient(), db, outbox, conflictLogStep = step).sync("d")
+
+        assertEquals(SyncRunOutcome.IncrementalPullRan, result.getOrNull())
+        assertEquals(1, calls)
+        assertEquals("must run after the pull, not before", 1, pullsSeenAtCall)
+    }
+
+    @Test
+    fun conflictLog_runsAfterForcedReconcilePull_seeingTheReconciledMirror() = runBlocking {
+        seedWatermark()
+        seedItem("a")
+        val row = outbox.enqueue(mutation("item", "a", """{"name":"Mine"}""", 1))
+        pushResponder = { conflictResponse(row.mutationId, "a", "name") }
+        pullResponder = { ok(page(itemChange("a", "Server", 3), 12)) }
+        var calls = 0
+        var mirrorNameAtCall: String? = null
+        val step: suspend () -> Unit = {
+            calls++
+            mirrorNameAtCall = db.itemDao().getById("a")?.name
+        }
+
+        val result = testSyncEngine(apiClient(), db, outbox, conflictLogStep = step).sync("d")
+
+        assertEquals(SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.ConflictReconcile), result.getOrNull())
+        assertEquals(1, calls)
+        assertEquals("Server", mirrorNameAtCall)
+    }
+
+    @Test
+    fun conflictLog_runsAfterFirstSyncFullPull() = runBlocking {
+        var calls = 0
+
+        val result = testSyncEngine(apiClient(), db, outbox, conflictLogStep = { calls++ }).sync("d")
+
+        assertEquals(SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.FirstSync), result.getOrNull())
+        assertEquals(1, calls)
+    }
+
+    @Test
+    fun conflictLog_notRunWhenPullFailsOrPushFailsOrIsBlocked() = runBlocking {
+        seedWatermark()
+        var calls = 0
+        val step: suspend () -> Unit = { calls++ }
+
+        pullResponder = { problem(500) }
+        assertTrue(testSyncEngine(apiClient(), db, outbox, conflictLogStep = step).sync("d").isFailure)
+        assertTrue(testSyncEngine(apiClient(), db, outbox, push = scripted(failed), conflictLogStep = step).sync("d").isFailure)
+        val blocked = scripted(PushPhaseOutcome.Blocked(BlockedReason.AUTH), PushPhaseOutcome.Blocked(BlockedReason.UPGRADE_REQUIRED, "9.9.9"))
+        val engine = testSyncEngine(apiClient(), db, outbox, push = blocked, conflictLogStep = step)
+        assertEquals(SyncRunOutcome.AuthRequired, engine.sync("d").getOrNull())
+        assertEquals(SyncRunOutcome.UpgradeRequired("9.9.9"), engine.sync("d").getOrNull())
+
+        assertEquals(0, calls)
+    }
+
+    @Test
+    fun conflictLog_failureIsSwallowed_syncStillSucceeds_hooksRun_andLastErrorCleared() = runBlocking {
+        seedWatermark()
+        db.syncRunStateDao().upsert(SyncRunStateEntity(lastError = "old", lastErrorAt = 1))
+        val hook = CountingHook()
+
+        val result = testSyncEngine(
+            apiClient(), db, outbox, hooks = setOf(hook),
+            conflictLogStep = { throw ApiError.Unknown(RuntimeException("conflicts endpoint down")) },
+        ).sync("d")
+
+        assertEquals(SyncRunOutcome.IncrementalPullRan, result.getOrNull())
+        assertEquals(1, hook.calls)
+        assertNull(db.syncRunStateDao().get()!!.lastError)
+    }
+
+    @Test
+    fun conflictLog_realStep_serverErrorOnConflictsEndpointNeverFailsTheEntitySync() = runBlocking {
+        seedWatermark()
+        val savedDispatcher = server.dispatcher
+        server.dispatcher = object : Dispatcher() {
+            override fun dispatch(request: RecordedRequest): MockResponse =
+                if (request.path.orEmpty().contains("/sync/conflicts")) problem(500) else savedDispatcher.dispatch(request)
+        }
+
+        val result = testSyncEngine(apiClient(), db, outbox, withConflictLog = true).sync("d")
+
+        assertEquals(SyncRunOutcome.IncrementalPullRan, result.getOrNull())
+        assertTrue(db.conflictRecordDao().getAll().isEmpty())
+        assertNull(db.syncRunStateDao().get()!!.lastError)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncEngineTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncEngineTest.kt
new file mode 100644
index 0000000..ff0208b
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncEngineTest.kt
@@ -0,0 +1,229 @@
+package dev.hho.android.data.sync
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.SyncStateEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class SyncEngineTest {
+
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(15)
+
+    private val server = MockWebServer()
+    private lateinit var db: HhoDatabase
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+        server.shutdown()
+    }
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("sync-engine-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val dataStore = tempDataStore()
+        runBlocking {
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() }
+        }
+        val clientVersionInterceptor = ClientVersionInterceptor()
+        val authHeaderInterceptor =
+            AuthHeaderInterceptor(
+                object : DeviceTokenProvider {
+                    override suspend fun tokenFor(requestUrl: HttpUrl): String? = "device-token"
+
+                    override suspend fun invalidate(
+                        requestUrl: HttpUrl,
+                        rejectedToken: String,
+                    ) = Unit
+                },
+            )
+        val baseUrlInterceptor = BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore))
+        val httpClient =
+            NetworkModule.provideOkHttpClient(baseUrlInterceptor, authHeaderInterceptor, clientVersionInterceptor)
+        val probeHttpClient = NetworkModule.provideProbeOkHttpClient(httpClient, clientVersionInterceptor)
+        return HhoApiClient(httpClient, probeHttpClient)
+    }
+
+    private fun engine(): SyncEngine {
+        val client = apiClient()
+        return testSyncEngine(client, db)
+    }
+
+    private fun locationPageJson(
+        id: String,
+        nextWatermark: Long,
+        hasMore: Boolean,
+    ) = """
+        {
+          "changes": [
+            {"entity_type":"location","id":"$id","group_change_seq":1,
+             "data":{"id":"$id","name":"Loc $id","created_at":1,"updated_at":1,"version":1}}
+          ],
+          "tombstones": [],
+          "next_watermark": $nextWatermark,
+          "has_more": $hasMore
+        }
+        """.trimIndent()
+
+    private fun itemPageJson(
+        id: String,
+        nextWatermark: Long,
+        hasMore: Boolean,
+    ) = """
+        {
+          "changes": [
+            {"entity_type":"item","id":"$id","group_change_seq":2,
+             "data":{"id":"$id","name":"Item $id","created_at":1,"updated_at":1,"version":1}}
+          ],
+          "tombstones": [],
+          "next_watermark": $nextWatermark,
+          "has_more": $hasMore
+        }
+        """.trimIndent()
+
+    private fun cursorTooOldJson() = """{"cursor_too_old":true}"""
+
+    private fun seedPreviousSuccessfulPull(
+        itemId: String = "item-old",
+        watermark: Long? = 5L,
+    ) = runBlocking {
+        db.itemDao().upsert(
+            ItemEntity(
+                id = itemId,
+                groupChangeSeq = 1L,
+                name = "Old item",
+                description = null,
+                locationId = null,
+                quantity = 1L,
+                shortCode = null,
+                createdAt = 1L,
+                updatedAt = 1L,
+                version = 1L,
+            ),
+        )
+        if (watermark != null) {
+            db.syncStateDao().upsert(SyncStateEntity(watermark = watermark, lastSyncedAt = 1L))
+        }
+    }
+
+    @Test
+    fun `no persisted watermark routes through a full pull, and a stale local row absent from the server is gone afterward`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-stale", watermark = null)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-1", nextWatermark = 5, hasMore = false)))
+
+            val result = engine().sync(deviceId = "device-1")
+
+            assertTrue(result.isSuccess)
+            assertEquals(
+                SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.FirstSync),
+                result.getOrNull(),
+            )
+            assertEquals(1, server.requestCount)
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":0"))
+            assertNull(db.itemDao().getById("item-stale"))
+            assertEquals("Item item-1", db.itemDao().getById("item-1")?.name)
+            assertEquals(5L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `a persisted watermark routes through an incremental pull`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-old", watermark = 5L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-new", nextWatermark = 10, hasMore = false)))
+
+            val result = engine().sync(deviceId = "device-1")
+
+            assertTrue(result.isSuccess)
+            assertEquals(SyncRunOutcome.IncrementalPullRan, result.getOrNull())
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":5"))
+            assertEquals("Old item", db.itemDao().getById("item-old")?.name)
+            assertEquals("Item item-new", db.itemDao().getById("item-new")?.name)
+            assertEquals(10L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `cursor_too_old on the incremental path triggers an immediate full re-pull from since 0 in the same call, discarding rows the server has purged`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-old", watermark = 5L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(cursorTooOldJson()))
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-new", nextWatermark = 20, hasMore = false)))
+
+            val result = engine().sync(deviceId = "device-1")
+
+            assertTrue(result.isSuccess)
+            assertEquals(
+                SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.CursorTooOldRecovery),
+                result.getOrNull(),
+            )
+            assertEquals(2, server.requestCount)
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":5"))
+            assertTrue(server.takeRequest().body.readUtf8().contains("\"since\":0"))
+            assertNull(db.itemDao().getById("item-old"))
+            assertEquals("Item item-new", db.itemDao().getById("item-new")?.name)
+            assertEquals(20L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `cursor_too_old recovery, then a fetch failure mid the resulting full re-pull, leaves the previous mirror and watermark fully intact`() =
+        runTest {
+            seedPreviousSuccessfulPull(itemId = "item-old", watermark = 5L)
+            server.enqueue(MockResponse().setResponseCode(200).setBody(cursorTooOldJson()))
+            server.enqueue(MockResponse().setResponseCode(200).setBody(locationPageJson("loc-1", nextWatermark = 10, hasMore = true)))
+            server.enqueue(
+                MockResponse().setResponseCode(500).setBody(
+                    """{"type":"urn:hho:problem:internal","title":"Internal Server Error","status":500}""",
+                ),
+            )
+
+            val result = engine().sync(deviceId = "device-1")
+
+            assertTrue(result.isFailure)
+            assertTrue(result.exceptionOrNull() is ApiError.Server)
+            assertNull(db.locationDao().getById("loc-1"))
+            assertEquals("Old item", db.itemDao().getById("item-old")?.name)
+            assertEquals(5L, db.syncStateDao().get()?.watermark)
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncEngineTestSupport.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncEngineTestSupport.kt
new file mode 100644
index 0000000..657e706
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncEngineTestSupport.kt
@@ -0,0 +1,43 @@
+package dev.hho.android.data.sync
+
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.HhoDatabase
+
+internal class CountingHook(private val failure: Throwable? = null) : PostSyncHook {
+    var calls = 0
+
+    override suspend fun onSyncSucceeded() {
+        calls++
+        failure?.let { throw it }
+    }
+}
+
+internal fun testSyncEngine(
+    client: HhoApiClient,
+    db: HhoDatabase,
+    outbox: OutboxRepository = OutboxRepository(db),
+    hooks: Set<PostSyncHook> = emptySet(),
+    push: suspend (String) -> PushPhaseOutcome = OutboxSyncer(db, client, outbox)::push,
+    withConflictLog: Boolean = false,
+    conflictLogStep: (suspend () -> Unit)? = null,
+): SyncEngine {
+    val recorder = SyncRunRecorder(db.syncRunStateDao()) { 1_000L }
+    val realStep: (suspend () -> Unit)? =
+        if (withConflictLog) {
+            val log = ConflictLogSync(client, db.conflictRecordDao(), recorder)
+            suspend { log.sync().getOrThrow() }
+        } else {
+            null
+        }
+    return SyncEngine(
+        FullSyncCoordinator(client, db),
+        IncrementalSyncCoordinator(client, db),
+        db,
+        push,
+        outbox,
+        hooks,
+        recorder,
+        conflictLogStep ?: realStep,
+    )
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncRunRecorderTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncRunRecorderTest.kt
new file mode 100644
index 0000000..92eb03d
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncRunRecorderTest.kt
@@ -0,0 +1,103 @@
+package dev.hho.android.data.sync
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.SyncRunStateEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class SyncRunRecorderTest {
+    private lateinit var db: HhoDatabase
+    private var now = 100L
+    private lateinit var recorder: SyncRunRecorder
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        recorder = SyncRunRecorder(db.syncRunStateDao()) { now }
+    }
+
+    @After
+    fun tearDown() = db.close()
+
+    private suspend fun row() = db.syncRunStateDao().get()!!
+
+    @Test
+    fun firstWrite_createsTheRow() = runBlocking {
+        assertNull(db.syncRunStateDao().get())
+        recorder.recordSuccess()
+        assertEquals(100L, row().lastRunAt)
+        assertNull(row().lastError)
+    }
+
+    @Test
+    fun recordingARun_neverErasesReconcilePendingOrConflictCursor() = runBlocking {
+        db.syncRunStateDao().upsert(SyncRunStateEntity(reconcilePending = true, conflictCursor = "777", lastPushAt = 5))
+
+        recorder.recordSuccess()
+        assertTrue(row().reconcilePending)
+        assertEquals("777", row().conflictCursor)
+
+        now = 200
+        recorder.recordFailure("boom")
+        assertTrue(row().reconcilePending)
+        assertEquals("777", row().conflictCursor)
+        assertEquals(5L, row().lastPushAt)
+
+        recorder.recordPushReachedServer()
+        assertTrue(row().reconcilePending)
+        assertEquals("777", row().conflictCursor)
+    }
+
+    @Test
+    fun failure_recordsErrorAndOnlyRaisesDebt() = runBlocking {
+        now = 300
+        recorder.recordFailure(null, reconcileOwed = false)
+        assertEquals("sync failed", row().lastError)
+        assertEquals(300L, row().lastErrorAt)
+        assertFalse(row().reconcilePending)
+
+        recorder.recordFailure("x", reconcileOwed = true)
+        assertTrue(row().reconcilePending)
+        recorder.recordFailure("y", reconcileOwed = false)
+        assertTrue("a later failure must not clear the debt", row().reconcilePending)
+        assertEquals("y", row().lastError)
+    }
+
+    @Test
+    fun success_clearsTheErrorAndStampsTheRun() = runBlocking {
+        recorder.recordFailure("boom")
+        now = 400
+        recorder.recordSuccess()
+        assertNull(row().lastError)
+        assertNull(row().lastErrorAt)
+        assertEquals(400L, row().lastRunAt)
+    }
+
+    @Test
+    fun pushTimestamp_andDebtAndWatermark_areIndependent() = runBlocking {
+        recorder.setReconcilePending(true)
+        recorder.advanceConflictWatermark(42)
+        now = 500
+        recorder.recordPushReachedServer()
+        assertEquals(500L, row().lastPushAt)
+        assertNull(row().lastRunAt)
+        assertTrue(recorder.reconcileOwed())
+        assertEquals(42L, recorder.conflictWatermark())
+        recorder.setReconcilePending(false)
+        assertFalse(recorder.reconcileOwed())
+        assertNotNull(row().conflictCursor)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncSchedulerTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncSchedulerTest.kt
new file mode 100644
index 0000000..229309e
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncSchedulerTest.kt
@@ -0,0 +1,111 @@
+package dev.hho.android.data.sync
+
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.work.BackoffPolicy
+import androidx.work.Configuration
+import androidx.work.NetworkType
+import androidx.work.WorkInfo
+import androidx.work.WorkManager
+import androidx.work.testing.WorkManagerTestInitHelper
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.util.concurrent.Executors
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class SyncSchedulerTest {
+
+    private val context = ApplicationProvider.getApplicationContext<android.content.Context>()
+
+    @Before
+    fun setUp() {
+        val configuration =
+            Configuration.Builder()
+                .setExecutor(Executors.newSingleThreadExecutor())
+                .build()
+        WorkManagerTestInitHelper.initializeTestWorkManager(context, configuration)
+    }
+
+    private fun scheduler() = SyncScheduler(context)
+
+    @Test
+    fun `schedulePeriodic enqueues a unique periodic SyncWorker request constrained to CONNECTED and battery-not-low`() {
+        scheduler().schedulePeriodic()
+
+        val workInfos =
+            WorkManager.getInstance(context)
+                .getWorkInfosForUniqueWork(SyncScheduler.PERIODIC_WORK_NAME)
+                .get()
+
+        assertEquals(1, workInfos.size)
+        val workInfo = workInfos.single()
+        assertEquals(WorkInfo.State.ENQUEUED, workInfo.state)
+        assertTrue(workInfo.tags.contains(SyncWorker::class.java.name))
+        assertEquals(NetworkType.CONNECTED, workInfo.constraints.requiredNetworkType)
+        assertTrue(workInfo.constraints.requiresBatteryNotLow())
+    }
+
+    @Test
+    fun `schedulePeriodic called twice keeps the existing schedule (ExistingPeriodicWorkPolicy KEEP) rather than duplicating it`() {
+        val scheduler = scheduler()
+
+        scheduler.schedulePeriodic()
+        scheduler.schedulePeriodic()
+
+        val workInfos =
+            WorkManager.getInstance(context)
+                .getWorkInfosForUniqueWork(SyncScheduler.PERIODIC_WORK_NAME)
+                .get()
+                .filter { it.state != WorkInfo.State.CANCELLED }
+
+        assertEquals(1, workInfos.size)
+    }
+
+    @Test
+    fun `syncNow enqueues a unique one-off SyncWorker request constrained to CONNECTED only`() {
+        scheduler().syncNow()
+
+        val workInfos =
+            WorkManager.getInstance(context)
+                .getWorkInfosForUniqueWork(SyncScheduler.ON_DEMAND_WORK_NAME)
+                .get()
+
+        assertEquals(1, workInfos.size)
+        val workInfo = workInfos.single()
+        assertTrue(workInfo.tags.contains(SyncWorker::class.java.name))
+        assertEquals(NetworkType.CONNECTED, workInfo.constraints.requiredNetworkType)
+        assertFalse(workInfo.constraints.requiresBatteryNotLow())
+    }
+
+    @Test
+    fun `the periodic request uses exponential backoff with WorkManager's own minimum initial delay`() {
+        val request = SyncScheduler.buildPeriodicRequest()
+
+        assertEquals(BackoffPolicy.EXPONENTIAL, request.workSpec.backoffPolicy)
+        assertEquals(androidx.work.WorkRequest.MIN_BACKOFF_MILLIS, request.workSpec.backoffDelayDuration)
+    }
+
+    @Test
+    fun `the on-demand request uses exponential backoff with WorkManager's own minimum initial delay`() {
+        val request = SyncScheduler.buildOnDemandRequest()
+
+        assertEquals(BackoffPolicy.EXPONENTIAL, request.workSpec.backoffPolicy)
+        assertEquals(androidx.work.WorkRequest.MIN_BACKOFF_MILLIS, request.workSpec.backoffDelayDuration)
+    }
+
+    @Test
+    fun `the periodic request runs at WorkManager's own minimum periodic interval`() {
+        val request = SyncScheduler.buildPeriodicRequest()
+
+        assertEquals(
+            androidx.work.PeriodicWorkRequest.MIN_PERIODIC_INTERVAL_MILLIS,
+            request.workSpec.intervalDuration,
+        )
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncStatusRepositoryTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncStatusRepositoryTest.kt
new file mode 100644
index 0000000..d20376d
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncStatusRepositoryTest.kt
@@ -0,0 +1,107 @@
+package dev.hho.android.data.sync
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.OutboxMutationEntity
+import dev.hho.android.data.room.OutboxState
+import dev.hho.android.data.room.PhotoQueueEntryEntity
+import dev.hho.android.data.room.PhotoState
+import dev.hho.android.data.room.SyncRunStateEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class SyncStatusRepositoryTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var repo: SyncStatusRepository
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+        val photos =
+            object : PhotoQueueStatus {
+                override fun observePendingCount(): Flow<Int> =
+                    db.photoQueueDao().observeCount(listOf(PhotoState.QUEUED, PhotoState.UPLOADING, PhotoState.WAITING_PARENT))
+
+                override fun observeFailedCount(): Flow<Int> = db.photoQueueDao().observeCount(listOf(PhotoState.FAILED))
+            }
+        repo = SyncStatusRepository(db.outboxDao(), photos, db.syncRunStateDao())
+    }
+
+    @After
+    fun tearDown() = db.close()
+
+    private suspend fun await(predicate: (SyncStatus) -> Boolean): SyncStatus = withTimeout(10_000) { repo.observe().first(predicate) }
+
+    private suspend fun outbox(id: String, state: String) =
+        db.outboxDao().insert(
+            OutboxMutationEntity(
+                mutationId = id, entityType = "item", entityId = id, op = "upsert", baseVersion = 1,
+                fieldsJson = "{}", state = state, createdAt = 1,
+            ),
+        )
+
+    private suspend fun photo(id: String, state: String) =
+        db.photoQueueDao().insert(
+            PhotoQueueEntryEntity(id, "i", "/x/$id", "h", 1, "image", state, createdAt = 1),
+        )
+
+    @Test
+    fun emptyDatabase_isAllZeroAndNeverSynced() = runBlocking {
+        val s = await { true }
+        assertEquals(SyncStatus(), s)
+        assertFalse(s.hasProblem)
+    }
+
+    @Test
+    fun countsFollowRowChanges() = runBlocking {
+        outbox("p", OutboxState.PENDING)
+        outbox("f", OutboxState.IN_FLIGHT)
+        outbox("h", OutboxState.HELD)
+        outbox("bad", OutboxState.FAILED)
+        photo("q", PhotoState.QUEUED)
+        photo("w", PhotoState.WAITING_PARENT)
+        photo("bad", PhotoState.FAILED)
+
+        val s = await { it.pendingCount == 3 && it.photoQueueDepth == 2 }
+        assertEquals(1, s.failedOutboxCount)
+        assertEquals(1, s.failedPhotoCount)
+        assertEquals(2, s.failedCount)
+        assertTrue(s.hasProblem)
+
+        db.outboxDao().deleteBySeq(db.outboxDao().getAllOrdered().first { it.mutationId == "p" }.seq)
+        db.photoQueueDao().deleteById("bad")
+        val after = await { it.pendingCount == 2 && it.failedPhotoCount == 0 }
+        assertEquals(1, after.failedCount)
+    }
+
+    @Test
+    fun runState_flowsThrough_andErrorHidesLastSyncedAt() = runBlocking {
+        db.syncRunStateDao().upsert(SyncRunStateEntity(lastRunAt = 50, lastPushAt = 40))
+        val ok = await { it.lastSyncedAt != null }
+        assertEquals(50L, ok.lastSyncedAt)
+        assertEquals(40L, ok.lastPushAt)
+        assertNull(ok.lastError)
+        assertFalse(ok.hasProblem)
+
+        SyncRunRecorder(db.syncRunStateDao()) { 60 }.recordFailure("Not authenticated")
+        val bad = await { it.lastError != null }
+        assertNull(bad.lastSyncedAt)
+        assertEquals("Not authenticated", bad.lastError)
+        assertEquals(40L, bad.lastPushAt)
+        assertTrue(bad.hasProblem)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncWorkerTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncWorkerTest.kt
new file mode 100644
index 0000000..642fb6c
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/data/sync/SyncWorkerTest.kt
@@ -0,0 +1,325 @@
+package dev.hho.android.data.sync
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.work.ListenableWorker
+import androidx.work.WorkerFactory
+import androidx.work.WorkerParameters
+import androidx.work.testing.TestListenableWorkerBuilder
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceIdProvider
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.SyncStateEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import dev.hho.android.domain.AuthRepository
+import dev.hho.android.domain.AuthState
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class SyncWorkerTest {
+
+    @get:Rule
+    val timeout: Timeout = Timeout.seconds(15)
+
+    private val server = MockWebServer()
+    private lateinit var db: HhoDatabase
+    private val context = ApplicationProvider.getApplicationContext<Context>()
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+        server.shutdown()
+    }
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("sync-worker-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    private fun apiClient(): HhoApiClient {
+        val dataStore = tempDataStore()
+        runBlocking {
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() }
+        }
+        val clientVersionInterceptor = ClientVersionInterceptor()
+        val authHeaderInterceptor =
+            AuthHeaderInterceptor(
+                object : DeviceTokenProvider {
+                    override suspend fun tokenFor(requestUrl: HttpUrl): String? = "device-token"
+
+                    override suspend fun invalidate(
+                        requestUrl: HttpUrl,
+                        rejectedToken: String,
+                    ) = Unit
+                },
+            )
+        val baseUrlInterceptor = BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore))
+        val httpClient =
+            NetworkModule.provideOkHttpClient(baseUrlInterceptor, authHeaderInterceptor, clientVersionInterceptor)
+        val probeHttpClient = NetworkModule.provideProbeOkHttpClient(httpClient, clientVersionInterceptor)
+        return HhoApiClient(httpClient, probeHttpClient)
+    }
+
+    private fun realSyncEngine(): SyncEngine {
+        val client = apiClient()
+        return testSyncEngine(client, db)
+    }
+
+    private class FakeAuthRepository(initial: AuthState) : AuthRepository {
+        private val state = MutableStateFlow(initial)
+        override val authState: Flow<AuthState> = state
+
+        override suspend fun login(
+            username: String,
+            password: String,
+        ): Result<Unit> = error("SyncWorkerTest: login() is not exercised by SyncWorker")
+
+        override suspend fun logout() = error("SyncWorkerTest: logout() is not exercised by SyncWorker")
+    }
+
+    private class FakeDeviceIdProvider(private val id: String) : DeviceIdProvider {
+        var callCount = 0
+            private set
+
+        override suspend fun deviceId(): String {
+            callCount++
+            return id
+        }
+    }
+
+    private fun buildWorker(
+        syncEngine: SyncEngine,
+        deviceIdProvider: DeviceIdProvider,
+        authRepository: AuthRepository,
+    ): SyncWorker =
+        TestListenableWorkerBuilder<SyncWorker>(context)
+            .setWorkerFactory(
+                object : WorkerFactory() {
+                    override fun createWorker(
+                        appContext: Context,
+                        workerClassName: String,
+                        workerParameters: WorkerParameters,
+                    ): ListenableWorker =
+                        SyncWorker(appContext, workerParameters, syncEngine, deviceIdProvider, authRepository, SyncRunRecorder(db.syncRunStateDao()))
+                },
+            )
+            .build()
+
+    private fun itemPageJson(
+        id: String,
+        nextWatermark: Long,
+        hasMore: Boolean,
+    ) = """
+        {
+          "changes": [
+            {"entity_type":"item","id":"$id","group_change_seq":1,
+             "data":{"id":"$id","name":"Item $id","created_at":1,"updated_at":1,"version":1}}
+          ],
+          "tombstones": [],
+          "next_watermark": $nextWatermark,
+          "has_more": $hasMore
+        }
+        """.trimIndent()
+
+    private fun cursorTooOldJson() = """{"cursor_too_old":true}"""
+
+    @Test
+    fun `logged out - no-op success with no network call and no device id lookup`() =
+        runTest {
+            val deviceIdProvider = FakeDeviceIdProvider("device-unused")
+            val worker = buildWorker(realSyncEngine(), deviceIdProvider, FakeAuthRepository(AuthState.LoggedOut))
+
+            val result = worker.doWork()
+
+            assertEquals(ListenableWorker.Result.success(), result)
+            assertEquals(0, server.requestCount)
+            assertEquals(0, deviceIdProvider.callCount)
+        }
+
+    @Test
+    fun `logged in - delegates to the real SyncEngine (device id forwarded, mirror actually updated), returns success`() =
+        runTest {
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-1", nextWatermark = 5, hasMore = false)))
+            val worker =
+                buildWorker(realSyncEngine(), FakeDeviceIdProvider("device-xyz"), FakeAuthRepository(AuthState.LoggedIn))
+
+            val result = worker.doWork()
+
+            assertEquals(ListenableWorker.Result.success(), result)
+            assertEquals(1, server.requestCount)
+            assertEquals("Item item-1", db.itemDao().getById("item-1")?.name)
+            assertEquals(5L, db.syncStateDao().get()?.watermark)
+        }
+
+    @Test
+    fun `logged in - the resolved device id is sent as the sync request's device_id`() =
+        runTest {
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-1", nextWatermark = 5, hasMore = false)))
+            val worker =
+                buildWorker(realSyncEngine(), FakeDeviceIdProvider("device-xyz"), FakeAuthRepository(AuthState.LoggedIn))
+
+            worker.doWork()
+
+            val body = server.takeRequest().body.readUtf8()
+            assertTrue(body.contains("\"device_id\":\"device-xyz\""))
+        }
+
+    @Test
+    fun `cursor_too_old triggers SyncEngine's internal full re-pull and still returns success, never retry`() =
+        runTest {
+            runBlocking {
+                db.itemDao().upsert(
+                    ItemEntity(
+                        id = "item-old",
+                        groupChangeSeq = 1L,
+                        name = "Old item",
+                        description = null,
+                        locationId = null,
+                        quantity = 1L,
+                        shortCode = null,
+                        createdAt = 1L,
+                        updatedAt = 1L,
+                        version = 1L,
+                    ),
+                )
+                db.syncStateDao().upsert(SyncStateEntity(watermark = 5L, lastSyncedAt = 1L))
+            }
+            server.enqueue(MockResponse().setResponseCode(200).setBody(cursorTooOldJson()))
+            server.enqueue(MockResponse().setResponseCode(200).setBody(itemPageJson("item-new", nextWatermark = 20, hasMore = false)))
+            val worker =
+                buildWorker(realSyncEngine(), FakeDeviceIdProvider("device-xyz"), FakeAuthRepository(AuthState.LoggedIn))
+
+            val result = worker.doWork()
+
+            assertEquals(ListenableWorker.Result.success(), result)
+            assertEquals(2, server.requestCount)
+            assertNull(db.itemDao().getById("item-old"))
+            assertEquals("Item item-new", db.itemDao().getById("item-new")?.name)
+        }
+
+    @Test
+    fun `a server failure returns retry, not failure or success`() =
+        runTest {
+            server.enqueue(
+                MockResponse().setResponseCode(500).setBody(
+                    """{"type":"urn:hho:problem:internal","title":"Internal Server Error","status":500}""",
+                ),
+            )
+            val worker =
+                buildWorker(realSyncEngine(), FakeDeviceIdProvider("device-xyz"), FakeAuthRepository(AuthState.LoggedIn))
+
+            val result = worker.doWork()
+
+            assertEquals(ListenableWorker.Result.retry(), result)
+        }
+
+    private suspend fun queueOneEdit() =
+        dev.hho.android.data.outbox.OutboxRepository(db).enqueue(
+            dev.hho.android.data.outbox.LocalMutation(
+                "item", "a", "upsert", 1,
+                kotlinx.serialization.json.buildJsonObject {
+                    put("name", kotlinx.serialization.json.JsonPrimitive("New"))
+                },
+            ),
+        )
+
+    private fun worker() =
+        buildWorker(realSyncEngine(), FakeDeviceIdProvider("device-xyz"), FakeAuthRepository(AuthState.LoggedIn))
+
+    @Test
+    fun `a failed push (5xx) returns retry and never pulls`() =
+        runTest {
+            queueOneEdit()
+            server.enqueue(MockResponse().setResponseCode(500).setBody("""{"type":"about:blank","title":"t","status":500}"""))
+
+            assertEquals(ListenableWorker.Result.retry(), worker().doWork())
+            assertEquals(1, server.requestCount)
+        }
+
+    @Test
+    fun `a 401 on push is success (no retry spin), rows stay queued, nothing pulled`() =
+        runTest {
+            queueOneEdit()
+            server.enqueue(MockResponse().setResponseCode(401).setBody("""{"type":"about:blank","title":"t","status":401}"""))
+
+            assertEquals(ListenableWorker.Result.success(), worker().doWork())
+            assertEquals(1, server.requestCount)
+            assertEquals(1, db.outboxDao().getAllOrdered().size)
+        }
+
+    @Test
+    fun `a 426 on push is success (no retry spin) and the minimum version is recorded`() =
+        runTest {
+            queueOneEdit()
+            server.enqueue(
+                MockResponse().setResponseCode(426).setHeader("Content-Type", "application/problem+json")
+                    .setBody("""{"type":"about:blank","title":"t","status":426,"detail":"old","minimum_version":"9.9.9"}"""),
+            )
+
+            assertEquals(ListenableWorker.Result.success(), worker().doWork())
+            assertEquals(1, server.requestCount)
+            assertTrue(db.syncRunStateDao().get()!!.lastError!!.contains("9.9.9"))
+        }
+
+    @Test
+    fun `an unexpected crash inside the engine is recorded and retried`() =
+        runTest {
+            val crashing = testSyncEngine(apiClient(), db, push = { throw IllegalStateException("kaput") })
+            val worker =
+                buildWorker(crashing, FakeDeviceIdProvider("device-xyz"), FakeAuthRepository(AuthState.LoggedIn))
+
+            assertEquals(ListenableWorker.Result.retry(), worker.doWork())
+            assertEquals("IllegalStateException", db.syncRunStateDao().get()!!.lastError)
+        }
+
+    @Test
+    fun `a clean run leaves last_run_at set and no error`() =
+        runTest {
+            server.enqueue(MockResponse().setResponseCode(200).setHeader("Content-Type", "application/json")
+                .setBody(itemPageJson("a", 3, false)))
+            val worker =
+                buildWorker(realSyncEngine(), FakeDeviceIdProvider("device-xyz"), FakeAuthRepository(AuthState.LoggedIn))
+
+            assertEquals(ListenableWorker.Result.success(), worker.doWork())
+            val row = db.syncRunStateDao().get()!!
+            assertEquals(1_000L, row.lastRunAt)
+            assertEquals(null, row.lastError)
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/domain/EditRepositoryTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/domain/EditRepositoryTest.kt
new file mode 100644
index 0000000..c975bf0
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/domain/EditRepositoryTest.kt
@@ -0,0 +1,301 @@
+package dev.hho.android.domain
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.outbox.LocalMutation
+import dev.hho.android.data.outbox.OutboxOverlay
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemLabelEntity
+import dev.hho.android.data.room.LabelEntity
+import dev.hho.android.data.room.LocationEntity
+import dev.hho.android.data.room.OutboxMutationEntity
+import dev.hho.android.data.room.PurchasedFromBlockEntity
+import dev.hho.android.data.room.deleteHhoDatabaseFile
+import dev.hho.android.data.room.fileHhoDatabase
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
+import kotlinx.serialization.json.JsonPrimitive
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.time.LocalDate
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class EditRepositoryTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var repo: EditRepository
+    private val syncCalls = mutableListOf<Pair<Boolean, Int>>()
+    private var syncThrows = false
+
+    private fun repoFor(database: HhoDatabase, onSync: suspend () -> Unit = {}): EditRepository {
+        val ids = UuidV7Generator()
+        return EditRepository(database, OutboxRepository(database, ids), ids) {
+            syncCalls += database.openHelper.writableDatabase.inTransaction() to
+                database.openHelper.readableDatabase.query("SELECT COUNT(*) FROM outbox_mutation").use { it.moveToFirst(); it.getInt(0) }
+            if (syncThrows) error("scheduler down")
+        }
+    }
+
+    @Before
+    fun setUp() = kotlinx.coroutines.runBlocking {
+        db = inMemoryHhoDatabase()
+        repo = repoFor(db)
+        seed(db)
+    }
+
+    @After
+    fun tearDown() = db.close()
+
+    private suspend fun seed(d: HhoDatabase) {
+        d.itemDao().upsert(ItemEntity("i1", 5, "Drill", "old", null, 10, "AB12", 1, 1, 4))
+        d.locationDao().upsert(LocationEntity("loc1", 1, "Garage", null, 1, 1, 1))
+        d.labelDao().upsert(LabelEntity("lb1", 1, "Tools", "#fff", 1, 1, 1))
+    }
+
+    private suspend fun rows(d: HhoDatabase = db) = d.outboxDao().getAllOrdered()
+
+    private fun OutboxMutationEntity.mutation() = LocalMutation.from(this)
+
+    private fun <T> EditResult<T>.ok(): T = (this as EditResult.Success<T>).value
+
+    private fun <T> EditResult<T>.err(): EditError = (this as EditResult.Failure).error
+
+    @Test
+    fun createItem_writesMirrorAndOutbox_baseZero_uuidV7() = kotlinx.coroutines.test.runTest {
+        val id = repo.createItem("  Saw ", "hand saw", "loc1").ok()
+        assertEquals('7', id[14])
+        val item = db.itemDao().getById(id)!!
+        assertEquals("Saw", item.name)
+        assertEquals("loc1", item.locationId)
+        val m = rows().single().mutation()
+        assertEquals(LocalMutation("item", id, "upsert", 0, m.fields), m)
+        assertEquals(setOf("name", "description", "location_id"), m.fields.keys)
+        assertEquals(1, syncCalls.size)
+    }
+
+    @Test
+    fun editItem_usesMirrorVersionAsBase_neverSendsQuantity() = runTest {
+        repo.editItem("i1", name = "Drill 2", description = "new").ok()
+        assertEquals("Drill 2", db.itemDao().getById("i1")!!.name)
+        val m = rows().single().mutation()
+        assertEquals(4L, m.baseVersion)
+        assertEquals(setOf("name", "description"), m.fields.keys)
+        assertEquals(10L, db.itemDao().getById("i1")!!.quantity)
+    }
+
+    @Test
+    fun moveItem_setsAndClearsLocation() = runTest {
+        repo.moveItem("i1", "loc1").ok()
+        assertEquals("loc1", db.itemDao().getById("i1")!!.locationId)
+        repo.moveItem("i1", null).ok()
+        assertNull(db.itemDao().getById("i1")!!.locationId)
+        assertEquals(2, syncCalls.size)
+        assertEquals(kotlinx.serialization.json.JsonNull, rows().single().mutation().fields["location_id"])
+    }
+
+    @Test
+    fun adjustStock_derivesQuantity_andNeverEmitsItemQuantity() = runTest {
+        val id = repo.adjustStock("i1", -3, reason = "used", note = "n").ok()
+        assertEquals(10L, db.itemDao().getById("i1")!!.quantity)
+        assertEquals(7L, OutboxOverlay.derivedQuantity(db, "i1"))
+        val m = rows().single().mutation()
+        assertEquals("stock_adjustment", m.entityType)
+        assertEquals(id, m.entityId)
+        assertFalse("quantity" in m.fields)
+        assertEquals(JsonPrimitive(-3L), m.fields["delta"])
+        assertEquals(setOf("item_id", "delta", "reason", "note"), m.fields.keys)
+        assertEquals(-3L, db.stockAdjustmentDao().observeByItemId("i1").first().single().delta)
+    }
+
+    @Test
+    fun attachAndDetachLabel() = runTest {
+        val edge = repo.attachLabel("i1", "lb1").ok()
+        assertEquals(listOf(ItemLabelEntity(edge, 0, "i1", "lb1")), db.itemLabelDao().observeByItemId("i1").first())
+        assertEquals(edge, repo.attachLabel("i1", "lb1").ok())
+        assertEquals(1, rows().size)
+        assertEquals(1, syncCalls.size)
+
+        repo.detachLabel("i1", "lb1").ok()
+        assertTrue(db.itemLabelDao().observeByItemId("i1").first().isEmpty())
+        val del = rows().last().mutation()
+        assertEquals("delete", del.op)
+        assertEquals(edge, del.entityId)
+        assertEquals("delete addresses the edge by item_id/label_id (openapi SyncMutation.fields)", setOf("item_id", "label_id"), del.fields.keys)
+        assertEquals(2, syncCalls.size)
+        assertTrue(repo.detachLabel("i1", "lb1").err() is EditError.NotFound)
+    }
+
+    @Test
+    fun addIdentification_writesBoth() = runTest {
+        val id = repo.addIdentification("i1", "serial", " SN-1 ").ok()
+        assertEquals("SN-1", db.itemIdentificationDao().observeByItemId("i1").first().single().value)
+        val m = rows().single().mutation()
+        assertEquals(id, m.entityId)
+        assertEquals(0L, m.baseVersion)
+        assertEquals(setOf("item_id", "kind", "value"), m.fields.keys)
+    }
+
+    @Test
+    fun stampPurchase_createsThenUpdatesWithBlockVersion() = runTest {
+        val id = repo.stampPurchase("i1", vendor = "Acme", purchasedOn = LocalDate.of(2026, 1, 2), purchasePriceMinor = 1999).ok()
+        assertEquals(0L, rows().single().mutation().baseVersion)
+        val block = db.purchasedFromBlockDao().getByItemId("i1")!!
+        assertEquals(LocalDate.of(2026, 1, 2), block.purchasedOn)
+
+        db.outboxDao().getAllOrdered().forEach { db.outboxDao().deleteBySeq(it.seq) }
+        db.purchasedFromBlockDao().upsert(block.copy(version = 6))
+        assertEquals(id, repo.stampPurchase("i1", notes = "gift").ok())
+        val m = rows().single().mutation()
+        assertEquals(6L, m.baseVersion)
+        assertEquals(setOf("item_id", "notes"), m.fields.keys)
+        assertEquals("Acme", db.purchasedFromBlockDao().getByItemId("i1")!!.vendor)
+        assertEquals("gift", db.purchasedFromBlockDao().getByItemId("i1")!!.notes)
+    }
+
+    @Test
+    fun validation_failsBeforeAnyWrite_noSync() = runTest {
+        val before = db.itemDao().getById("i1")
+        assertTrue(repo.createItem("  ").err() is EditError.Invalid)
+        assertTrue(repo.createItem("x", locationId = "nope").err() is EditError.NotFound)
+        assertTrue(repo.editItem("i1", name = " ").err() is EditError.Invalid)
+        assertTrue(repo.editItem("i1").err() is EditError.Invalid)
+        assertTrue(repo.editItem("ghost", name = "x").err() is EditError.NotFound)
+        assertTrue(repo.moveItem("i1", "nope").err() is EditError.NotFound)
+        assertTrue(repo.adjustStock("i1", 0).err() is EditError.Invalid)
+        assertTrue(repo.adjustStock("ghost", 1).err() is EditError.NotFound)
+        assertTrue(repo.attachLabel("i1", "nope").err() is EditError.NotFound)
+        assertTrue(repo.attachLabel("ghost", "lb1").err() is EditError.NotFound)
+        assertTrue(repo.addIdentification("i1", "bogus", "v").err() is EditError.Invalid)
+        assertTrue(repo.addIdentification("i1", "serial", " ").err() is EditError.Invalid)
+        assertTrue(repo.stampPurchase("i1").err() is EditError.Invalid)
+        assertTrue(repo.stampPurchase("ghost", vendor = "v").err() is EditError.NotFound)
+        assertTrue(rows().isEmpty())
+        assertEquals(before, db.itemDao().getById("i1"))
+        assertEquals(1, db.itemDao().observeAll().first().size)
+        assertTrue(syncCalls.isEmpty())
+    }
+
+    @Test
+    fun failingEnqueue_rollsBackMirror_everyOperation() = runTest {
+        db.openHelper.writableDatabase.execSQL(
+            "CREATE TRIGGER fail_enqueue BEFORE INSERT ON outbox_mutation BEGIN SELECT RAISE(ABORT, 'boom'); END",
+        )
+        val results = listOf(
+            repo.createItem("Saw"),
+            repo.editItem("i1", name = "Changed"),
+            repo.moveItem("i1", "loc1"),
+            repo.adjustStock("i1", 2),
+            repo.attachLabel("i1", "lb1"),
+            repo.addIdentification("i1", "serial", "S"),
+            repo.stampPurchase("i1", vendor = "V"),
+        )
+        results.forEach { assertTrue(it.err() is EditError.StorageFailed) }
+        assertEquals(listOf(ItemEntity("i1", 5, "Drill", "old", null, 10, "AB12", 1, 1, 4)), db.itemDao().observeAll().first())
+        assertTrue(db.stockAdjustmentDao().observeByItemId("i1").first().isEmpty())
+        assertTrue(db.itemLabelDao().observeByItemId("i1").first().isEmpty())
+        assertTrue(db.itemIdentificationDao().observeByItemId("i1").first().isEmpty())
+        assertNull(db.purchasedFromBlockDao().getByItemId("i1"))
+        assertTrue(rows().isEmpty())
+        assertTrue(syncCalls.isEmpty())
+    }
+
+    @Test
+    fun observersSeeOptimisticChange() = runTest {
+        val seenInitial = CompletableDeferred<Unit>()
+        val renamed = withContext(Dispatchers.Default) {
+            val watcher = async {
+                db.itemDao().observeById("i1").onEach { seenInitial.complete(Unit) }.first { it?.name == "Renamed" }
+            }
+            withTimeout(5_000) { seenInitial.await() }
+            repo.editItem("i1", name = "Renamed").ok()
+            withTimeout(5_000) { watcher.await() }
+        }
+        assertEquals("Renamed", renamed!!.name)
+    }
+
+    @Test
+    fun syncNow_calledOnceAfterCommit_outsideTransaction() = runTest {
+        repo.adjustStock("i1", 1).ok()
+        assertEquals(listOf(false to 1), syncCalls)
+    }
+
+    @Test
+    fun schedulerFailure_doesNotFailTheCommittedEdit() = runTest {
+        syncThrows = true
+        repo.editItem("i1", name = "Kept").ok()
+        assertEquals("Kept", db.itemDao().getById("i1")!!.name)
+        assertEquals(1, rows().size)
+    }
+
+    @Test
+    fun killBetweenCommitAndSync_losesNothing() = runTest {
+        val name = "edit-repo-kill"
+        deleteHhoDatabaseFile(name)
+        var file = fileHhoDatabase(name)
+        try {
+            seed(file)
+            syncThrows = true
+            val killed = repoFor(file)
+            val adjId = killed.adjustStock("i1", 4).ok()
+            val newId = killed.createItem("Persisted").ok()
+            file.close()
+
+            file = fileHhoDatabase(name)
+            assertEquals(listOf("stock_adjustment", "item"), rows(file).map { it.entityType })
+            assertNotNull(file.stockAdjustmentDao().observeByItemId("i1").first().firstOrNull { it.id == adjId })
+            assertEquals("Persisted", file.itemDao().getById(newId)!!.name)
+            assertEquals(14L, OutboxOverlay.derivedQuantity(file, "i1"))
+        } finally {
+            file.close()
+            deleteHhoDatabaseFile(name)
+        }
+    }
+
+    @Test
+    fun batch_commitsAllEdits_syncsOnceAfterCommit() = runTest {
+        val r = repo.batch {
+            adjustStock("i1", 2, "r", null)
+            adjustStock("i1", 3, "r", null)
+            EditResult.Success("done")
+        }
+        assertEquals("done", r.ok())
+        assertEquals(2, rows().size)
+        assertEquals(15L, OutboxOverlay.derivedQuantity(db, "i1"))
+        assertEquals(listOf(false to 2), syncCalls)
+    }
+
+    @Test
+    fun batch_failureRollsBackEarlierEdits_noSync() = runTest {
+        val r = repo.batch {
+            adjustStock("i1", 2, "r", null)
+            adjustStock("ghost", 1, "r", null)
+        }
+        assertTrue(r.err() is EditError.NotFound)
+        assertTrue(rows().isEmpty())
+        assertTrue(db.stockAdjustmentDao().observeByItemId("i1").first().isEmpty())
+        assertTrue(syncCalls.isEmpty())
+    }
+
+    @Test
+    fun batch_thatWritesNothing_doesNotSync() = runTest {
+        repo.batch { EditResult.Success(Unit) }.ok()
+        assertTrue(syncCalls.isEmpty())
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/domain/ReceivingCheckInTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/domain/ReceivingCheckInTest.kt
new file mode 100644
index 0000000..15b4646
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/domain/ReceivingCheckInTest.kt
@@ -0,0 +1,346 @@
+package dev.hho.android.domain
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.outbox.LocalMutation
+import dev.hho.android.data.outbox.OutboxOverlay
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.receiving.ReceivingException
+import dev.hho.android.data.receiving.ReceivingRepository
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.PurchasedFromBlockEntity
+import dev.hho.android.data.room.ReceivingStatus
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.edit
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.outbox.LedgerFakeServer
+import dev.hho.android.data.receiving.ScanOutcome
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.data.sync.OutboxSyncer
+import dev.hho.android.data.sync.PushPhaseOutcome
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import okhttp3.HttpUrl
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import okhttp3.Response
+import okhttp3.mockwebserver.MockWebServer
+import java.io.File
+import java.io.IOException
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.json.JsonPrimitive
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.time.LocalDate
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ReceivingCheckInTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var receiving: ReceivingRepository
+    private lateinit var checkIn: ReceivingCheckIn
+    private val syncCalls = mutableListOf<Pair<Boolean, Int>>()
+    private val date = LocalDate.of(2026, 3, 4)
+
+    @Before
+    fun setUp() = kotlinx.coroutines.runBlocking {
+        db = inMemoryHhoDatabase()
+        val ids = UuidV7Generator()
+        val edits = EditRepository(db, OutboxRepository(db, ids), ids) {
+            syncCalls += db.openHelper.writableDatabase.inTransaction() to
+                db.openHelper.readableDatabase.query("SELECT COUNT(*) FROM outbox_mutation").use { it.moveToFirst(); it.getInt(0) }
+        }
+        checkIn = ReceivingCheckIn(db, edits) { 1234L }
+        receiving = ReceivingRepository(db)
+        for ((id, qty) in listOf("a" to 10L, "b" to 0L, "c" to 5L, "d" to 1L)) {
+            db.itemDao().upsert(ItemEntity(id, 1, "Item $id", null, null, qty, null, 1, 1, 3))
+        }
+    }
+
+    @After
+    fun tearDown() = db.close()
+
+    private suspend fun rows() = db.outboxDao().getAllOrdered().map { LocalMutation.from(it) }
+
+    private suspend fun session(): String {
+        val s = receiving.startSession("Acme", "PO-7", date)
+        receiving.addExpected(s.id, "a", 5)
+        receiving.setReceived(s.id, "a", 4)
+        receiving.addExpected(s.id, "b", 3)
+        receiving.addExpected(s.id, "c", 2)
+        receiving.setReceived(s.id, "c", 2)
+        receiving.confirmUnexpected(s.id, "d")
+        return s.id
+    }
+
+    @Test
+    fun multiLine_writesAdjustmentsAndStamps_completes_syncsOnceAfterCommit() = runTest {
+        val id = session()
+        val r = checkIn.checkIn(id)
+        assertEquals(CheckInResult.Completed(3), r)
+
+        val m = rows()
+        val adj = m.filter { it.entityType == "stock_adjustment" }
+        assertEquals(3, adj.size)
+        assertEquals(setOf("a" to 4L, "c" to 2L, "d" to 1L), adj.map { (it.fields["item_id"] as JsonPrimitive).content to (it.fields["delta"] as JsonPrimitive).content.toLong() }.toSet())
+        adj.forEach {
+            assertEquals(JsonPrimitive("receiving"), it.fields["reason"])
+            assertEquals(JsonPrimitive("PO-7"), it.fields["note"])
+        }
+        val stamps = m.filter { it.entityType == "purchased_from_block" }
+        assertEquals(3, stamps.size)
+        stamps.forEach {
+            assertEquals(setOf("item_id", "vendor", "purchased_on", "order_reference"), it.fields.keys)
+            assertEquals(JsonPrimitive("Acme"), it.fields["vendor"])
+            assertEquals(JsonPrimitive("2026-03-04"), it.fields["purchased_on"])
+            assertEquals(0L, it.baseVersion)
+        }
+        assertEquals(14L, OutboxOverlay.derivedQuantity(db, "a"))
+        assertEquals(0L, OutboxOverlay.derivedQuantity(db, "b"))
+        assertEquals(7L, OutboxOverlay.derivedQuantity(db, "c"))
+        assertEquals(2L, OutboxOverlay.derivedQuantity(db, "d"))
+        assertNull(db.purchasedFromBlockDao().getByItemId("b"))
+        assertNotNull(db.purchasedFromBlockDao().getByItemId("a"))
+
+        val s = db.receivingDao().getSession(id)!!
+        assertEquals(ReceivingStatus.COMPLETED, s.status)
+        assertEquals(1234L, s.completedAt)
+        assertEquals(listOf(false to 6), syncCalls)
+    }
+
+    @Test
+    fun existingBlock_isUpdatedWithItsVersion_keepingPrice() = runTest {
+        db.purchasedFromBlockDao().upsert(
+            PurchasedFromBlockEntity("blk", 1, "a", 999, "Old", null, null, "n", 1, 1, 6),
+        )
+        val s = receiving.startSession("Acme", "PO-7", date)
+        receiving.addExpected(s.id, "a", 1)
+        receiving.setReceived(s.id, "a", 1)
+        checkIn.checkIn(s.id)
+        val stamp = rows().single { it.entityType == "purchased_from_block" }
+        assertEquals("blk", stamp.entityId)
+        assertEquals(6L, stamp.baseVersion)
+        assertFalse("purchase_price_minor" in stamp.fields)
+        assertEquals(999L, db.purchasedFromBlockDao().getByItemId("a")!!.purchasePriceMinor)
+        assertEquals("Acme", db.purchasedFromBlockDao().getByItemId("a")!!.vendor)
+    }
+
+    @Test
+    fun repeat_isNoOp_noRowsNoSync() = runTest {
+        val id = session()
+        checkIn.checkIn(id)
+        val rowsBefore = rows()
+        val r = checkIn.checkIn(id)
+        assertEquals(CheckInResult.AlreadyCompleted, r)
+        assertEquals(rowsBefore, rows())
+        assertEquals(1, syncCalls.size)
+    }
+
+    @Test
+    fun sessionWithNoReceivedLines_completesWithoutWritesOrSync() = runTest {
+        val s = receiving.startSession("Acme")
+        receiving.addExpected(s.id, "a", 2)
+        assertEquals(CheckInResult.Completed(0), checkIn.checkIn(s.id))
+        assertTrue(rows().isEmpty())
+        assertTrue(syncCalls.isEmpty())
+        assertEquals(ReceivingStatus.COMPLETED, db.receivingDao().getSession(s.id)!!.status)
+    }
+
+    @Test
+    fun cancelledAndUnknownSessions_areErrors() = runTest {
+        val s = receiving.startSession("Acme")
+        receiving.cancel(s.id)
+        try {
+            checkIn.checkIn(s.id)
+            fail()
+        } catch (e: ReceivingException.SessionNotOpen) {
+            assertEquals(ReceivingStatus.CANCELLED, e.status)
+        }
+        try {
+            checkIn.checkIn("nope")
+            fail()
+        } catch (_: ReceivingException.SessionNotFound) {
+        }
+        assertTrue(rows().isEmpty())
+        assertTrue(syncCalls.isEmpty())
+    }
+
+    @Test
+    fun rejectedLine_rollsBackWholeCheckIn() = runTest {
+        val id = session()
+        db.openHelper.writableDatabase.execSQL("DELETE FROM item WHERE id = 'd'")
+        val r = checkIn.checkIn(id)
+        assertTrue((r as CheckInResult.Failed).error is EditError.NotFound)
+        assertTrue(rows().isEmpty())
+        assertEquals(ReceivingStatus.OPEN, db.receivingDao().getSession(id)!!.status)
+        assertTrue(syncCalls.isEmpty())
+    }
+
+    @Test
+    fun killMidCheckIn_leavesSessionOpen_outboxAndMirrorUntouched() = runTest {
+        val id = session()
+        db.openHelper.writableDatabase.execSQL(
+            "CREATE TRIGGER die_4th BEFORE INSERT ON outbox_mutation WHEN (SELECT COUNT(*) FROM outbox_mutation) >= 3 " +
+                "BEGIN SELECT RAISE(ABORT, 'killed'); END",
+        )
+        val r = checkIn.checkIn(id)
+        assertTrue((r as CheckInResult.Failed).error is EditError.StorageFailed)
+        assertTrue(rows().isEmpty())
+        assertEquals(ReceivingStatus.OPEN, db.receivingDao().getSession(id)!!.status)
+        assertNull(db.receivingDao().getSession(id)!!.completedAt)
+        assertTrue(db.stockAdjustmentDao().observeByItemId("a").first().isEmpty())
+        assertNull(db.purchasedFromBlockDao().getByItemId("a"))
+        assertEquals(10L, OutboxOverlay.derivedQuantity(db, "a"))
+        assertTrue(syncCalls.isEmpty())
+
+        db.openHelper.writableDatabase.execSQL("DROP TRIGGER die_4th")
+        assertEquals(CheckInResult.Completed(3), checkIn.checkIn(id))
+        assertEquals(6, rows().size)
+    }
+
+    private class JvmTripwire : Interceptor {
+        val calls = mutableListOf<String>()
+
+        override fun intercept(chain: Interceptor.Chain): Response {
+            calls += chain.request().url.toString()
+            throw IOException("NetworkTripwire: network access attempted in an offline test")
+        }
+    }
+
+    private fun tripwireClient(tripwire: JvmTripwire): HhoApiClient {
+        val http = OkHttpClient.Builder().addInterceptor(tripwire).build()
+        return HhoApiClient(http, http)
+    }
+
+    private fun serverClient(server: MockWebServer): HhoApiClient {
+        val file = File.createTempFile("hho-checkin-test", ".preferences_pb").also { it.deleteOnExit() }
+        val dataStore = PreferenceDataStoreFactory.create(produceFile = { file })
+        runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = server.url("/").toString() } }
+        val cv = ClientVersionInterceptor()
+        val provider = object : DeviceTokenProvider {
+            override suspend fun tokenFor(requestUrl: HttpUrl): String? = null
+            override suspend fun invalidate(requestUrl: HttpUrl, rejectedToken: String) = Unit
+        }
+        val http = NetworkModule.provideOkHttpClient(BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore)), AuthHeaderInterceptor(provider), cv)
+        return HhoApiClient(http, NetworkModule.provideProbeOkHttpClient(http, cv))
+    }
+
+    private fun str(m: LocalMutation, key: String) = (m.fields[key] as JsonPrimitive).content
+
+    @Test
+    fun tripwire_recordsAndRefuses_soZeroCallsMeansZero() = runBlocking {
+        val tripwire = JvmTripwire()
+        assertTrue(tripwireClient(tripwire).getStatus().isFailure)
+        assertEquals(1, tripwire.calls.size)
+    }
+
+    @Test
+    fun offlineCheckIn_expectedAndUnexpected_mirrorOutboxAndLedgerPush() = runBlocking {
+        val tripwire = JvmTripwire()
+        val offlineApi = tripwireClient(tripwire)
+        db.itemDao().upsert(ItemEntity("a", 1, "Item a", null, null, 5, null, 1, 1, 3))
+        db.itemDao().upsert(ItemEntity("b", 1, "Item b", null, null, 0, null, 1, 1, 3))
+        db.itemDao().upsert(ItemEntity("c", 1, "Item c", null, null, 0, null, 1, 1, 3))
+        db.purchasedFromBlockDao().upsert(
+            PurchasedFromBlockEntity("blk-a", 1, "a", 999, "Old", LocalDate.of(2020, 1, 1), "PO-OLD", "n", 1, 1, 6),
+        )
+
+        val s = receiving.startSession("ACME", "PO-9", date)
+        receiving.addExpected(s.id, "a", 3)
+        receiving.addExpected(s.id, "b", 2)
+        repeat(3) { assertTrue(receiving.recordScan(s.id, "a") is ScanOutcome.Counted) }
+        assertTrue(receiving.recordScan(s.id, "b") is ScanOutcome.Counted)
+        assertEquals(ScanOutcome.Unexpected("c"), receiving.recordScan(s.id, "c"))
+        receiving.confirmUnexpected(s.id, "c")
+        assertEquals(CheckInResult.Completed(3), checkIn.checkIn(s.id))
+        assertEquals("no network call during start -> scan -> check-in", emptyList<String>(), tripwire.calls)
+        assertNotNull(offlineApi)
+
+        assertEquals(8L, OutboxOverlay.derivedQuantity(db, "a"))
+        assertEquals(1L, OutboxOverlay.derivedQuantity(db, "b"))
+        assertEquals(1L, OutboxOverlay.derivedQuantity(db, "c"))
+        assertEquals(ReceivingStatus.COMPLETED, db.receivingDao().getSession(s.id)!!.status)
+
+        val blockA = db.purchasedFromBlockDao().getByItemId("a")!!
+        assertEquals("blk-a", blockA.id)
+        assertEquals("ACME", blockA.vendor)
+        assertEquals("PO-9", blockA.orderReference)
+        assertEquals(date, blockA.purchasedOn)
+        assertEquals(999L, blockA.purchasePriceMinor)
+        for (id in listOf("b", "c")) {
+            val b = db.purchasedFromBlockDao().getByItemId(id)
+            assertNotNull("block for $id created in the mirror", b)
+            assertEquals("ACME", b!!.vendor)
+            assertEquals("PO-9", b.orderReference)
+            assertEquals(date, b.purchasedOn)
+        }
+
+        val rowsBefore = db.outboxDao().getAllOrdered()
+        val m = rows()
+        assertEquals(6, m.size)
+        val adj = m.filter { it.entityType == "stock_adjustment" }
+        assertEquals(mapOf("a" to 3L, "b" to 1L, "c" to 1L), adj.associate { str(it, "item_id") to str(it, "delta").toLong() })
+        adj.forEach {
+            assertEquals(setOf("item_id", "delta", "reason", "note"), it.fields.keys)
+            assertEquals("receiving", str(it, "reason"))
+            assertEquals("PO-9", str(it, "note"))
+            assertEquals(0L, it.baseVersion)
+        }
+        val stamps = m.filter { it.entityType == "purchased_from_block" }.associateBy { str(it, "item_id") }
+        assertEquals(setOf("a", "b", "c"), stamps.keys)
+        stamps.values.forEach {
+            assertEquals(setOf("item_id", "vendor", "order_reference", "purchased_on"), it.fields.keys)
+            assertEquals("ACME", str(it, "vendor"))
+            assertEquals("PO-9", str(it, "order_reference"))
+            assertEquals("2026-03-04", str(it, "purchased_on"))
+        }
+        assertEquals("blk-a", stamps.getValue("a").entityId)
+        assertEquals(6L, stamps.getValue("a").baseVersion)
+        assertEquals(0L, stamps.getValue("b").baseVersion)
+        assertEquals(0L, stamps.getValue("c").baseVersion)
+        assertTrue(rowsBefore.all { it.state == dev.hho.android.data.room.OutboxState.PENDING })
+
+        val fake = LedgerFakeServer()
+        val server = MockWebServer().also { it.dispatcher = fake }
+        try {
+            val out = OutboxSyncer(db, serverClient(server), OutboxRepository(db)).push("device-1")
+            assertEquals(PushPhaseOutcome.Drained, out)
+        } finally {
+            server.shutdown()
+        }
+        assertTrue("outbox drained", db.outboxDao().getAllOrdered().isEmpty())
+        assertEquals(rowsBefore.map { it.mutationId }, fake.applyOrder)
+        assertTrue("each mutation applied exactly once (none skipped / replayed)", fake.appliedCount.values.all { it == 1 })
+        assertEquals(6, fake.appliedCount.size)
+        rowsBefore.forEach { assertEquals(it.baseVersion, fake.baseVersions[it.mutationId]) }
+        assertEquals(1L, fake.versions["purchased_from_block/blk-a"])
+        val stateA = fake.entityState.getValue("purchased_from_block/blk-a")
+        assertEquals("ACME", stateA["vendor"])
+        assertEquals("PO-9", stateA["order_reference"])
+        assertFalse("purchase_price_minor" in stateA)
+        assertEquals(3, fake.entityState.keys.count { it.startsWith("stock_adjustment/") })
+        assertEquals(
+            listOf("1", "1", "3"),
+            fake.entityState.filterKeys { it.startsWith("stock_adjustment/") }.values.map { it.getValue("delta") }.sorted(),
+        )
+        assertEquals(1, fake.pushRequests)
+        assertEquals("the tripwire client stayed untouched through the push phase too", emptyList<String>(), tripwire.calls)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/e2e/ConflictLogTwoDeviceE2ETest.kt b/android-app/app/src/test/kotlin/dev/hho/android/e2e/ConflictLogTwoDeviceE2ETest.kt
new file mode 100644
index 0000000..b0780fe
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/e2e/ConflictLogTwoDeviceE2ETest.kt
@@ -0,0 +1,80 @@
+package dev.hho.android.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.outbox.LocalMutation
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.ConflictOrigin
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.sync.SyncRunOutcome
+import dev.hho.android.data.sync.testSyncEngine
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ConflictLogTwoDeviceE2ETest {
+    @get:Rule(order = 0)
+    val timeout: Timeout = Timeout.seconds(120)
+
+    @get:Rule(order = 1)
+    val server = RealServerHarness()
+
+    private lateinit var dbA: HhoDatabase
+    private lateinit var dbB: HhoDatabase
+
+    @Before
+    fun setUp() {
+        dbA = inMemoryHhoDatabase()
+        dbB = inMemoryHhoDatabase()
+    }
+
+    @After
+    fun tearDown() {
+        dbA.close()
+        dbB.close()
+    }
+
+    @Test
+    fun sameFieldConflictPushedByTwoDevices_landsInConflictRecordWithBothValues_afterOneRun() = runBlocking {
+        val id = server.seedItem("Original", quantity = 1).getValue("id").jsonPrimitive.content
+        val outboxA = OutboxRepository(dbA)
+        val outboxB = OutboxRepository(dbB)
+        val engineA = testSyncEngine(server.newApiClient(), dbA, outboxA, withConflictLog = true)
+        val engineB = testSyncEngine(server.newApiClient(), dbB, outboxB, withConflictLog = true)
+
+        assertTrue(engineA.sync("device-a").isSuccess)
+        assertTrue(engineB.sync("device-b").isSuccess)
+        outboxA.enqueue(rename(id, checkNotNull(dbA.itemDao().getById(id)?.version), "A-name"))
+        val queuedB = outboxB.enqueue(rename(id, checkNotNull(dbB.itemDao().getById(id)?.version), "B-name"))
+
+        val a = engineA.sync("device-a")
+        assertTrue("A sync failed: ${a.exceptionOrNull()}", a.isSuccess)
+        assertEquals("A-name", server.readItem(id)!!.getValue("name").jsonPrimitive.content)
+        assertTrue(dbA.conflictRecordDao().getAll().isEmpty())
+
+        val b = engineB.sync("device-b")
+        assertEquals(SyncRunOutcome.FullPullRan(SyncRunOutcome.FullPullReason.ConflictReconcile), b.getOrNull())
+
+        val row = dbB.conflictRecordDao().getAll().single { it.entityId == id && it.fieldName == "name" }
+        assertEquals(queuedB.mutationId, row.mutationId)
+        assertEquals("\"B-name\"", row.losingValueJson)
+        assertEquals("\"A-name\"", row.serverValueJson)
+        assertEquals(ConflictOrigin.SERVER_LOG, row.origin)
+        assertEquals("A-name", dbB.itemDao().getById(id)?.name)
+    }
+
+    private fun rename(id: String, base: Long, name: String) =
+        LocalMutation("item", id, "upsert", base, buildJsonObject { put("name", JsonPrimitive(name)) })
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/e2e/RealServerHarness.kt b/android-app/app/src/test/kotlin/dev/hho/android/e2e/RealServerHarness.kt
new file mode 100644
index 0000000..c0ec459
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/e2e/RealServerHarness.kt
@@ -0,0 +1,286 @@
+package dev.hho.android.e2e
+
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.edit
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.auth.DeviceTokenProvider
+import dev.hho.android.data.network.AuthHeaderInterceptor
+import dev.hho.android.data.network.BaseUrlInterceptor
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceBaseUrlResolver
+import dev.hho.android.data.settings.SettingsKeys
+import dev.hho.android.di.NetworkModule
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.put
+import okhttp3.HttpUrl
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.junit.Assume
+import org.junit.rules.ExternalResource
+import java.io.File
+import java.net.InetAddress
+import java.net.ServerSocket
+import java.util.concurrent.TimeUnit
+
+class RealServerHarness : ExternalResource(), AutoCloseable {
+    private var process: Process? = null
+    private var shutdownHook: Thread? = null
+    private lateinit var workDir: File
+    private lateinit var logFile: File
+    private val json = Json { ignoreUnknownKeys = true }
+    private val readbackHttp = OkHttpClient()
+
+    @Volatile
+    private var deviceToken: String? = null
+
+    lateinit var baseUrl: HttpUrl
+        private set
+
+    val username: String = "owner"
+    val password: String = "correct-horse-battery-staple"
+
+    lateinit var groupId: String
+        private set
+
+    val pid: Long get() = pidOf(checkNotNull(process) { "harness not started" })
+
+    val serverLog: File get() = logFile
+
+    fun newApiClient(): HhoApiClient {
+        val token = checkNotNull(deviceToken) { "harness not started" }
+        return buildClient(baseUrl, token)
+    }
+
+    override fun before() {
+        start()
+    }
+
+    override fun after() {
+        close()
+    }
+
+    fun start() {
+        val bin = resolveBinary()
+        Assume.assumeTrue(SKIP_MESSAGE, bin != null)
+        workDir = File.createTempFile("hho-e2e-", "").also {
+            it.delete()
+            check(it.mkdirs()) { "cannot create $it" }
+        }
+        val dataDir = File(workDir, "data").also { it.mkdirs() }
+        logFile = File(workDir, "server.log")
+        try {
+            launch(checkNotNull(bin), dataDir)
+            bootstrap()
+        } catch (t: Throwable) {
+            val tail = runCatching { logFile.readText().takeLast(4000) }.getOrDefault("")
+            close()
+            throw AssertionError("real-server harness failed to start: ${t.message}\n--- server log tail ---\n$tail", t)
+        }
+    }
+
+    private fun launch(bin: File, dataDir: File) {
+        var lastFailure: Throwable? = null
+        repeat(LAUNCH_ATTEMPTS) {
+            val port = freePort()
+            val pb = ProcessBuilder(bin.absolutePath, "serve", "--addr", "127.0.0.1:$port")
+                .redirectErrorStream(true)
+                .redirectOutput(logFile)
+            pb.environment().apply {
+                keys.filter { it.startsWith("HHO_") }.forEach { remove(it) }
+                put("HHO_DATA_DIR", dataDir.absolutePath)
+            }
+            val p = pb.start()
+            process = p
+            registerShutdownHook(p)
+            baseUrl = "http://127.0.0.1:$port/".toHttpUrlOrThrow()
+            try {
+                awaitReady(p)
+                return
+            } catch (t: Throwable) {
+                lastFailure = t
+                terminate(p)
+                process = null
+            }
+        }
+        throw IllegalStateException("server did not become ready after $LAUNCH_ATTEMPTS attempts", lastFailure)
+    }
+
+    private fun awaitReady(p: Process) {
+        val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(READY_TIMEOUT_SECONDS)
+        val statusUrl = baseUrl.resolve("api/v1/status")!!
+        while (System.nanoTime() < deadline) {
+            check(p.isAlive) { "server exited early with code ${p.exitValue()}" }
+            val ok = runCatching {
+                readbackHttp.newCall(Request.Builder().url(statusUrl).build()).execute().use { it.isSuccessful }
+            }.getOrDefault(false)
+            if (ok) return
+            Thread.sleep(POLL_MILLIS)
+        }
+        error("no 200 from $statusUrl within ${READY_TIMEOUT_SECONDS}s")
+    }
+
+    private fun bootstrap() {
+        val register = post(
+            "api/v1/auth/register",
+            buildJsonObject {
+                put("username", username)
+                put("password", password)
+            },
+            token = null,
+        )
+        check(register.first == 201) { "register answered ${register.first}" }
+        groupId = json.parseToJsonElement(register.second).jsonObject.getValue("group_id").jsonPrimitive.content
+
+        val bootstrapClient = buildClient(baseUrl, token = null)
+        runBlocking {
+            val login = bootstrapClient.login(username, password).getOrThrow()
+            val issued = bootstrapClient.issueDeviceToken("e2e-harness", login.sessionCookie).getOrThrow()
+            deviceToken = issued.token
+        }
+    }
+
+    fun seedItem(
+        name: String,
+        quantity: Long = 0,
+        description: String? = null,
+    ): JsonObject {
+        val (code, body) = post(
+            "api/v1/items",
+            buildJsonObject {
+                put("name", name)
+                put("quantity", quantity)
+                if (description != null) put("description", description)
+            },
+            token = deviceToken,
+        )
+        check(code == 201) { "createItem answered $code" }
+        return json.parseToJsonElement(body).jsonObject
+    }
+
+    fun readItem(id: String): JsonObject? {
+        val (code, body) = get("api/v1/items/$id")
+        if (code == 404) return null
+        check(code == 200) { "getItem answered $code" }
+        return json.parseToJsonElement(body).jsonObject
+    }
+
+    fun listItems(): List<JsonObject> {
+        val (code, body) = get("api/v1/items?limit=200")
+        check(code == 200) { "listItems answered $code" }
+        val parsed = json.parseToJsonElement(body)
+        val array: JsonArray = if (parsed is JsonArray) parsed else parsed.jsonObject.getValue("items").jsonArray
+        return array.map { it.jsonObject }
+    }
+
+    private fun get(path: String): Pair<Int, String> {
+        val req = Request.Builder().url(baseUrl.resolve(path)!!)
+            .header("Authorization", "Bearer ${checkNotNull(deviceToken)}")
+            .build()
+        return readbackHttp.newCall(req).execute().use { it.code to it.body!!.string() }
+    }
+
+    private fun post(
+        path: String,
+        body: JsonObject,
+        token: String?,
+    ): Pair<Int, String> {
+        val req = Request.Builder().url(baseUrl.resolve(path)!!)
+            .post(body.toString().toRequestBody("application/json".toMediaType()))
+            .apply { if (token != null) header("Authorization", "Bearer $token") }
+            .build()
+        return readbackHttp.newCall(req).execute().use { it.code to it.body!!.string() }
+    }
+
+    override fun close() {
+        process?.let { terminate(it) }
+        process = null
+        shutdownHook?.let { runCatching { Runtime.getRuntime().removeShutdownHook(it) } }
+        shutdownHook = null
+        if (::workDir.isInitialized) workDir.deleteRecursively()
+        readbackHttp.dispatcher.executorService.shutdown()
+        readbackHttp.connectionPool.evictAll()
+    }
+
+    private fun registerShutdownHook(p: Process) {
+        shutdownHook?.let { runCatching { Runtime.getRuntime().removeShutdownHook(it) } }
+        val hook = Thread { kill(p) }
+        Runtime.getRuntime().addShutdownHook(hook)
+        shutdownHook = hook
+    }
+
+    private fun terminate(p: Process) {
+        p.destroy()
+        if (!p.waitFor(GRACEFUL_STOP_SECONDS, TimeUnit.SECONDS)) kill(p)
+        p.waitFor(GRACEFUL_STOP_SECONDS, TimeUnit.SECONDS)
+    }
+
+    private fun kill(p: Process) {
+        descendantsOf(p).forEach { runCatching { it.javaClass.getMethod("destroyForcibly").invoke(it) } }
+        p.destroyForcibly()
+    }
+
+    companion object {
+        const val SKIP_MESSAGE = "HHO_SERVER_BIN not set: real-server e2e tests skipped (see T170g)"
+
+        private const val READY_TIMEOUT_SECONDS = 30L
+        private const val GRACEFUL_STOP_SECONDS = 5L
+        private const val POLL_MILLIS = 100L
+        private const val LAUNCH_ATTEMPTS = 3
+
+        fun resolveBinary(): File? {
+            val raw = System.getenv("HHO_SERVER_BIN")?.takeIf { it.isNotBlank() }
+                ?: System.getProperty("HHO_SERVER_BIN")?.takeIf { it.isNotBlank() }
+            return raw?.let(::File)?.takeIf { it.isFile && it.canExecute() }
+        }
+
+        private fun pidOf(p: Process): Long = Process::class.java.getMethod("pid").invoke(p) as Long
+
+        private fun descendantsOf(p: Process): List<Any> =
+            runCatching {
+                @Suppress("UNCHECKED_CAST")
+                val stream = Process::class.java.getMethod("descendants").invoke(p) as java.util.stream.Stream<Any>
+                stream.toList()
+            }.getOrDefault(emptyList())
+
+        private fun freePort(): Int =
+            ServerSocket(0, 1, InetAddress.getLoopbackAddress()).use { it.localPort }
+
+        private fun String.toHttpUrlOrThrow(): HttpUrl = HttpUrl.Builder().apply {
+            val u = java.net.URI(this@toHttpUrlOrThrow)
+            scheme(u.scheme).host(u.host).port(u.port)
+        }.build()
+
+        private fun buildClient(
+            baseUrl: HttpUrl,
+            token: String?,
+        ): HhoApiClient {
+            val file = File.createTempFile("hho-e2e-prefs", ".preferences_pb").also { it.deleteOnExit() }
+            val dataStore = PreferenceDataStoreFactory.create(produceFile = { file })
+            runBlocking { dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = baseUrl.toString() } }
+            val cv = ClientVersionInterceptor()
+            val provider = object : DeviceTokenProvider {
+                override suspend fun tokenFor(requestUrl: HttpUrl): String? = token
+
+                override suspend fun invalidate(
+                    requestUrl: HttpUrl,
+                    rejectedToken: String,
+                ) = Unit
+            }
+            val http = NetworkModule.provideOkHttpClient(
+                BaseUrlInterceptor(InstanceBaseUrlResolver(dataStore)),
+                AuthHeaderInterceptor(provider),
+                cv,
+            )
+            return HhoApiClient(http, NetworkModule.provideProbeOkHttpClient(http, cv))
+        }
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/e2e/RealServerHarnessSmokeTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/e2e/RealServerHarnessSmokeTest.kt
new file mode 100644
index 0000000..7961a40
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/e2e/RealServerHarnessSmokeTest.kt
@@ -0,0 +1,66 @@
+package dev.hho.android.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.sync.testSyncEngine
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.jsonPrimitive
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class RealServerHarnessSmokeTest {
+    @get:Rule(order = 0)
+    val timeout: Timeout = Timeout.seconds(90)
+
+    @get:Rule(order = 1)
+    val server = RealServerHarness()
+
+    private lateinit var db: HhoDatabase
+
+    @Before
+    fun setUp() {
+        db = inMemoryHhoDatabase()
+    }
+
+    @After
+    fun tearDown() {
+        db.close()
+    }
+
+    @Test
+    fun seedRoundTripsThroughIndependentReadback() {
+        val seeded = server.seedItem("Cordless drill", quantity = 3)
+        val id = seeded.getValue("id").jsonPrimitive.content
+
+        val read = checkNotNull(server.readItem(id))
+        assertEquals("Cordless drill", read.getValue("name").jsonPrimitive.content)
+        assertEquals("3", read.getValue("quantity").jsonPrimitive.content)
+        assertTrue(server.listItems().any { it.getValue("id").jsonPrimitive.content == id })
+        assertNull(server.readItem("does-not-exist"))
+    }
+
+    @Test
+    fun syncPullMirrorsSeededItemIntoRoom() =
+        runBlocking {
+            val id = server.seedItem("Step ladder", quantity = 1).getValue("id").jsonPrimitive.content
+
+            val engine = testSyncEngine(server.newApiClient(), db)
+            val outcome = engine.sync("e2e-device-a")
+            assertTrue("sync failed: ${outcome.exceptionOrNull()}", outcome.isSuccess)
+
+            val mirrored = checkNotNull(db.itemDao().getById(id))
+            assertEquals("Step ladder", mirrored.name)
+            assertEquals(1L, mirrored.quantity)
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/e2e/StocktakeRealServerTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/e2e/StocktakeRealServerTest.kt
new file mode 100644
index 0000000..5cf9974
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/e2e/StocktakeRealServerTest.kt
@@ -0,0 +1,286 @@
+package dev.hho.android.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.domain.EditRepository
+import dev.hho.android.domain.EditResult
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.longOrNull
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class StocktakeRealServerTest {
+    @get:Rule(order = 0)
+    val timeout: Timeout = Timeout.seconds(240)
+
+    @get:Rule(order = 1)
+    val server = RealServerHarness()
+
+    private lateinit var a: TwoDeviceSupportDevice
+    private lateinit var b: TwoDeviceSupportDevice
+    private val json = Json { ignoreUnknownKeys = true }
+
+    @Before
+    fun setUp() {
+        a = TwoDeviceSupportDevice(server, "stocktake-device-a")
+        b = TwoDeviceSupportDevice(server, "stocktake-device-b")
+    }
+
+    @After
+    fun tearDown() {
+        a.close()
+        b.close()
+    }
+
+    private sealed interface Edit {
+        suspend fun perform(repo: EditRepository): EditResult<*>
+    }
+
+    private class Adjust(val item: String, val delta: Long, val reason: String?) : Edit {
+        override suspend fun perform(repo: EditRepository) = repo.adjustStock(item, delta, reason)
+    }
+
+    private class Rename(val item: String, val name: String?, val description: String?) : Edit {
+        override suspend fun perform(repo: EditRepository) = repo.editItem(item, name, description)
+    }
+
+    private class Move(val item: String, val location: String?) : Edit {
+        override suspend fun perform(repo: EditRepository) = repo.moveItem(item, location)
+    }
+
+    private class Attach(val item: String, val label: String) : Edit {
+        override suspend fun perform(repo: EditRepository) = repo.attachLabel(item, label)
+    }
+
+    private class Detach(val item: String, val label: String) : Edit {
+        override suspend fun perform(repo: EditRepository) = repo.detachLabel(item, label)
+    }
+
+    private fun golden(name: String): JsonObject =
+        json.parseToJsonElement(File(GOLDEN_DIR, name).also { assertTrue("golden $it missing", it.isFile) }.readText()).jsonObject
+
+    private fun String.str(key: String) = jsonOf(this).getValue(key).jsonPrimitive.content
+
+    private fun jsonOf(s: String) = json.parseToJsonElement(s).jsonObject
+
+    private fun editsFromGolden(push: JsonObject): List<Edit> =
+        push.getValue("mutations").jsonArray.map { it.jsonObject }.map { m ->
+            val f = m.getValue("fields").jsonObject
+            val op = m["op"]?.jsonPrimitive?.content ?: "upsert"
+            when (val type = m.getValue("entity_type").jsonPrimitive.content) {
+                "stock_adjustment" -> Adjust(
+                    f.getValue("item_id").jsonPrimitive.content,
+                    f.getValue("delta").jsonPrimitive.longOrNull!!,
+                    f["reason"]?.jsonPrimitive?.content,
+                )
+                "item" -> {
+                    val id = m.getValue("entity_id").jsonPrimitive.content
+                    if ("location_id" in f) {
+                        assertEquals("a move carries only the location", setOf("location_id"), f.keys)
+                        Move(id, (f.getValue("location_id") as? JsonPrimitive)?.takeIf { it !is JsonNull }?.content)
+                    } else {
+                        Rename(id, f["name"]?.jsonPrimitive?.content, f["description"]?.jsonPrimitive?.content)
+                    }
+                }
+                "item_label" -> {
+                    val item = f.getValue("item_id").jsonPrimitive.content
+                    val label = f.getValue("label_id").jsonPrimitive.content
+                    if (op == "delete") Detach(item, label) else Attach(item, label)
+                }
+                else -> error("unexpected entity_type $type in the golden")
+            }
+        }
+
+    @Test
+    fun `50 stocktake edits persist on the real server, second sync is a no-op, second device converges`() = runBlocking {
+        val seedRequest = golden("stocktake-seed-push-request.json")
+        val push = golden("stocktake-push-request.json")
+        val expected = golden("stocktake-expected-state.json")
+        val edits = editsFromGolden(push)
+        assertEquals(50, edits.size)
+        assertEquals(
+            "golden edit mix",
+            listOf(15, 12, 10, 8, 5),
+            listOf(
+                edits.count { it is Adjust },
+                edits.count { it is Rename },
+                edits.count { it is Move },
+                edits.count { it is Attach },
+                edits.count { it is Detach },
+            ),
+        )
+
+        val seedQty = seedRequest.getValue("mutations").jsonArray.map { it.jsonObject }
+            .filter { it.getValue("entity_type").jsonPrimitive.content == "item" }
+            .associate { it.getValue("entity_id").jsonPrimitive.content to it.getValue("fields").jsonObject.getValue("quantity").jsonPrimitive.long() }
+        assertEquals(30, seedQty.size)
+        val expectedQty = seedQty.toMutableMap()
+        edits.filterIsInstance<Adjust>().forEach { expectedQty[it.item] = expectedQty.getValue(it.item) + it.delta }
+        val goldenItems = expected.getValue("items").jsonArray.map { it.jsonObject }
+        assertEquals(
+            "golden expected-state quantities == seed + sum(delta)",
+            expectedQty,
+            goldenItems.associate { it.getValue("id").jsonPrimitive.content to it.getValue("quantity").jsonPrimitive.long() },
+        )
+
+        val rest = RestReadback(server)
+        try {
+            val seeded = rest.push(seedRequest)
+            assertEquals("seed applied", seedRequest.getValue("mutations").jsonArray.size, seeded.getValue("applied").jsonArray.size)
+            assertTrue("seed has no conflicts: $seeded", seeded.getValue("conflicts").jsonArray.isEmpty())
+            val seedState = rest.snapshot()
+            assertEquals(seedQty, seedState.quantities())
+
+            a.sync()
+            assertEquals(30, a.db.itemDao().observeAll().first().size)
+            for (e in edits) {
+                val r = e.perform(a.edits)
+                assertTrue("edit failed: $r", r is EditResult.Success<*>)
+            }
+            assertEquals("50 queued mutations", 50, a.pending())
+            assertEquals("nothing reached the server yet", seedState.text, rest.snapshot().text)
+            a.sync()
+            assertEquals("outbox drained", 0, a.pending())
+
+            val after = rest.snapshot()
+            assertEquals("readback quantities == seed + sum(delta)", expectedQty, after.quantities())
+            assertEquals(30, after.items.size)
+            for (g in goldenItems) {
+                val id = g.getValue("id").jsonPrimitive.content
+                val row = after.items.getValue(id)
+                assertEquals("name of $id", g.getValue("name").jsonPrimitive.content, row.getValue("name").jsonPrimitive.content)
+                assertEquals("description of $id", g.getValue("description").jsonPrimitive.content, row.getValue("description").jsonPrimitive.content)
+                assertEquals("location of $id", g.getValue("location_id").jsonPrimitive.content, row.getValue("location_id").jsonPrimitive.content)
+            }
+            val goldenEdges = expected.getValue("item_labels").jsonArray.map { it.jsonObject }
+                .map { it.getValue("item_id").jsonPrimitive.content to it.getValue("label_id").jsonPrimitive.content }.toSet()
+            assertEquals("label edges", goldenEdges, after.edges)
+            assertTrue("edits changed the server", after.text != seedState.text)
+            assertTrue(edits.filterIsInstance<Rename>().all { after.items.getValue(it.item).getValue("name").jsonPrimitive.content == it.name })
+            assertTrue(edits.filterIsInstance<Move>().all { after.items.getValue(it.item).getValue("location_id").jsonPrimitive.content == it.location })
+
+            val mirrorA = mirror(a.db)
+            a.sync()
+            assertEquals("second sync changed nothing on the server", after.text, rest.snapshot().text)
+            assertEquals(0, a.pending())
+            assertEquals("second sync changed nothing in the mirror", mirrorA, mirror(a.db))
+            assertTrue("GET /sync/conflicts is empty: ${rest.conflicts()}", rest.conflicts().isEmpty())
+            assertTrue(a.db.conflictRecordDao().getAll().isEmpty())
+
+            b.sync()
+            assertEquals(0, b.pending())
+            assertTrue(b.db.conflictRecordDao().getAll().isEmpty())
+            val mirrorB = mirror(b.db)
+            assertEquals("device B == device A", mirrorA, mirrorB)
+            assertEquals("device B == server readback", after.text, rest.snapshot().text)
+            assertEquals(expectedQty, mirrorB.items.mapValues { it.value.quantity!! })
+            assertEquals(goldenEdges, mirrorB.edges)
+            for (g in goldenItems) {
+                val row = mirrorB.items.getValue(g.getValue("id").jsonPrimitive.content)
+                assertEquals(g.getValue("name").jsonPrimitive.content, row.name)
+                assertEquals(g.getValue("description").jsonPrimitive.content, row.description)
+                assertEquals(g.getValue("location_id").jsonPrimitive.content, row.locationId)
+            }
+            b.sync()
+            assertEquals(mirrorB, mirror(b.db))
+        } finally {
+            rest.close()
+        }
+    }
+
+    private data class Mirror(
+        val items: Map<String, dev.hho.android.data.room.ItemEntity>,
+        val edges: Set<Pair<String, String>>,
+        val labels: Set<String>,
+        val locations: Set<String>,
+    )
+
+    private suspend fun mirror(db: HhoDatabase): Mirror {
+        val items = db.itemDao().observeAll().first().associateBy { it.id }
+        val labels = db.labelDao().observeAll().first()
+        val edges = labels.flatMap { l -> db.itemLabelDao().observeByLabelId(l.id).first() }.map { it.itemId to it.labelId }
+        return Mirror(
+            items,
+            edges.toSet().also { assertEquals("no duplicate edges", edges.size, it.size) },
+            labels.map { it.id }.toSet(),
+            db.locationDao().observeAll().first().map { it.id }.toSet(),
+        )
+    }
+
+    private fun JsonElement.long() = jsonPrimitive.longOrNull!!
+
+    private fun kotlinx.serialization.json.JsonPrimitive.long() = longOrNull!!
+
+    private class Snapshot(val items: Map<String, JsonObject>, val edges: Set<Pair<String, String>>) {
+        val text: String = items.toSortedMap().values.joinToString("\n") { it.toString() } + "\n" + edges.sortedBy { it.first + it.second }
+
+        fun quantities() = items.mapValues { it.value.getValue("quantity").jsonPrimitive.longOrNull!! }
+    }
+
+    private class RestReadback(private val server: RealServerHarness) : AutoCloseable {
+        private val http = OkHttpClient()
+        private val json = Json { ignoreUnknownKeys = true }
+        private val token: String = runBlocking {
+            val client = server.newApiClient()
+            val login = client.login(server.username, server.password).getOrThrow()
+            client.issueDeviceToken("e2e-stocktake-readback", login.sessionCookie).getOrThrow().token
+        }
+
+        private fun call(path: String, body: JsonObject? = null): JsonObject {
+            val req = Request.Builder().url(server.baseUrl.resolve(path)!!)
+                .header("Authorization", "Bearer $token")
+                .apply { if (body != null) post(body.toString().toRequestBody("application/json".toMediaType())) }
+                .build()
+            return http.newCall(req).execute().use {
+                val text = it.body!!.string()
+                check(it.code == 200) { "${req.method} $path answered ${it.code}" }
+                json.parseToJsonElement(text).jsonObject
+            }
+        }
+
+        fun push(body: JsonObject) = call("api/v1/sync/push", body)
+
+        fun conflicts(): List<JsonElement> = call("api/v1/sync/conflicts?limit=200").getValue("conflicts").jsonArray
+
+        fun snapshot(): Snapshot {
+            val items = call("api/v1/items?limit=200").getValue("items").jsonArray.map { it.jsonObject }
+                .associateBy { it.getValue("id").jsonPrimitive.content }
+            val edges = items.keys.flatMap { id ->
+                call("api/v1/items/$id/labels").getValue("labels").jsonArray.map { id to it.jsonObject.getValue("id").jsonPrimitive.content }
+            }.toSet()
+            return Snapshot(items, edges)
+        }
+
+        override fun close() {
+            http.connectionPool.evictAll()
+            http.dispatcher.executorService.shutdown()
+        }
+    }
+
+    private companion object {
+        val GOLDEN_DIR = File("src/test/resources/golden")
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/e2e/TwoDeviceConcurrentEditTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/e2e/TwoDeviceConcurrentEditTest.kt
new file mode 100644
index 0000000..165fbd1
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/e2e/TwoDeviceConcurrentEditTest.kt
@@ -0,0 +1,130 @@
+package dev.hho.android.e2e
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.domain.EditResult
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.jsonPrimitive
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class TwoDeviceConcurrentEditTest {
+    @get:Rule(order = 0)
+    val timeout: Timeout = Timeout.seconds(180)
+
+    @get:Rule(order = 1)
+    val server = RealServerHarness()
+
+    private lateinit var a: TwoDeviceSupportDevice
+    private lateinit var b: TwoDeviceSupportDevice
+
+    @Before
+    fun setUp() {
+        a = TwoDeviceSupportDevice(server, "device-a")
+        b = TwoDeviceSupportDevice(server, "device-b")
+    }
+
+    @After
+    fun tearDown() {
+        a.close()
+        b.close()
+    }
+
+    private fun serverField(id: String, field: String) =
+        server.readItem(id)!!.getValue(field).jsonPrimitive.content
+
+    private fun <T> EditResult<T>.ok() = assertTrue("edit failed: $this", this is EditResult.Success)
+
+    @Test
+    fun differentFieldEdits_bothSurvive_andBothMirrorsConverge() = runBlocking {
+        val id = server.seedItem("Original", quantity = 1, description = "orig-desc").getValue("id").jsonPrimitive.content
+        a.sync(); b.sync()
+
+        a.edits.editItem(id, name = "A-name").ok()
+        b.edits.editItem(id, description = "B-desc").ok()
+        a.sync(); b.sync(); a.sync()
+
+        assertEquals("A-name", serverField(id, "name"))
+        assertEquals("B-desc", serverField(id, "description"))
+        for (d in listOf(a, b)) {
+            val row = checkNotNull(d.db.itemDao().getById(id))
+            assertEquals("${d.name} name", "A-name", row.name)
+            assertEquals("${d.name} description", "B-desc", row.description)
+            assertTrue("${d.name} conflicts", d.db.conflictRecordDao().getAll().isEmpty())
+            assertEquals("${d.name} outbox", 0, d.pending())
+        }
+    }
+
+    @Test
+    fun sameFieldEdit_serverWins_loserGetsConflictRecord_andCorrectedMirror() = runBlocking {
+        val id = server.seedItem("Original", quantity = 1).getValue("id").jsonPrimitive.content
+        a.sync(); b.sync()
+
+        a.edits.editItem(id, name = "A-name").ok()
+        b.edits.editItem(id, name = "B-name").ok()
+        assertEquals("B's optimistic apply", "B-name", b.db.itemDao().getById(id)?.name)
+
+        a.sync()
+        b.sync()
+
+        assertEquals("A-name", serverField(id, "name"))
+        val rows = b.db.conflictRecordDao().getAll().filter { it.entityId == id && it.fieldName == "name" }
+        assertEquals(1, rows.size)
+        assertEquals("\"B-name\"", rows.single().losingValueJson)
+        assertEquals("\"A-name\"", rows.single().serverValueJson)
+        assertEquals("A-name", b.db.itemDao().getById(id)?.name)
+        assertEquals(0, b.pending())
+        a.sync()
+        assertEquals("A-name", a.db.itemDao().getById(id)?.name)
+        assertEquals(0, a.pending())
+        val bMutations = rows.map { it.mutationId }.toSet()
+        assertTrue(a.db.conflictRecordDao().getAll().all { it.mutationId in bMutations })
+    }
+
+    @Test
+    fun stockAdjustmentsFromBothDevices_bothApply_noDoubleCount() = runBlocking {
+        val id = server.seedItem("Screws", quantity = 10).getValue("id").jsonPrimitive.content
+        a.sync(); b.sync()
+
+        a.edits.adjustStock(id, 2).ok()
+        b.edits.adjustStock(id, -1).ok()
+        a.sync(); b.sync(); a.sync(); b.sync()
+
+        assertEquals("11", serverField(id, "quantity"))
+        assertEquals(11L, a.db.itemDao().getById(id)?.quantity)
+        assertEquals(11L, b.db.itemDao().getById(id)?.quantity)
+        assertTrue(a.db.conflictRecordDao().getAll().isEmpty())
+        assertTrue(b.db.conflictRecordDao().getAll().isEmpty())
+    }
+
+    @Test
+    fun moveOnOneDevice_andLabelAttachOnAnother_bothSurvive() = runBlocking {
+        val seeder = ReferenceDataSeeder(server)
+        val loc = seeder.createLocation("Garage")
+        val label = seeder.createLabel("Tools")
+        val id = server.seedItem("Drill", quantity = 1).getValue("id").jsonPrimitive.content
+        a.sync(); b.sync()
+
+        a.edits.moveItem(id, loc).ok()
+        b.edits.attachLabel(id, label).ok()
+        a.sync(); b.sync(); a.sync()
+
+        val item = server.readItem(id)!!
+        assertEquals(loc, item.getValue("location_id").jsonPrimitive.content)
+        for (d in listOf(a, b)) {
+            assertEquals("${d.name} location", loc, d.db.itemDao().getById(id)?.locationId)
+            val labels = d.db.itemLabelDao().observeByItemId(id).first()
+            assertEquals("${d.name} labels", listOf(label), labels.map { it.labelId })
+            assertTrue(d.db.conflictRecordDao().getAll().isEmpty())
+        }
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/e2e/TwoDeviceSupport.kt b/android-app/app/src/test/kotlin/dev/hho/android/e2e/TwoDeviceSupport.kt
new file mode 100644
index 0000000..bc9d1e5
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/e2e/TwoDeviceSupport.kt
@@ -0,0 +1,66 @@
+package dev.hho.android.e2e
+
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.sync.SyncEngine
+import dev.hho.android.data.sync.testSyncEngine
+import dev.hho.android.domain.EditRepository
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.put
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+
+internal class TwoDeviceSupportDevice(
+    server: RealServerHarness,
+    val name: String,
+) {
+    val db: HhoDatabase = inMemoryHhoDatabase()
+    val outbox = OutboxRepository(db)
+    private val engine: SyncEngine = testSyncEngine(server.newApiClient(), db, outbox, withConflictLog = true)
+    private val ids = UuidV7Generator()
+
+    val edits = EditRepository(db, outbox, ids) {}
+
+    suspend fun sync() = engine.sync(name).also { check(it.isSuccess) { "$name sync failed: ${it.exceptionOrNull()}" } }.getOrThrow()
+
+    suspend fun pending(): Int = outbox.observePendingCount().first()
+
+    fun close() = db.close()
+}
+
+internal class ReferenceDataSeeder(private val server: RealServerHarness) {
+    private val http = OkHttpClient()
+    private val json = Json { ignoreUnknownKeys = true }
+
+    private val token: String = runBlocking {
+        val client = server.newApiClient()
+        val login = client.login(server.username, server.password).getOrThrow()
+        client.issueDeviceToken("e2e-seeder", login.sessionCookie).getOrThrow().token
+    }
+
+    fun createLocation(name: String): String = create("api/v1/locations", buildJsonObject { put("name", name) })
+
+    fun createLabel(name: String): String =
+        create("api/v1/labels", buildJsonObject { put("name", name); put("color", "#336699") })
+
+    private fun create(path: String, body: kotlinx.serialization.json.JsonObject): String {
+        val req = Request.Builder().url(server.baseUrl.resolve(path)!!)
+            .header("Authorization", "Bearer $token")
+            .post(body.toString().toRequestBody("application/json".toMediaType()))
+            .build()
+        return http.newCall(req).execute().use {
+            val text = it.body!!.string()
+            check(it.code == 201) { "POST $path answered ${it.code}" }
+            json.parseToJsonElement(text).jsonObject.getValue("id").jsonPrimitive.content
+        }.also { http.connectionPool.evictAll(); http.dispatcher.executorService.shutdown() }
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/connect/ConnectViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/connect/ConnectViewModelTest.kt
new file mode 100644
index 0000000..0630e01
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/connect/ConnectViewModelTest.kt
@@ -0,0 +1,216 @@
+package dev.hho.android.ui.connect
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.PreferenceDataStoreFactory
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import dev.hho.android.data.apiclient.HhoApiClient
+import dev.hho.android.data.network.ClientVersionInterceptor
+import dev.hho.android.data.network.InstanceUrlNormalization
+import dev.hho.android.data.network.InstanceUrlNormalizer
+import dev.hho.android.data.settings.SettingsKeys
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import okhttp3.OkHttpClient
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import java.io.File
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class ConnectViewModelTest {
+
+    private val server = MockWebServer()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+        server.shutdown()
+    }
+
+    private fun tempDataStore(): DataStore<Preferences> {
+        val file = File.createTempFile("connect-viewmodel-test", ".preferences_pb")
+        file.deleteOnExit()
+        return PreferenceDataStoreFactory.create(produceFile = { file })
+    }
+
+    private fun apiClient(): HhoApiClient =
+        HhoApiClient(OkHttpClient(), OkHttpClient.Builder().addInterceptor(ClientVersionInterceptor()).build())
+
+    private suspend fun storedUrl(dataStore: DataStore<Preferences>): String? =
+        dataStore.data.map { it[SettingsKeys.INSTANCE_BASE_URL] }.first()
+
+    private val statusOkBody = """{"status":"ok","version":"1.0.0","schema_version":3}"""
+
+    @Test
+    fun `success persists the normalised url and emits the navigate-on event`() =
+        runTest {
+            server.enqueue(MockResponse().setResponseCode(200).setBody(statusOkBody))
+            val dataStore = tempDataStore()
+            val viewModel = ConnectViewModel(dataStore, apiClient())
+            val candidate = server.url("/").toString()
+
+            val expected = (InstanceUrlNormalizer.normalize(candidate) as InstanceUrlNormalization.Valid).url.toString()
+
+            viewModel.connect(candidate)
+
+            assertEquals(expected, storedUrl(dataStore))
+            assertEquals(Unit, viewModel.connected.first())
+            assertNull(viewModel.uiState.value.errorMessage)
+            assertTrue(!viewModel.uiState.value.isChecking)
+        }
+
+    @Test
+    fun `a prefix instance validates against its own prefixed status path and persists the prefix`() =
+        runTest {
+            server.enqueue(MockResponse().setResponseCode(200).setBody(statusOkBody))
+            val dataStore = tempDataStore()
+            val viewModel = ConnectViewModel(dataStore, apiClient())
+            val candidate = server.url("/hho").toString()
+            val expected = (InstanceUrlNormalizer.normalize(candidate) as InstanceUrlNormalization.Valid).url.toString()
+
+            viewModel.connect(candidate)
+
+            assertEquals("/hho/api/v1/status", server.takeRequest().path)
+            assertEquals(expected, storedUrl(dataStore))
+            assertEquals(Unit, viewModel.connected.first())
+        }
+
+    @Test
+    fun `unreachable host fails with a network error and leaves DataStore unchanged`() =
+        runTest {
+            val dataStore = tempDataStore()
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "https://already-configured.example.com" }
+            val before = storedUrl(dataStore)
+            val viewModel = ConnectViewModel(dataStore, apiClient())
+            val candidate = server.url("/").toString()
+            server.shutdown()
+
+            viewModel.connect(candidate)
+
+            assertEquals(before, storedUrl(dataStore))
+            assertTrue(viewModel.uiState.value.errorMessage!!.contains("Couldn't reach"))
+        }
+
+    @Test
+    fun `a 200 from a non-HHO server fails as unexpected-payload and leaves DataStore unchanged`() =
+        runTest {
+            server.enqueue(
+                MockResponse().setResponseCode(200)
+                    .setHeader("Content-Type", "text/html")
+                    .setBody("<html>hello, wrong server</html>"),
+            )
+            val dataStore = tempDataStore()
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "https://already-configured.example.com" }
+            val before = storedUrl(dataStore)
+            val viewModel = ConnectViewModel(dataStore, apiClient())
+
+            viewModel.connect(server.url("/").toString())
+
+            assertEquals(before, storedUrl(dataStore))
+            assertTrue(viewModel.uiState.value.errorMessage!!.contains("doesn't look like an HHO server"))
+        }
+
+    @Test
+    fun `a 200 with a JSON body missing the required StatusResponse fields fails and leaves DataStore unchanged`() =
+        runTest {
+            server.enqueue(MockResponse().setResponseCode(200).setBody("""{"hello":"world"}"""))
+            val dataStore = tempDataStore()
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "https://already-configured.example.com" }
+            val before = storedUrl(dataStore)
+            val viewModel = ConnectViewModel(dataStore, apiClient())
+
+            viewModel.connect(server.url("/").toString())
+
+            assertEquals(before, storedUrl(dataStore))
+            assertTrue(viewModel.uiState.value.errorMessage!!.contains("doesn't look like an HHO server"))
+        }
+
+    @Test
+    fun `426 fails with an upgrade-required message and leaves DataStore unchanged`() =
+        runTest {
+            server.enqueue(
+                MockResponse().setResponseCode(426).setBody(
+                    """{"type":"urn:hho:problem:upgrade-required","title":"Upgrade Required",""" +
+                        """"status":426,"minimum_version":"2.0.0"}""",
+                ),
+            )
+            val dataStore = tempDataStore()
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "https://already-configured.example.com" }
+            val before = storedUrl(dataStore)
+            val viewModel = ConnectViewModel(dataStore, apiClient())
+
+            viewModel.connect(server.url("/").toString())
+
+            assertEquals(before, storedUrl(dataStore))
+            assertTrue(viewModel.uiState.value.errorMessage!!.contains("2.0.0"))
+        }
+
+    @Test
+    fun `404 fails with a path-prefix hint and leaves DataStore unchanged`() =
+        runTest {
+            server.enqueue(MockResponse().setResponseCode(404))
+            val dataStore = tempDataStore()
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "https://already-configured.example.com" }
+            val before = storedUrl(dataStore)
+            val viewModel = ConnectViewModel(dataStore, apiClient())
+
+            viewModel.connect(server.url("/").toString())
+
+            assertEquals(before, storedUrl(dataStore))
+            assertTrue(viewModel.uiState.value.errorMessage!!.contains("reverse-proxy"))
+        }
+
+    @Test
+    fun `an invalid url is rejected before ever reaching the network and leaves DataStore unchanged`() =
+        runTest {
+            val dataStore = tempDataStore()
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "https://already-configured.example.com" }
+            val before = storedUrl(dataStore)
+            val viewModel = ConnectViewModel(dataStore, apiClient())
+
+            viewModel.connect("not-a-url-at-all")
+
+            assertEquals(before, storedUrl(dataStore))
+            assertEquals(0, server.requestCount)
+            assertTrue(viewModel.uiState.value.errorMessage!!.isNotBlank())
+        }
+
+    @Test
+    fun `the url field is pre-filled from a previously stored instance url`() =
+        runTest {
+            val dataStore = tempDataStore()
+            dataStore.edit { it[SettingsKeys.INSTANCE_BASE_URL] = "https://stored.example.com" }
+            val viewModel = ConnectViewModel(dataStore, apiClient())
+
+            viewModel.prefillStoredUrl()
+
+            assertEquals("https://stored.example.com", viewModel.uiState.value.urlInput)
+        }
+
+    @Test
+    fun `the url field stays blank when nothing is stored yet`() =
+        runTest {
+            val viewModel = ConnectViewModel(tempDataStore(), apiClient())
+
+            viewModel.prefillStoredUrl()
+
+            assertEquals("", viewModel.uiState.value.urlInput)
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/deeplink/DeepLinkParserTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/deeplink/DeepLinkParserTest.kt
new file mode 100644
index 0000000..16ba975
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/deeplink/DeepLinkParserTest.kt
@@ -0,0 +1,50 @@
+package dev.hho.android.ui.deeplink
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class DeepLinkParserTest {
+    private val id = "0190a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5b"
+
+    @Test fun validUuidOnHttps() =
+        assertEquals(ItemDeepLink.ById(id), parseItemDeepLink("https://hho.example.com/i/$id"))
+
+    @Test fun validUuidOnLanHttpWithPort() =
+        assertEquals(ItemDeepLink.ById(id), parseItemDeepLink("http://192.168.1.5:7745/i/$id"))
+
+    @Test fun uppercaseUuidIsLowercased() =
+        assertEquals(ItemDeepLink.ById(id), parseItemDeepLink("https://h/i/${id.uppercase()}"))
+
+    @Test fun trailingSlashQueryAndFragmentIgnored() {
+        assertEquals(ItemDeepLink.ById(id), parseItemDeepLink("https://h/i/$id/"))
+        assertEquals(ItemDeepLink.ById(id), parseItemDeepLink("https://h/i/$id?utm=1&x=/y"))
+        assertEquals(ItemDeepLink.ById(id), parseItemDeepLink("https://h/i/$id/?a=b#frag"))
+    }
+
+    @Test fun nonUuidTokenIsShortCode() =
+        assertEquals(ItemDeepLink.ByShortCode("AB-12"), parseItemDeepLink("https://h/i/AB-12"))
+
+    @Test fun malformedUuidFallsBackToShortCodeLikeServer() =
+        assertEquals(
+            ItemDeepLink.ByShortCode("0190a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5"),
+            parseItemDeepLink("https://h/i/0190a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5"),
+        )
+
+    @Test fun wrongPathsRejected() {
+        listOf(
+            "https://h/items/$id", "https://h/x/i/$id", "https://h/i", "https://h/i/", "https://h/i//",
+            "https://h/i/$id/extra", "https://h/I/$id", "https://h/api/v1/i/$id", "https://h/",
+        ).forEach { assertNull(it, parseItemDeepLink(it)) }
+    }
+
+    @Test fun badSchemeOrHostRejected() {
+        listOf("ftp://h/i/$id", "hho://h/i/$id", "/i/$id", "https:///i/$id", "i/$id")
+            .forEach { assertNull(it, parseItemDeepLink(it)) }
+    }
+
+    @Test fun garbageRejected() {
+        listOf(null, "", "   ", "https://h/i/a b", "https://h/i/%2F", "ht tp://x", "https://h/i/${"a".repeat(129)}")
+            .forEach { assertNull(it, parseItemDeepLink(it)) }
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/deeplink/DeepLinkResolverTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/deeplink/DeepLinkResolverTest.kt
new file mode 100644
index 0000000..fbc3a78
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/deeplink/DeepLinkResolverTest.kt
@@ -0,0 +1,69 @@
+package dev.hho.android.ui.deeplink
+
+import android.content.Intent
+import android.net.Uri
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class DeepLinkResolverTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var resolver: DeepLinkResolver
+    private val id = "0190a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5b"
+
+    private fun item(id: String, code: String?) = ItemEntity(
+        id = id, groupChangeSeq = 1, name = "n", description = null, locationId = null,
+        quantity = null, shortCode = code, createdAt = null, updatedAt = null, version = null,
+    )
+
+    @Before fun setUp() {
+        db = inMemoryHhoDatabase()
+        resolver = DeepLinkResolver(db.itemDao())
+    }
+
+    @After fun tearDown() = db.close()
+
+    @Test fun knownIdResolves() = runTest {
+        db.itemDao().upsert(item(id, "AB-1"))
+        assertEquals(DeepLinkResolution.Found(id), resolver.resolve(ItemDeepLink.ById(id)))
+    }
+
+    @Test fun shortCodeResolvesExactly() = runTest {
+        db.itemDao().upsert(item(id, "AB-1"))
+        assertEquals(DeepLinkResolution.Found(id), resolver.resolve(ItemDeepLink.ByShortCode("AB-1")))
+        assertEquals(
+            DeepLinkResolution.NotFound(ItemDeepLink.ByShortCode("ab-1")),
+            resolver.resolve(ItemDeepLink.ByShortCode("ab-1")),
+        )
+    }
+
+    @Test fun unknownTokenIsNotFound() = runTest {
+        db.itemDao().upsert(item("other", null))
+        val link = ItemDeepLink.ById(id)
+        assertEquals(DeepLinkResolution.NotFound(link), resolver.resolve(link))
+    }
+
+    @Test fun manifestFilterMatchesArbitraryHostsAndOnlyItemPaths() {
+        val pm = ApplicationProvider.getApplicationContext<android.content.Context>().packageManager
+        fun matches(url: String) = pm.resolveActivity(
+            Intent(Intent.ACTION_VIEW, Uri.parse(url)).addCategory(Intent.CATEGORY_BROWSABLE), 0,
+        )
+        assertNotNull(matches("https://hho.example.com/i/$id"))
+        assertNotNull(matches("http://192.168.1.5:7745/i/$id"))
+        assertNull(matches("https://hho.example.com/items/$id"))
+        assertNull(matches("ftp://hho.example.com/i/$id"))
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ItemDetailViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ItemDetailViewModelTest.kt
new file mode 100644
index 0000000..6a1cb82
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ItemDetailViewModelTest.kt
@@ -0,0 +1,466 @@
+package dev.hho.android.ui.items
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemCustomFieldEntity
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemIdentificationEntity
+import dev.hho.android.data.room.ItemLabelEntity
+import dev.hho.android.data.room.LabelEntity
+import dev.hho.android.data.room.LocationEntity
+import dev.hho.android.data.room.PurchasedFromBlockEntity
+import dev.hho.android.data.room.SoldToBlockEntity
+import dev.hho.android.data.room.StockAdjustmentEntity
+import dev.hho.android.data.room.WarrantyBlockEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.math.BigDecimal
+import java.time.LocalDate
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ItemDetailViewModelTest {
+
+    private lateinit var db: HhoDatabase
+    private lateinit var viewModel: ItemDetailViewModel
+    private val viewModels = ViewModelTracker()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+        db = inMemoryHhoDatabase()
+        viewModel = viewModels.track(ItemDetailViewModel(
+            itemDao = db.itemDao(),
+            itemLabelDao = db.itemLabelDao(),
+            labelDao = db.labelDao(),
+            locationDao = db.locationDao(),
+            warrantyBlockDao = db.warrantyBlockDao(),
+            soldToBlockDao = db.soldToBlockDao(),
+            purchasedFromBlockDao = db.purchasedFromBlockDao(),
+            itemIdentificationDao = db.itemIdentificationDao(),
+            itemCustomFieldDao = db.itemCustomFieldDao(),
+            stockAdjustmentDao = db.stockAdjustmentDao(),
+            db = db,
+        ))
+    }
+
+    @After
+    fun tearDown() {
+        viewModels.cancelAll()
+        db.close()
+        Dispatchers.resetMain()
+    }
+
+    private fun itemFixture(
+        id: String,
+        name: String,
+        locationId: String? = null,
+        quantity: Long? = 2L,
+        shortCode: String? = "SC-1",
+        description: String? = "A cordless drill",
+    ) = ItemEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        name = name,
+        description = description,
+        locationId = locationId,
+        quantity = quantity,
+        shortCode = shortCode,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+    private fun locationFixture(id: String, name: String) =
+        LocationEntity(
+            id = id,
+            groupChangeSeq = 1L,
+            name = name,
+            parentId = null,
+            createdAt = 1L,
+            updatedAt = 1L,
+            version = 1L,
+        )
+
+    private fun labelFixture(id: String, name: String) =
+        LabelEntity(
+            id = id,
+            groupChangeSeq = 1L,
+            name = name,
+            color = "#ffffff",
+            createdAt = 1L,
+            updatedAt = 1L,
+            version = 1L,
+        )
+
+    private fun itemLabelFixture(id: String, itemId: String, labelId: String) =
+        ItemLabelEntity(id = id, groupChangeSeq = 1L, itemId = itemId, labelId = labelId)
+
+    private fun warrantyFixture(
+        id: String,
+        itemId: String,
+        isLifetime: Boolean = false,
+        holder: String? = "Jane Doe",
+        provider: String? = "Acme Warranties",
+        startsOn: LocalDate? = LocalDate.of(2024, 1, 1),
+        expiresOn: LocalDate? = LocalDate.of(2026, 1, 1),
+        notes: String? = "Keep receipt",
+    ) = WarrantyBlockEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        isLifetime = isLifetime,
+        holder = holder,
+        provider = provider,
+        startsOn = startsOn,
+        expiresOn = expiresOn,
+        notes = notes,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+    private fun soldToFixture(
+        id: String,
+        itemId: String,
+        salePriceMinor: Long = 5_000L,
+        buyerName: String? = "Alex Buyer",
+        soldOn: LocalDate? = LocalDate.of(2024, 6, 1),
+        notes: String? = "Sold at yard sale",
+    ) = SoldToBlockEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        salePriceMinor = salePriceMinor,
+        buyerName = buyerName,
+        soldOn = soldOn,
+        notes = notes,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+    private fun purchasedFromFixture(
+        id: String,
+        itemId: String,
+        purchasePriceMinor: Long = 12_000L,
+        vendor: String? = "Hardware Store",
+        purchasedOn: LocalDate? = LocalDate.of(2023, 3, 1),
+        orderReference: String? = "PO-42",
+        notes: String? = "Bought on sale",
+    ) = PurchasedFromBlockEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        purchasePriceMinor = purchasePriceMinor,
+        vendor = vendor,
+        purchasedOn = purchasedOn,
+        orderReference = orderReference,
+        notes = notes,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+    private fun identifierFixture(id: String, itemId: String, kind: String = "barcode", value: String = "012345") =
+        ItemIdentificationEntity(
+            id = id,
+            groupChangeSeq = 1L,
+            itemId = itemId,
+            kind = kind,
+            value = value,
+            createdAt = 1L,
+            updatedAt = 1L,
+            version = 1L,
+        )
+
+    private fun customFieldFixture(
+        id: String,
+        itemId: String,
+        name: String,
+        fieldType: String,
+        textValue: String? = null,
+        numberValue: BigDecimal? = null,
+        boolValue: Boolean? = null,
+        dateValue: LocalDate? = null,
+    ) = ItemCustomFieldEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        name = name,
+        fieldType = fieldType,
+        fieldDefId = null,
+        textValue = textValue,
+        numberValue = numberValue,
+        boolValue = boolValue,
+        dateValue = dateValue,
+        createdAt = 1L,
+        updatedAt = 1L,
+        version = 1L,
+    )
+
+    private fun stockAdjustmentFixture(
+        id: String,
+        itemId: String,
+        delta: Long,
+        resultingQuantity: Long,
+        reason: String? = "manual",
+        note: String? = null,
+        createdAt: Long = 1L,
+    ) = StockAdjustmentEntity(
+        id = id,
+        groupChangeSeq = 1L,
+        itemId = itemId,
+        delta = delta,
+        resultingQuantity = resultingQuantity,
+        reason = reason,
+        note = note,
+        createdAt = createdAt,
+        updatedAt = createdAt,
+        version = 1L,
+    )
+
+    @Test
+    fun `shows the requested item's core fields, location and labels`() = runTest {
+        db.locationDao().upsert(locationFixture("loc-1", "Garage"))
+        db.labelDao().upsert(labelFixture("label-1", "Power tools"))
+        db.labelDao().upsert(labelFixture("label-2", "Fragile"))
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill", locationId = "loc-1"))
+        db.itemLabelDao().upsert(itemLabelFixture("il-1", itemId = "item-1", labelId = "label-1"))
+        db.itemLabelDao().upsert(itemLabelFixture("il-2", itemId = "item-1", labelId = "label-2"))
+
+        viewModel.loadItem("item-1")
+        val state = viewModel.uiState.first { it is ItemDetailUiState.Data } as ItemDetailUiState.Data
+
+        assertEquals(
+            ItemDetailData(
+                id = "item-1",
+                name = "Drill",
+                description = "A cordless drill",
+                quantity = 2L,
+                shortCode = "SC-1",
+                locationName = "Garage",
+                labelNames = listOf("Power tools", "Fragile"),
+                warranty = null,
+                soldTo = null,
+                purchasedFrom = null,
+                identifiers = emptyList(),
+                customFields = emptyList(),
+                stockAdjustments = emptyList(),
+            ),
+            state.item,
+        )
+    }
+
+    @Test
+    fun `renders the warranty, sold_to and purchased_from blocks when present`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        db.warrantyBlockDao().upsert(warrantyFixture("warranty-1", itemId = "item-1"))
+        db.soldToBlockDao().upsert(soldToFixture("sold-1", itemId = "item-1"))
+        db.purchasedFromBlockDao().upsert(purchasedFromFixture("purchased-1", itemId = "item-1"))
+
+        viewModel.loadItem("item-1")
+        val state = viewModel.uiState.first { it is ItemDetailUiState.Data } as ItemDetailUiState.Data
+
+        assertEquals(
+            WarrantyBlockData(
+                isLifetime = false,
+                holder = "Jane Doe",
+                provider = "Acme Warranties",
+                startsOn = LocalDate.of(2024, 1, 1),
+                expiresOn = LocalDate.of(2026, 1, 1),
+                notes = "Keep receipt",
+            ),
+            state.item.warranty,
+        )
+        assertEquals(
+            SoldToBlockData(
+                salePriceMinor = 5_000L,
+                buyerName = "Alex Buyer",
+                soldOn = LocalDate.of(2024, 6, 1),
+                notes = "Sold at yard sale",
+            ),
+            state.item.soldTo,
+        )
+        assertEquals(
+            PurchasedFromBlockData(
+                purchasePriceMinor = 12_000L,
+                vendor = "Hardware Store",
+                purchasedOn = LocalDate.of(2023, 3, 1),
+                orderReference = "PO-42",
+                notes = "Bought on sale",
+            ),
+            state.item.purchasedFrom,
+        )
+    }
+
+    @Test
+    fun `absent warranty, sold_to and purchased_from blocks render as null, not empty placeholders`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+
+        viewModel.loadItem("item-1")
+        val state = viewModel.uiState.first { it is ItemDetailUiState.Data } as ItemDetailUiState.Data
+
+        assertNull(state.item.warranty)
+        assertNull(state.item.soldTo)
+        assertNull(state.item.purchasedFrom)
+    }
+
+    @Test
+    fun `renders identifiers with their type and value`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        db.itemIdentificationDao().upsert(identifierFixture("id-1", itemId = "item-1", kind = "barcode", value = "111"))
+        db.itemIdentificationDao().upsert(identifierFixture("id-2", itemId = "item-1", kind = "serial", value = "SN-9"))
+
+        viewModel.loadItem("item-1")
+        val state = viewModel.uiState.first { it is ItemDetailUiState.Data } as ItemDetailUiState.Data
+
+        assertEquals(
+            listOf(
+                IdentifierData(kind = "barcode", value = "111"),
+                IdentifierData(kind = "serial", value = "SN-9"),
+            ),
+            state.item.identifiers.sortedBy { it.kind },
+        )
+    }
+
+    @Test
+    fun `a custom field of each type maps to the right typed value`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        db.itemCustomFieldDao().upsert(
+            customFieldFixture("cf-text", itemId = "item-1", name = "Color", fieldType = "text", textValue = "Red"),
+        )
+        db.itemCustomFieldDao().upsert(
+            customFieldFixture(
+                "cf-number",
+                itemId = "item-1",
+                name = "Weight (kg)",
+                fieldType = "number",
+                numberValue = BigDecimal("1.50"),
+            ),
+        )
+        db.itemCustomFieldDao().upsert(
+            customFieldFixture("cf-bool", itemId = "item-1", name = "Cordless", fieldType = "boolean", boolValue = true),
+        )
+        db.itemCustomFieldDao().upsert(
+            customFieldFixture(
+                "cf-date",
+                itemId = "item-1",
+                name = "Last serviced",
+                fieldType = "date",
+                dateValue = LocalDate.of(2025, 5, 1),
+            ),
+        )
+
+        viewModel.loadItem("item-1")
+        val state = viewModel.uiState.first { it is ItemDetailUiState.Data } as ItemDetailUiState.Data
+
+        val byName = state.item.customFields.associateBy { it.name }
+        assertEquals(CustomFieldValue.Text("Red"), byName.getValue("Color").value)
+        assertEquals(CustomFieldValue.Number(BigDecimal("1.50")), byName.getValue("Weight (kg)").value)
+        assertEquals(CustomFieldValue.Bool(true), byName.getValue("Cordless").value)
+        assertEquals(CustomFieldValue.Date(LocalDate.of(2025, 5, 1)), byName.getValue("Last serviced").value)
+    }
+
+    @Test
+    fun `renders stock adjustments as history`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        db.stockAdjustmentDao().upsert(
+            stockAdjustmentFixture("adj-1", itemId = "item-1", delta = 5L, resultingQuantity = 5L, createdAt = 1L),
+        )
+        db.stockAdjustmentDao().upsert(
+            stockAdjustmentFixture("adj-2", itemId = "item-1", delta = -2L, resultingQuantity = 3L, createdAt = 2L),
+        )
+
+        viewModel.loadItem("item-1")
+        val state = viewModel.uiState.first { it is ItemDetailUiState.Data } as ItemDetailUiState.Data
+
+        assertEquals(
+            listOf(
+                StockAdjustmentData(delta = 5L, resultingQuantity = 5L, reason = "manual", note = null, createdAt = 1L),
+                StockAdjustmentData(delta = -2L, resultingQuantity = 3L, reason = "manual", note = null, createdAt = 2L),
+            ),
+            state.item.stockAdjustments,
+        )
+    }
+
+    @Test
+    fun `absent identifiers, custom fields and stock adjustments render as empty lists`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+
+        viewModel.loadItem("item-1")
+        val state = viewModel.uiState.first { it is ItemDetailUiState.Data } as ItemDetailUiState.Data
+
+        assertTrue(state.item.identifiers.isEmpty())
+        assertTrue(state.item.customFields.isEmpty())
+        assertTrue(state.item.stockAdjustments.isEmpty())
+    }
+
+    @Test
+    fun `inserting a warranty row after load shows it live`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        viewModel.loadItem("item-1")
+        val before = viewModel.uiState.first { it is ItemDetailUiState.Data } as ItemDetailUiState.Data
+        assertNull(before.item.warranty)
+
+        db.warrantyBlockDao().upsert(warrantyFixture("warranty-1", itemId = "item-1", holder = "New Holder"))
+
+        val after = viewModel.uiState.first {
+            it is ItemDetailUiState.Data && it.item.warranty != null
+        } as ItemDetailUiState.Data
+        assertEquals("New Holder", after.item.warranty?.holder)
+    }
+
+    @Test
+    fun `shows a different item after loadItem is called again with a new id`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        db.itemDao().upsert(itemFixture("item-2", name = "Saw"))
+
+        viewModel.loadItem("item-1")
+        val first = viewModel.uiState.first { it is ItemDetailUiState.Data } as ItemDetailUiState.Data
+        assertEquals("Drill", first.item.name)
+
+        viewModel.loadItem("item-2")
+        val second = viewModel.uiState.first {
+            it is ItemDetailUiState.Data && it.item.id == "item-2"
+        } as ItemDetailUiState.Data
+        assertEquals("Saw", second.item.name)
+    }
+
+    @Test
+    fun `a missing id gives a not-found state, not a crash`() = runTest {
+        viewModel.loadItem("does-not-exist")
+
+        val state = viewModel.uiState.first { it !is ItemDetailUiState.Loading }
+
+        assertEquals(ItemDetailUiState.NotFound, state)
+    }
+
+    @Test
+    fun `an item deleted after being shown transitions live from Data to NotFound`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        viewModel.loadItem("item-1")
+        val before = viewModel.uiState.first { it is ItemDetailUiState.Data }
+        assertEquals(ItemDetailData::class, (before as ItemDetailUiState.Data).item::class)
+
+        db.itemDao().deleteById("item-1")
+
+        val after = viewModel.uiState.first { it is ItemDetailUiState.NotFound }
+        assertEquals(ItemDetailUiState.NotFound, after)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ItemEditActionsViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ItemEditActionsViewModelTest.kt
new file mode 100644
index 0000000..e007f08
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ItemEditActionsViewModelTest.kt
@@ -0,0 +1,319 @@
+package dev.hho.android.ui.items
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.outbox.LocalMutation
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemLabelEntity
+import dev.hho.android.data.room.LabelEntity
+import dev.hho.android.data.room.LocationEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.domain.EditRepository
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import kotlinx.coroutines.withTimeout
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonPrimitive
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ItemEditActionsViewModelTest {
+
+    private lateinit var db: HhoDatabase
+    private var syncCalls = 0
+    private val viewModels = ViewModelTracker()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+        db = inMemoryHhoDatabase()
+        runBlocking {
+            db.itemDao().upsert(ItemEntity("i1", 5, "Drill", "d", "loc-garage", 5, "AB12", 1, 1, 4))
+            db.locationDao().upsertAll(
+                listOf(
+                    LocationEntity("loc-house", 1, "House", null, 1, 1, 1),
+                    LocationEntity("loc-garage", 1, "Garage", "loc-house", 1, 1, 2),
+                    LocationEntity("loc-shed", 1, "Shed", null, 1, 1, 1),
+                ),
+            )
+            db.labelDao().upsertAll(
+                listOf(
+                    LabelEntity("lab-a", 1, "Fragile", "#f00", 1, 1, 1),
+                    LabelEntity("lab-b", 1, "Power tools", "#0f0", 1, 1, 1),
+                ),
+            )
+            db.itemLabelDao().upsert(ItemLabelEntity("edge-a", 1, "i1", "lab-a"))
+        }
+    }
+
+    @After
+    fun tearDown() {
+        viewModels.cancelAll()
+        db.close()
+        Dispatchers.resetMain()
+    }
+
+    private fun editViewModel(): ItemEditActionsViewModel {
+        val ids = UuidV7Generator()
+        val repo = EditRepository(db, OutboxRepository(db, ids), ids) { syncCalls++ }
+        return viewModels.track(
+            ItemEditActionsViewModel(repo, db.itemDao(), db.itemLabelDao(), db.labelDao(), db.locationDao()),
+        )
+    }
+
+    private fun detailViewModel() = viewModels.track(
+        ItemDetailViewModel(
+            itemDao = db.itemDao(),
+            itemLabelDao = db.itemLabelDao(),
+            labelDao = db.labelDao(),
+            locationDao = db.locationDao(),
+            warrantyBlockDao = db.warrantyBlockDao(),
+            soldToBlockDao = db.soldToBlockDao(),
+            purchasedFromBlockDao = db.purchasedFromBlockDao(),
+            itemIdentificationDao = db.itemIdentificationDao(),
+            itemCustomFieldDao = db.itemCustomFieldDao(),
+            stockAdjustmentDao = db.stockAdjustmentDao(),
+            db = db,
+        ),
+    )
+
+    private fun await(condition: () -> Boolean) = runBlocking {
+        withTimeout(10_000) { while (!condition()) kotlinx.coroutines.delay(10) }
+    }
+
+    private fun outbox() = runBlocking { db.outboxDao().getAllOrdered() }
+
+    @Test
+    fun optionsShowLocationPathsAndSplitLabels() {
+        val vm = editViewModel()
+        vm.load("i1")
+        val collector = CoroutineScope(Dispatchers.Default).launch { vm.options.collect { } }
+        try {
+            await { vm.options.value.locations.size == 3 && vm.options.value.attachedLabels.isNotEmpty() }
+            val o = vm.options.value
+            assertEquals(listOf("House", "House / Garage", "Shed"), o.locations.map { it.path })
+            assertEquals("loc-garage", o.currentLocationId)
+            assertEquals(listOf("lab-a"), o.attachedLabels.map { it.id })
+            assertEquals(listOf("lab-b"), o.availableLabels.map { it.id })
+        } finally {
+            collector.cancel()
+        }
+    }
+
+    @Test
+    fun moveToLocationQueuesUpsertWithBaseVersionAndCompletes() {
+        val vm = editViewModel()
+        vm.move("i1", "loc-shed")
+        await { vm.state.value.completed }
+
+        assertEquals(1, syncCalls)
+        val row = outbox().single()
+        val m = LocalMutation.from(row)
+        assertEquals("item", row.entityType)
+        assertEquals("i1", row.entityId)
+        assertEquals(4L, m.baseVersion)
+        assertEquals("loc-shed", (m.fields["location_id"] as JsonPrimitive).content)
+        assertEquals("loc-shed", runBlocking { db.itemDao().getById("i1") }!!.locationId)
+    }
+
+    @Test
+    fun moveToNoLocationSendsJsonNullAndClearsMirror() {
+        val vm = editViewModel()
+        vm.move("i1", null)
+        await { vm.state.value.completed }
+
+        val m = LocalMutation.from(outbox().single())
+        assertEquals(JsonNull, m.fields["location_id"])
+        assertEquals(4L, m.baseVersion)
+        assertNull(runBlocking { db.itemDao().getById("i1") }!!.locationId)
+    }
+
+    @Test
+    fun moveToUnknownLocationReportsNotFoundAndWritesNothing() {
+        val vm = editViewModel()
+        vm.move("i1", "ghost")
+        await { vm.state.value.error != null }
+
+        assertEquals("That location is no longer on this device.", vm.state.value.error)
+        assertFalse(vm.state.value.completed)
+        assertTrue(outbox().isEmpty())
+        assertEquals(0, syncCalls)
+    }
+
+    @Test
+    fun moveOfUnknownItemReportsNotFound() {
+        val vm = editViewModel()
+        vm.move("ghost", "loc-shed")
+        await { vm.state.value.error != null }
+        assertEquals("This item is no longer on this device.", vm.state.value.error)
+    }
+
+    @Test
+    fun attachLabelUpsertsEdgeAndDoesNotCloseTheEditor() {
+        val vm = editViewModel()
+        vm.attach("i1", "lab-b")
+        await { !vm.state.value.submitting && outbox().isNotEmpty() }
+
+        assertFalse(vm.state.value.completed)
+        assertNull(vm.state.value.error)
+        val row = outbox().single()
+        val m = LocalMutation.from(row)
+        assertEquals("item_label", row.entityType)
+        assertEquals("i1", (m.fields["item_id"] as JsonPrimitive).content)
+        assertEquals("lab-b", (m.fields["label_id"] as JsonPrimitive).content)
+        val edges = runBlocking { db.itemLabelDao().observeByItemId("i1").first() }
+        assertEquals(setOf("lab-a", "lab-b"), edges.map { it.labelId }.toSet())
+    }
+
+    @Test
+    fun attachingAnAlreadyAttachedLabelIsIdempotent() {
+        val vm = editViewModel()
+        vm.attach("i1", "lab-a")
+        await { !vm.state.value.submitting }
+
+        assertNull(vm.state.value.error)
+        assertTrue(outbox().isEmpty())
+        assertEquals(0, syncCalls)
+    }
+
+    @Test
+    fun attachUnknownLabelReportsNotFound() {
+        val vm = editViewModel()
+        vm.attach("i1", "ghost")
+        await { vm.state.value.error != null }
+        assertEquals("That label is no longer on this device.", vm.state.value.error)
+        assertTrue(outbox().isEmpty())
+    }
+
+    @Test
+    fun detachLabelQueuesEdgeDeleteAndRemovesFromMirror() {
+        val vm = editViewModel()
+        vm.detach("i1", "lab-a")
+        await { !vm.state.value.submitting && outbox().isNotEmpty() }
+
+        val row = outbox().single()
+        assertEquals("item_label", row.entityType)
+        assertEquals("edge-a", row.entityId)
+        assertEquals("delete", row.op)
+        assertEquals(1, syncCalls)
+        val edges = runBlocking { db.itemLabelDao().observeByItemId("i1").first() }
+        assertTrue(edges.isEmpty())
+    }
+
+    @Test
+    fun detachOfUnattachedLabelReportsNotFound() {
+        val vm = editViewModel()
+        vm.detach("i1", "lab-b")
+        await { vm.state.value.error != null }
+        assertEquals("That label is no longer on this device.", vm.state.value.error)
+        assertTrue(outbox().isEmpty())
+    }
+
+    @Test
+    fun submittingBlocksASecondEditUntilTheFirstFinishes() {
+        val dispatcher = StandardTestDispatcher()
+        Dispatchers.setMain(dispatcher)
+        val vm = editViewModel()
+
+        vm.move("i1", "loc-shed")
+        assertTrue(vm.state.value.submitting)
+        vm.move("i1", "loc-house")
+        await {
+            dispatcher.scheduler.advanceUntilIdle()
+            vm.state.value.completed
+        }
+
+        val rows = outbox()
+        assertEquals(1, rows.size)
+        assertEquals("loc-shed", (LocalMutation.from(rows.single()).fields["location_id"] as JsonPrimitive).content)
+    }
+
+    @Test
+    fun storageFailureIsReported() {
+        db.openHelper.writableDatabase.execSQL(
+            "CREATE TRIGGER fail_enqueue BEFORE INSERT ON outbox_mutation BEGIN SELECT RAISE(ABORT, 'boom'); END",
+        )
+        val vm = editViewModel()
+        vm.move("i1", "loc-shed")
+        await { vm.state.value.error != null }
+        assertEquals("Couldn't save the change. Please try again.", vm.state.value.error)
+        assertFalse(vm.state.value.submitting)
+        assertEquals("loc-garage", runBlocking { db.itemDao().getById("i1") }!!.locationId)
+    }
+
+    @Test
+    fun resetClearsErrorAndCompletion() {
+        val vm = editViewModel()
+        vm.move("ghost", null)
+        await { vm.state.value.error != null }
+        vm.reset()
+        assertEquals(ItemEditState(), vm.state.value)
+    }
+
+    @Test
+    fun detailUiStateReflectsMoveAndLabelChanges() {
+        val detail = detailViewModel()
+        detail.loadItem("i1")
+        val collector = CoroutineScope(Dispatchers.Default).launch { detail.uiState.collect { } }
+        fun data() = (detail.uiState.value as? ItemDetailUiState.Data)?.item
+        try {
+            await { data()?.locationName == "Garage" && data()?.labelNames == listOf("Fragile") }
+            val vm = editViewModel()
+            vm.move("i1", "loc-shed")
+            await { vm.state.value.completed }
+            await { data()?.locationName == "Shed" }
+            vm.reset()
+            vm.attach("i1", "lab-b")
+            await { data()?.labelNames?.toSet() == setOf("Fragile", "Power tools") }
+            await { !vm.state.value.submitting }
+            vm.detach("i1", "lab-a")
+            await { data()?.labelNames == listOf("Power tools") }
+            vm.reset()
+            vm.move("i1", null)
+            await { data()?.locationName == null }
+        } finally {
+            collector.cancel()
+        }
+    }
+
+    @Test
+    fun locationOptionsSurviveCyclesAndDanglingParents() {
+        val options = locationOptions(
+            listOf(
+                LocationEntity("a", 1, "A", "b", 1, 1, 1),
+                LocationEntity("b", 1, "B", "a", 1, 1, 1),
+                LocationEntity("c", 1, "C", "missing", 1, 1, 1),
+            ),
+        )
+        assertEquals(setOf("A / B", "B / A"), options.filter { it.id != "c" }.map { it.path }.toSet())
+        assertEquals(3, options.size)
+        assertEquals("C", options.first { it.id == "c" }.path)
+    }
+
+    @Test
+    fun filterLocationsMatchesPathCaseInsensitively() {
+        val all = listOf(LocationOption("1", "House / Garage"), LocationOption("2", "Shed"))
+        assertEquals(listOf("1"), filterLocations(all, " garage ").map { it.id })
+        assertEquals(2, filterLocations(all, "  ").size)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ItemFormViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ItemFormViewModelTest.kt
new file mode 100644
index 0000000..826ce48
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ItemFormViewModelTest.kt
@@ -0,0 +1,314 @@
+package dev.hho.android.ui.items
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.outbox.LocalMutation
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.LocationEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.domain.EditRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import kotlinx.coroutines.withTimeout
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonPrimitive
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ItemFormViewModelTest {
+
+    private lateinit var db: HhoDatabase
+    private var syncCalls = 0
+    private val viewModels = ViewModelTracker()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+        db = inMemoryHhoDatabase()
+        runBlocking {
+            db.itemDao().upsert(ItemEntity("i1", 5, "Drill", "old", "loc-garage", 5, "AB12", 1, 1, 4))
+            db.locationDao().upsertAll(
+                listOf(
+                    LocationEntity("loc-garage", 1, "Garage", null, 1, 1, 2),
+                    LocationEntity("loc-shed", 1, "Shed", null, 1, 1, 1),
+                ),
+            )
+        }
+    }
+
+    @After
+    fun tearDown() {
+        viewModels.cancelAll()
+        db.close()
+        Dispatchers.resetMain()
+    }
+
+    private fun vm(): ItemFormViewModel {
+        val ids = UuidV7Generator()
+        val repo = EditRepository(db, OutboxRepository(db, ids), ids) { syncCalls++ }
+        return viewModels.track(ItemFormViewModel(repo, db.itemDao(), db.locationDao()))
+    }
+
+    private fun await(condition: () -> Boolean) = runBlocking {
+        withTimeout(10_000) { while (!condition()) kotlinx.coroutines.delay(10) }
+    }
+
+    private fun outbox() = runBlocking { db.outboxDao().getAllOrdered() }
+
+    private fun ItemFormViewModel.fill(name: String, description: String = "", location: String? = null) {
+        onNameChange(name)
+        onDescriptionChange(description)
+        onLocationChange(location)
+    }
+
+    private fun str(m: LocalMutation, key: String) = (m.fields[key] as JsonPrimitive).content
+
+    @Test
+    fun createWithIdentifierAndLocationQueuesBothRowsInOneTransactionAndOneSync() {
+        val vm = vm()
+        vm.start(null)
+        vm.fill("  Hammer ", " claw ", "loc-shed")
+        vm.onIdentifierKindChange("serial")
+        vm.onIdentifierValueChange(" SN-1 ")
+        vm.submit()
+        await { vm.state.value.savedItemId != null }
+
+        val id = vm.state.value.savedItemId!!
+        val rows = outbox()
+        assertEquals(listOf("item", "item_identification"), rows.map { it.entityType })
+        val item = LocalMutation.from(rows[0])
+        assertEquals(id, rows[0].entityId)
+        assertEquals(0L, item.baseVersion)
+        assertEquals("Hammer", str(item, "name"))
+        assertEquals("claw", str(item, "description"))
+        assertEquals("loc-shed", str(item, "location_id"))
+        val ident = LocalMutation.from(rows[1])
+        assertEquals(0L, ident.baseVersion)
+        assertEquals(id, str(ident, "item_id"))
+        assertEquals("serial", str(ident, "kind"))
+        assertEquals("SN-1", str(ident, "value"))
+        assertEquals(1, syncCalls)
+        assertEquals("Hammer", runBlocking { db.itemDao().getById(id) }!!.name)
+    }
+
+    @Test
+    fun createWithNameOnlySendsNoDescriptionLocationOrIdentification() {
+        val vm = vm()
+        vm.start(null)
+        vm.fill("Saw")
+        vm.submit()
+        await { vm.state.value.savedItemId != null }
+
+        val row = outbox().single()
+        assertEquals("item", row.entityType)
+        assertEquals(setOf("name"), LocalMutation.from(row).fields.keys)
+        assertEquals(1, syncCalls)
+    }
+
+    @Test
+    fun failingIdentificationInsertRollsBackTheItemCreateToo() {
+        db.openHelper.writableDatabase.execSQL(
+            "CREATE TRIGGER fail_ident BEFORE INSERT ON item_identification BEGIN SELECT RAISE(ABORT, 'boom'); END",
+        )
+        val vm = vm()
+        vm.start(null)
+        vm.fill("Saw")
+        vm.onIdentifierValueChange("X1")
+        vm.submit()
+        await { vm.state.value.error != null }
+
+        assertEquals("Couldn't save the item. Please try again.", vm.state.value.error)
+        assertNull(vm.state.value.savedItemId)
+        assertTrue(outbox().isEmpty())
+        assertEquals(0, syncCalls)
+        assertEquals(1, runBlocking { db.itemDao().observeAll().first().size })
+    }
+
+    @Test
+    fun blankNameIsRejectedInlineAndWritesNothing() {
+        val vm = vm()
+        vm.start(null)
+        vm.fill("   ")
+        vm.onIdentifierValueChange("X1")
+        vm.submit()
+
+        assertEquals("Name is required.", vm.state.value.nameError)
+        assertTrue(!vm.state.value.submitting)
+        assertTrue(outbox().isEmpty())
+        assertEquals(0, syncCalls)
+        vm.onNameChange("A")
+        assertNull(vm.state.value.nameError)
+    }
+
+    @Test
+    fun invalidIdentifierKindIsRejectedAndWritesNothing() {
+        val vm = vm()
+        vm.start(null)
+        vm.fill("Saw")
+        vm.onIdentifierKindChange("isbn")
+        vm.onIdentifierValueChange("X1")
+        vm.submit()
+
+        assertNotNull(vm.state.value.identifierError)
+        assertTrue(outbox().isEmpty())
+        assertEquals(0, syncCalls)
+    }
+
+    @Test
+    fun everyOfferedIdentificationKindIsAcceptedByTheRepository() {
+        ITEM_FORM_IDENTIFICATION_KINDS.forEach { kind ->
+            val vm = vm()
+            vm.start(null)
+            vm.fill("Item $kind")
+            vm.onIdentifierKindChange(kind)
+            vm.onIdentifierValueChange("v-$kind")
+            vm.submit()
+            await { vm.state.value.savedItemId != null }
+        }
+        assertEquals(ITEM_FORM_IDENTIFICATION_KINDS.size * 2, outbox().size)
+    }
+
+    @Test
+    fun prefillPopulatesCreateStateAndIsSubmittedAsIdentification() {
+        val vm = vm()
+        vm.start(null, "serial", "SCAN-9")
+        assertEquals("serial", vm.state.value.identifierKind)
+        assertEquals("SCAN-9", vm.state.value.identifierValue)
+        vm.onNameChange("Scanned thing")
+        vm.submit()
+        await { vm.state.value.savedItemId != null }
+        val ident = LocalMutation.from(outbox().last())
+        assertEquals("SCAN-9", str(ident, "value"))
+        assertEquals("serial", str(ident, "kind"))
+    }
+
+    @Test
+    fun prefillWithUnknownOrMissingKindFallsBack() {
+        val a = vm().also { it.start(null, "weird", "V") }
+        assertEquals("other", a.state.value.identifierKind)
+        val b = vm().also { it.start(null, null, "V") }
+        assertEquals(ITEM_FORM_DEFAULT_KIND, b.state.value.identifierKind)
+    }
+
+    @Test
+    fun startIsIdempotentSoRecompositionKeepsUserInput() {
+        val vm = vm()
+        vm.start(null, "serial", "V")
+        vm.onNameChange("Typed")
+        vm.start(null, "model", "OTHER")
+        assertEquals("Typed", vm.state.value.name)
+        assertEquals("V", vm.state.value.identifierValue)
+    }
+
+    @Test
+    fun editLoadsItemAndSendsOnlyChangedFieldsAtMirrorVersion() {
+        val vm = vm()
+        vm.start("i1")
+        await { !vm.state.value.loading }
+        assertEquals("Drill", vm.state.value.name)
+        assertEquals("old", vm.state.value.description)
+        assertEquals("loc-garage", vm.state.value.locationId)
+
+        vm.onDescriptionChange("new text")
+        vm.submit()
+        await { vm.state.value.savedItemId != null }
+
+        assertEquals("i1", vm.state.value.savedItemId)
+        val row = outbox().single()
+        val m = LocalMutation.from(row)
+        assertEquals("i1", row.entityId)
+        assertEquals(4L, m.baseVersion)
+        assertEquals(setOf("description"), m.fields.keys)
+        assertEquals("new text", str(m, "description"))
+        assertEquals(1, syncCalls)
+    }
+
+    @Test
+    fun editNameAndLocationChangeIsOneMutationAndClearingDescriptionSendsEmpty() {
+        val vm = vm()
+        vm.start("i1")
+        await { !vm.state.value.loading }
+        vm.onNameChange("Drill 2")
+        vm.onDescriptionChange("")
+        vm.onLocationChange(null)
+        vm.submit()
+        await { vm.state.value.savedItemId != null }
+
+        val m = LocalMutation.from(outbox().single())
+        assertEquals(4L, m.baseVersion)
+        assertEquals("Drill 2", str(m, "name"))
+        assertEquals("", str(m, "description"))
+        assertEquals(JsonNull, m.fields["location_id"])
+        assertEquals(1, syncCalls)
+    }
+
+    @Test
+    fun editWithNoChangesWritesNothingAndStillCompletes() {
+        val vm = vm()
+        vm.start("i1")
+        await { !vm.state.value.loading }
+        vm.submit()
+        await { vm.state.value.savedItemId != null }
+        assertTrue(outbox().isEmpty())
+        assertEquals(0, syncCalls)
+    }
+
+    @Test
+    fun editWithBlankNameIsRejected() {
+        val vm = vm()
+        vm.start("i1")
+        await { !vm.state.value.loading }
+        vm.onNameChange(" ")
+        vm.submit()
+        assertEquals("Name is required.", vm.state.value.nameError)
+        assertTrue(outbox().isEmpty())
+    }
+
+    @Test
+    fun editOfMissingItemReportsNotFound() {
+        val vm = vm()
+        vm.start("ghost")
+        await { vm.state.value.notFound }
+        vm.submit()
+        assertTrue(outbox().isEmpty())
+    }
+
+    @Test
+    fun doubleSubmitCreatesOneItem() {
+        val dispatcher = StandardTestDispatcher()
+        Dispatchers.setMain(dispatcher)
+        val vm = vm()
+        vm.start(null)
+        vm.fill("Saw")
+        vm.submit()
+        assertTrue(vm.state.value.submitting)
+        vm.submit()
+        await {
+            dispatcher.scheduler.advanceUntilIdle()
+            vm.state.value.savedItemId != null
+        }
+        vm.submit()
+        dispatcher.scheduler.advanceUntilIdle()
+
+        assertEquals(1, outbox().size)
+        assertEquals(1, syncCalls)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ItemListViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ItemListViewModelTest.kt
new file mode 100644
index 0000000..b2bbb45
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ItemListViewModelTest.kt
@@ -0,0 +1,232 @@
+package dev.hho.android.ui.items
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.items.ItemSearch
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemIdentificationEntity
+import dev.hho.android.data.room.OutboxMutationEntity
+import dev.hho.android.data.room.OutboxState
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ItemListViewModelTest {
+
+    private lateinit var db: HhoDatabase
+    private lateinit var itemSearch: ItemSearch
+    private val viewModels = ViewModelTracker()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+        db = inMemoryHhoDatabase()
+        itemSearch = ItemSearch(db.itemDao())
+    }
+
+    @After
+    fun tearDown() {
+        viewModels.cancelAll()
+        db.close()
+        Dispatchers.resetMain()
+    }
+
+    private fun itemFixture(id: String, name: String, quantity: Long? = 1L, shortCode: String? = null) =
+        ItemEntity(
+            id = id,
+            groupChangeSeq = 1L,
+            name = name,
+            description = null,
+            locationId = null,
+            quantity = quantity,
+            shortCode = shortCode,
+            createdAt = 1L,
+            updatedAt = 1L,
+            version = 1L,
+        )
+
+    @Test
+    fun `empty Room mirror surfaces the empty state, not a crash or an infinite loading state`() = runTest {
+        val viewModel = viewModels.track(ItemListViewModel(itemSearch, db))
+
+        val state = viewModel.uiState.first { it !is ItemListUiState.Loading }
+
+        assertEquals(ItemListUiState.Empty, state)
+    }
+
+    @Test
+    fun `emits every synced item, sorted by name`() = runTest {
+        db.itemDao().upsert(itemFixture("item-2", name = "Saw", quantity = 3L))
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill", quantity = 1L, shortCode = "DRL-1"))
+        val viewModel = viewModels.track(ItemListViewModel(itemSearch, db))
+
+        val state = viewModel.uiState.first { it is ItemListUiState.Data } as ItemListUiState.Data
+
+        assertEquals(
+            listOf(
+                ItemRow(id = "item-1", name = "Drill", quantity = 1L, shortCode = "DRL-1"),
+                ItemRow(id = "item-2", name = "Saw", quantity = 3L, shortCode = null),
+            ),
+            state.items,
+        )
+    }
+
+    @Test
+    fun `a row inserted by a background sync after the ViewModel is created updates the list live`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        val viewModel = viewModels.track(ItemListViewModel(itemSearch, db))
+        val initial = viewModel.uiState.first { it is ItemListUiState.Data } as ItemListUiState.Data
+        assertEquals(1, initial.items.size)
+
+        db.itemDao().upsert(itemFixture("item-2", name = "Saw"))
+
+        val updated = viewModel.uiState.first { it is ItemListUiState.Data && it.items.size == 2 }
+            as ItemListUiState.Data
+        assertEquals(setOf("item-1", "item-2"), updated.items.map { it.id }.toSet())
+    }
+
+    @Test
+    fun `onQueryChange filters to items whose name, short code, or identifier value matches, case-insensitively`() =
+        runTest {
+            db.itemDao().upsert(itemFixture("item-1", name = "Cordless Drill", shortCode = "DRL-1"))
+            db.itemDao().upsert(itemFixture("item-2", name = "Table Saw"))
+            db.itemIdentificationDao().upsert(
+                ItemIdentificationEntity(
+                    id = "ident-1",
+                    groupChangeSeq = 1L,
+                    itemId = "item-2",
+                    kind = "barcode",
+                    value = "DRILL-CODE-9",
+                    createdAt = 1L,
+                    updatedAt = 1L,
+                    version = 1L,
+                ),
+            )
+            val viewModel = viewModels.track(ItemListViewModel(itemSearch, db))
+            viewModel.uiState.first { it is ItemListUiState.Data }
+
+            viewModel.onQueryChange("drill")
+
+            val state = viewModel.uiState.first {
+                it is ItemListUiState.Data && it.items.size == 2
+            } as ItemListUiState.Data
+            assertEquals(setOf("item-1", "item-2"), state.items.map { it.id }.toSet())
+        }
+
+    @Test
+    fun `a query matching nothing in a non-empty mirror surfaces NoMatches, not Empty`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        val viewModel = viewModels.track(ItemListViewModel(itemSearch, db))
+        viewModel.uiState.first { it is ItemListUiState.Data }
+
+        viewModel.onQueryChange("no-such-item")
+
+        val state = viewModel.uiState.first { it is ItemListUiState.NoMatches }
+        assertEquals(ItemListUiState.NoMatches("no-such-item"), state)
+    }
+
+    @Test
+    fun `clearing the query back to blank restores the full, unfiltered list`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", name = "Drill"))
+        db.itemDao().upsert(itemFixture("item-2", name = "Saw"))
+        val viewModel = viewModels.track(ItemListViewModel(itemSearch, db))
+        viewModel.onQueryChange("drill")
+        viewModel.uiState.first { it is ItemListUiState.Data && it.items.size == 1 }
+
+        viewModel.onQueryChange("")
+
+        val state = viewModel.uiState.first { it is ItemListUiState.Data && it.items.size == 2 }
+            as ItemListUiState.Data
+        assertEquals(setOf("item-1", "item-2"), state.items.map { it.id }.toSet())
+    }
+
+    private suspend fun adjustment(itemId: String, delta: Long, state: String = OutboxState.PENDING): Long =
+        db.outboxDao().insert(
+            OutboxMutationEntity(
+                mutationId = "m-${System.nanoTime()}",
+                entityType = "stock_adjustment",
+                entityId = "s-${System.nanoTime()}",
+                op = "create",
+                baseVersion = 0L,
+                fieldsJson = """{"item_id":"$itemId","delta":$delta}""",
+                state = state,
+                createdAt = 1L,
+            ),
+        )
+
+    private suspend fun ItemListViewModel.quantities(expect: Map<String, Long?>): Map<String, Long?> =
+        (uiState.first { s -> s is ItemListUiState.Data && s.items.associate { it.id to it.quantity } == expect }
+            as ItemListUiState.Data).items.associate { it.id to it.quantity }
+
+    @Test
+    fun `pending stock delta is added to the mirror quantity in the list`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", "Drill", quantity = 5L))
+        adjustment("item-1", 2L)
+        val viewModel = viewModels.track(ItemListViewModel(itemSearch, db))
+
+        assertEquals(mapOf("item-1" to 7L), viewModel.quantities(mapOf("item-1" to 7L)))
+    }
+
+    @Test
+    fun `after the ack and a pulled server value there is no double count`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", "Drill", quantity = 5L))
+        val seq = adjustment("item-1", 2L)
+        val viewModel = viewModels.track(ItemListViewModel(itemSearch, db))
+        viewModel.quantities(mapOf("item-1" to 7L))
+
+        db.outboxDao().deleteBySeq(seq)
+        db.itemDao().upsert(itemFixture("item-1", "Drill", quantity = 7L))
+
+        assertEquals(mapOf("item-1" to 7L), viewModel.quantities(mapOf("item-1" to 7L)))
+    }
+
+    @Test
+    fun `several items each get only their own deltas, summed`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", "Drill", quantity = 5L))
+        db.itemDao().upsert(itemFixture("item-2", "Saw", quantity = 10L))
+        db.itemDao().upsert(itemFixture("item-3", "Nails", quantity = 3L))
+        adjustment("item-1", 2L)
+        adjustment("item-1", -1L)
+        adjustment("item-2", -4L, OutboxState.IN_FLIGHT)
+        val viewModel = viewModels.track(ItemListViewModel(itemSearch, db))
+
+        val expected = mapOf("item-1" to 6L, "item-2" to 6L, "item-3" to 3L)
+        assertEquals(expected, viewModel.quantities(expected))
+    }
+
+    @Test
+    fun `FAILED adjustments are ignored`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", "Drill", quantity = 5L))
+        adjustment("item-1", 100L, OutboxState.FAILED)
+        val viewModel = viewModels.track(ItemListViewModel(itemSearch, db))
+
+        assertEquals(mapOf("item-1" to 5L), viewModel.quantities(mapOf("item-1" to 5L)))
+    }
+
+    @Test
+    fun `search results also show derived quantities and a new adjustment updates live`() = runTest {
+        db.itemDao().upsert(itemFixture("item-1", "Drill", quantity = 5L))
+        db.itemDao().upsert(itemFixture("item-2", "Saw", quantity = 1L))
+        adjustment("item-1", 2L)
+        val viewModel = viewModels.track(ItemListViewModel(itemSearch, db))
+        viewModel.onQueryChange("drill")
+
+        assertEquals(mapOf("item-1" to 7L), viewModel.quantities(mapOf("item-1" to 7L)))
+        adjustment("item-1", 1L)
+        assertEquals(mapOf("item-1" to 8L), viewModel.quantities(mapOf("item-1" to 8L)))
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/items/NoApiClientInItemsPackageTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/NoApiClientInItemsPackageTest.kt
new file mode 100644
index 0000000..9f278c4
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/NoApiClientInItemsPackageTest.kt
@@ -0,0 +1,57 @@
+package dev.hho.android.ui.items
+
+import dev.hho.android.data.apiclient.HhoApiClient
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Test
+import java.io.File
+
+class NoApiClientInItemsPackageTest {
+
+    @Test
+    fun `ItemListViewModel's constructor never mentions HhoApiClient`() {
+        assertNoConstructorParameterIsHhoApiClient(ItemListViewModel::class.java)
+    }
+
+    @Test
+    fun `ItemDetailViewModel's constructor never mentions HhoApiClient`() {
+        assertNoConstructorParameterIsHhoApiClient(ItemDetailViewModel::class.java)
+    }
+
+    @Test
+    fun `no source file under ui items mentions HhoApiClient`() {
+        val sourceFiles = itemsPackageSourceFiles()
+        assertTrue(
+            "Expected to find ui/items Kotlin source files to scan, found none at ${itemsPackageDir().absolutePath} " +
+                "— this test would otherwise pass vacuously.",
+            sourceFiles.isNotEmpty(),
+        )
+
+        val offenders = sourceFiles.filter { it.readText().contains("HhoApiClient") }
+        if (offenders.isNotEmpty()) {
+            fail(
+                "ui/items must never reference HhoApiClient (plan.md D3.5, FR-112/FR-113 — this " +
+                    "package's screens/ViewModels read exclusively from Room), but found it in: " +
+                    offenders.joinToString { it.relativeTo(itemsPackageDir()).path },
+            )
+        }
+    }
+
+    private fun assertNoConstructorParameterIsHhoApiClient(viewModelClass: Class<*>) {
+        val offendingConstructors = viewModelClass.declaredConstructors.filter { constructor ->
+            constructor.parameterTypes.any { it == HhoApiClient::class.java }
+        }
+        assertTrue(
+            "${viewModelClass.simpleName} must never take an HhoApiClient constructor parameter " +
+                "(plan.md D3.5: 'no ViewModel in this deliverable holds a reference to HhoApiClient " +
+                "at all') — found it on: $offendingConstructors",
+            offendingConstructors.isEmpty(),
+        )
+    }
+
+    private fun itemsPackageDir(): File =
+        File("src/main/kotlin/dev/hho/android/ui/items")
+
+    private fun itemsPackageSourceFiles(): List<File> =
+        itemsPackageDir().listFiles { file -> file.isFile && file.extension == "kt" }?.toList().orEmpty()
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/items/StockActionsViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/StockActionsViewModelTest.kt
new file mode 100644
index 0000000..020968a
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/StockActionsViewModelTest.kt
@@ -0,0 +1,191 @@
+package dev.hho.android.ui.items
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.outbox.LocalMutation
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.domain.EditRepository
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import kotlinx.coroutines.withTimeout
+import kotlinx.serialization.json.JsonPrimitive
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class StockActionsViewModelTest {
+
+    private lateinit var db: HhoDatabase
+    private var syncCalls = 0
+    private val viewModels = ViewModelTracker()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+        db = inMemoryHhoDatabase()
+        runBlocking { db.itemDao().upsert(ItemEntity("i1", 5, "Drill", "d", null, 5, "AB12", 1, 1, 4)) }
+    }
+
+    @After
+    fun tearDown() {
+        viewModels.cancelAll()
+        db.close()
+        Dispatchers.resetMain()
+    }
+
+    private fun stockViewModel(): StockActionsViewModel {
+        val ids = UuidV7Generator()
+        val repo = EditRepository(db, OutboxRepository(db, ids), ids) { syncCalls++ }
+        return viewModels.track(StockActionsViewModel(repo))
+    }
+
+    private fun detailViewModel() = viewModels.track(
+        ItemDetailViewModel(
+            itemDao = db.itemDao(),
+            itemLabelDao = db.itemLabelDao(),
+            labelDao = db.labelDao(),
+            locationDao = db.locationDao(),
+            warrantyBlockDao = db.warrantyBlockDao(),
+            soldToBlockDao = db.soldToBlockDao(),
+            purchasedFromBlockDao = db.purchasedFromBlockDao(),
+            itemIdentificationDao = db.itemIdentificationDao(),
+            itemCustomFieldDao = db.itemCustomFieldDao(),
+            stockAdjustmentDao = db.stockAdjustmentDao(),
+            db = db,
+        ),
+    )
+
+    private fun await(condition: () -> Boolean) = runBlocking {
+        withTimeout(10_000) { while (!condition()) kotlinx.coroutines.delay(10) }
+    }
+
+    private fun detailQuantity(vm: ItemDetailViewModel): Long? =
+        ((vm.uiState.value as? ItemDetailUiState.Data)?.item)?.quantity
+
+    @Test
+    fun successQueuesAdjustmentTriggersSyncAndCompletes() {
+        val vm = stockViewModel()
+        vm.submit("i1", 3L, "  Restocked ", " ")
+        await { vm.state.value.completed }
+
+        assertFalse(vm.state.value.submitting)
+        assertNull(vm.state.value.deltaError)
+        assertEquals(1, syncCalls)
+        val row = runBlocking { db.outboxDao().getAllOrdered() }.single()
+        val fields = LocalMutation.from(row).fields
+        assertEquals("stock_adjustment", row.entityType)
+        assertEquals("3", (fields["delta"] as JsonPrimitive).content)
+        assertEquals("Restocked", (fields["reason"] as JsonPrimitive).content)
+        assertFalse("blank note is sent as absent", fields.containsKey("note"))
+    }
+
+    @Test
+    fun zeroDeltaShowsInlineErrorAndWritesNothing() {
+        val vm = stockViewModel()
+        vm.submit("i1", 0L, "", "")
+        await { vm.state.value.deltaError != null }
+
+        assertFalse(vm.state.value.completed)
+        assertTrue(runBlocking { db.outboxDao().getAllOrdered() }.isEmpty())
+        assertEquals(0, syncCalls)
+    }
+
+    @Test
+    fun unparseableDeltaShowsInlineErrorWithoutTouchingRepository() {
+        val vm = stockViewModel()
+        vm.submit("i1", null, "", "")
+
+        assertNotNull(vm.state.value.deltaError)
+        assertFalse(vm.state.value.submitting)
+        assertTrue(runBlocking { db.outboxDao().getAllOrdered() }.isEmpty())
+    }
+
+    @Test
+    fun missingItemReportsNotFound() {
+        val vm = stockViewModel()
+        vm.submit("ghost", 2L, "", "")
+        await { vm.state.value.generalError != null }
+
+        assertEquals("This item is no longer on this device.", vm.state.value.generalError)
+        assertFalse(vm.state.value.completed)
+    }
+
+    @Test
+    fun storageFailureIsReportedAndLeavesNoRow() {
+        db.openHelper.writableDatabase.execSQL(
+            "CREATE TRIGGER fail_enqueue BEFORE INSERT ON outbox_mutation BEGIN SELECT RAISE(ABORT, 'boom'); END",
+        )
+        val vm = stockViewModel()
+        vm.submit("i1", 2L, "", "")
+        await { vm.state.value.generalError != null }
+
+        assertFalse(vm.state.value.completed)
+        assertFalse(vm.state.value.submitting)
+        assertTrue(runBlocking { db.stockAdjustmentDao().observeByItemId("i1").first() }.isEmpty())
+        assertEquals(0, syncCalls)
+    }
+
+    @Test
+    fun submittingBlocksASecondSubmitUntilTheFirstFinishes() {
+        val dispatcher = StandardTestDispatcher()
+        Dispatchers.setMain(dispatcher)
+        val vm = stockViewModel()
+
+        vm.submit("i1", 1L, "", "")
+        assertTrue("confirm must be disabled while submitting", vm.state.value.submitting)
+        vm.submit("i1", 1L, "", "")
+        await {
+            dispatcher.scheduler.advanceUntilIdle()
+            vm.state.value.completed
+        }
+
+        assertEquals(1, runBlocking { db.outboxDao().getAllOrdered() }.size)
+    }
+
+    @Test
+    fun resetClearsErrorsAndCompletion() {
+        val vm = stockViewModel()
+        vm.submit("i1", 0L, "", "")
+        await { vm.state.value.deltaError != null }
+        vm.reset()
+        assertEquals(AdjustStockState(), vm.state.value)
+    }
+
+    @Test
+    fun detailQuantityReflectsPendingAdjustmentImmediately() {
+        val detail = detailViewModel()
+        detail.loadItem("i1")
+        val collector = CoroutineScope(Dispatchers.Default).launch { detail.uiState.collect { } }
+        try {
+            await { detailQuantity(detail) == 5L }
+            val vm = stockViewModel()
+            vm.submit("i1", -2L, "Used", "")
+            await { vm.state.value.completed }
+            await { detailQuantity(detail) == 3L }
+            assertEquals(5L, runBlocking { db.itemDao().getById("i1") }!!.quantity)
+        } finally {
+            collector.cancel()
+        }
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ViewModelTeardown.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ViewModelTeardown.kt
new file mode 100644
index 0000000..ea58464
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/items/ViewModelTeardown.kt
@@ -0,0 +1,18 @@
+package dev.hho.android.ui.items
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.cancel
+import org.robolectric.shadows.ShadowLooper
+
+internal class ViewModelTracker {
+    private val tracked = mutableListOf<ViewModel>()
+
+    fun <T : ViewModel> track(viewModel: T): T = viewModel.also { tracked += it }
+
+    fun cancelAll() {
+        tracked.forEach { it.viewModelScope.cancel() }
+        tracked.clear()
+        ShadowLooper.idleMainLooper()
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/login/LoginViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/login/LoginViewModelTest.kt
new file mode 100644
index 0000000..ee33a0e
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/login/LoginViewModelTest.kt
@@ -0,0 +1,117 @@
+package dev.hho.android.ui.login
+
+import dev.hho.android.data.apiclient.ApiError
+import dev.hho.android.domain.AuthRepository
+import dev.hho.android.domain.AuthState
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class LoginViewModelTest {
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+    }
+
+    @After
+    fun tearDown() {
+        Dispatchers.resetMain()
+    }
+
+    private class FakeAuthRepository(private val result: Result<Unit>) : AuthRepository {
+        override val authState: Flow<AuthState> = MutableStateFlow(AuthState.LoggedOut)
+        var lastUsername: String? = null
+        var lastPassword: String? = null
+
+        override suspend fun login(
+            username: String,
+            password: String,
+        ): Result<Unit> {
+            lastUsername = username
+            lastPassword = password
+            return result
+        }
+
+        override suspend fun logout() {
+        }
+    }
+
+    @Test
+    fun `a successful login forwards the credentials, clears the password, and emits loggedIn`() =
+        runTest {
+            val repository = FakeAuthRepository(Result.success(Unit))
+            val viewModel = LoginViewModel(repository)
+
+            viewModel.submit("alice", "secret")
+
+            assertEquals("alice", repository.lastUsername)
+            assertEquals("secret", repository.lastPassword)
+            assertEquals(Unit, viewModel.loggedIn.first())
+            assertNull(viewModel.uiState.value.errorMessage)
+            assertEquals("", viewModel.uiState.value.password)
+            assertTrue(!viewModel.uiState.value.isLoading)
+        }
+
+    @Test
+    fun `an incorrect-credentials failure shows a specific message, stays on screen, and clears the password`() =
+        runTest {
+            val repository = FakeAuthRepository(Result.failure(ApiError.Unauthorized()))
+            val viewModel = LoginViewModel(repository)
+
+            viewModel.submit("alice", "wrong-password")
+
+            assertEquals("Incorrect username or password.", viewModel.uiState.value.errorMessage)
+            assertEquals("", viewModel.uiState.value.password)
+            assertTrue(!viewModel.uiState.value.isLoading)
+        }
+
+    @Test
+    fun `a 429 shows a rate-limited message`() =
+        runTest {
+            val repository = FakeAuthRepository(Result.failure(ApiError.Validation(status = 429, detail = null)))
+            val viewModel = LoginViewModel(repository)
+
+            viewModel.submit("alice", "secret")
+
+            assertTrue(viewModel.uiState.value.errorMessage!!.contains("Too many login attempts"))
+        }
+
+    @Test
+    fun `a device-token-call failure after a successful login surfaces the same way as a login failure`() =
+        runTest {
+            val repository = FakeAuthRepository(Result.failure(ApiError.Server(status = 500, detail = null)))
+            val viewModel = LoginViewModel(repository)
+
+            viewModel.submit("alice", "secret")
+
+            assertEquals("That server answered unexpectedly. Try again.", viewModel.uiState.value.errorMessage)
+            assertTrue(!viewModel.uiState.value.isLoading)
+        }
+
+    @Test
+    fun `changing the username field clears a stale error message`() =
+        runTest {
+            val repository = FakeAuthRepository(Result.failure(ApiError.Unauthorized()))
+            val viewModel = LoginViewModel(repository)
+            viewModel.submit("alice", "wrong-password")
+            assertTrue(viewModel.uiState.value.errorMessage != null)
+
+            viewModel.onUsernameChanged("alice2")
+
+            assertNull(viewModel.uiState.value.errorMessage)
+        }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/photos/PhotoCaptureViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/photos/PhotoCaptureViewModelTest.kt
new file mode 100644
index 0000000..385b276
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/photos/PhotoCaptureViewModelTest.kt
@@ -0,0 +1,210 @@
+package dev.hho.android.ui.photos
+
+import androidx.camera.core.Preview
+import androidx.lifecycle.LifecycleOwner
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.photoqueue.PhotoCapture
+import dev.hho.android.data.photoqueue.PhotoQueueRepository
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.PhotoQueueDao
+import dev.hho.android.data.room.PhotoQueueEntryEntity
+import dev.hho.android.data.room.PhotoState
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.ui.items.ViewModelTracker
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.io.File
+import java.io.IOException
+
+private class FakeCapture(private val dir: File) : PhotoCapture {
+    var failure: Throwable? = null
+    var gate: CompletableDeferred<Unit>? = null
+    var calls = 0
+    var lastFile: File? = null
+    var unbound = false
+
+    override suspend fun bind(lifecycleOwner: LifecycleOwner, surfaceProvider: Preview.SurfaceProvider) = Unit
+
+    override fun unbind() {
+        unbound = true
+    }
+
+    override suspend fun capture(): File {
+        calls++
+        gate?.await()
+        failure?.let { throw it }
+        return File(dir, "cap-$calls.jpg").also {
+            it.writeText("jpeg-bytes")
+            lastFile = it
+        }
+    }
+}
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class PhotoCaptureViewModelTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var base: File
+    private lateinit var capDir: File
+    private lateinit var fake: FakeCapture
+    private var scheduled = 0
+    private val viewModels = ViewModelTracker()
+
+    @Before
+    fun setUp() {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+        db = inMemoryHhoDatabase()
+        val tmp = TemporaryFolder().also { it.create() }
+        base = tmp.newFolder("files")
+        capDir = tmp.newFolder("cache")
+        fake = FakeCapture(capDir)
+    }
+
+    @After
+    fun tearDown() {
+        viewModels.cancelAll()
+        db.close()
+        Dispatchers.resetMain()
+    }
+
+    private fun repo(dao: PhotoQueueDao = db.photoQueueDao()) =
+        PhotoQueueRepository(base, dao, { 1_000L }) { it.inputStream() }
+
+    private fun vm(queue: PhotoQueueRepository = repo()) =
+        viewModels.track(PhotoCaptureViewModel(fake, queue) { scheduled++ })
+
+    private fun awaitState(vm: PhotoCaptureViewModel, pred: (PhotoCaptureUiState) -> Boolean) = runBlocking {
+        val deadline = System.currentTimeMillis() + 5_000
+        while (!pred(vm.state.value) && System.currentTimeMillis() < deadline) {
+            org.robolectric.shadows.ShadowLooper.idleMainLooper()
+            Thread.sleep(10)
+        }
+        assertTrue("state: ${vm.state.value}", pred(vm.state.value))
+    }
+
+    private fun entries() = runBlocking { db.photoQueueDao().getAllOrdered() }
+
+    @Test
+    fun captureSuccessQueuesOneEntrySchedulesOnceAndDeletesTemp() {
+        val v = vm()
+        v.shoot("item-1")
+        awaitState(v) { it.done }
+        val e = entries().single()
+        assertEquals("item-1", e.itemId)
+        assertEquals(PhotoState.QUEUED, e.state)
+        assertEquals(
+            java.security.MessageDigest.getInstance("SHA-256").digest("jpeg-bytes".toByteArray())
+                .joinToString("") { "%02x".format(it) },
+            e.sha256,
+        )
+        assertEquals(1, scheduled)
+        assertFalse("temp must be deleted", fake.lastFile!!.exists())
+        assertTrue(File(e.filePath).isFile)
+        assertNull(v.state.value.error)
+    }
+
+    @Test
+    fun captureFailureQueuesNothingAndShowsError() {
+        fake.failure = IOException("boom")
+        val v = vm()
+        v.shoot("item-1")
+        awaitState(v) { it.error != null }
+        assertTrue(entries().isEmpty())
+        assertEquals(0, scheduled)
+        assertFalse(v.state.value.submitting)
+        assertFalse(v.state.value.done)
+    }
+
+    @Test
+    fun enqueueFailureDeletesTempAndShowsError() {
+        val real = db.photoQueueDao()
+        val failing =
+            object : PhotoQueueDao by real {
+                override suspend fun insert(entry: PhotoQueueEntryEntity) = throw IOException("disk full")
+            }
+        val v = vm(repo(failing))
+        v.shoot("item-1")
+        awaitState(v) { it.error != null }
+        assertFalse("temp must be deleted", fake.lastFile!!.exists())
+        assertTrue(entries().isEmpty())
+        assertEquals(0, scheduled)
+        assertTrue(File(base, "photo-queue").listFiles().orEmpty().isEmpty())
+    }
+
+    @Test
+    fun doubleSubmitWhileInFlightCapturesOnce() {
+        fake.gate = CompletableDeferred()
+        val v = vm()
+        v.shoot("item-1")
+        v.shoot("item-1")
+        assertEquals(1, fake.calls)
+        assertTrue(v.state.value.submitting)
+        fake.gate!!.complete(Unit)
+        awaitState(v) { it.done }
+        v.shoot("item-1")
+        assertEquals(1, fake.calls)
+        assertEquals(1, entries().size)
+        assertEquals(1, scheduled)
+    }
+
+    @Test
+    fun retryIsAllowedAfterFailure() {
+        fake.failure = IOException("boom")
+        val v = vm()
+        v.shoot("item-1")
+        awaitState(v) { it.error != null }
+        fake.failure = null
+        v.shoot("item-1")
+        awaitState(v) { it.done }
+        assertEquals(1, entries().size)
+        assertNull(v.state.value.error)
+    }
+
+    @Test
+    fun badgeCountsArePerItem() = runTest {
+        val dao = db.photoQueueDao()
+        fun e(id: String, item: String, state: String) =
+            PhotoQueueEntryEntity(id, item, "/x/$id", "s", 1, "image", state, createdAt = 1)
+        dao.insert(e("a", "i1", PhotoState.QUEUED))
+        dao.insert(e("b", "i1", PhotoState.WAITING_PARENT))
+        dao.insert(e("c", "i1", PhotoState.UPLOADING))
+        dao.insert(e("d", "i1", PhotoState.FAILED))
+        dao.insert(e("z", "i2", PhotoState.QUEUED))
+        val badge = viewModels.track(ItemPhotoBadgeViewModel(repo()))
+        badge.load("i1")
+        val collector = CoroutineScope(Dispatchers.Unconfined).launch { badge.badge.collect { } }
+        val deadline = System.currentTimeMillis() + 5_000
+        while (badge.badge.value.failed == 0 && System.currentTimeMillis() < deadline) {
+            org.robolectric.shadows.ShadowLooper.idleMainLooper()
+            Thread.sleep(10)
+        }
+        assertEquals(PhotoBadge(queued = 2, uploading = 1, failed = 1), badge.badge.value)
+        val b = repo().observeEntriesForItem("i1").first().let { PhotoBadge.from(it) }
+        assertEquals(PhotoBadge(queued = 2, uploading = 1, failed = 1), b)
+        assertEquals("Photos: 2 queued, 1 uploading, 1 failed", b.summary())
+        assertEquals(PhotoBadge(queued = 1), PhotoBadge.from(repo().observeEntriesForItem("i2").first()))
+        assertNull(PhotoBadge.from(repo().observeEntriesForItem("none").first()).summary())
+        collector.cancel()
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/receiving/ReceivingViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/receiving/ReceivingViewModelTest.kt
new file mode 100644
index 0000000..72d5bb2
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/receiving/ReceivingViewModelTest.kt
@@ -0,0 +1,332 @@
+package dev.hho.android.ui.receiving
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.items.ItemSearch
+import dev.hho.android.data.outbox.LocalMutation
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.data.receiving.LineStatus
+import dev.hho.android.data.receiving.ReceivingRepository
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemIdentificationEntity
+import dev.hho.android.data.room.ReceivingStatus
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.scanner.BarcodeFormat
+import dev.hho.android.data.scanner.DecodedBarcode
+import dev.hho.android.domain.EditRepository
+import dev.hho.android.domain.ReceivingCheckIn
+import dev.hho.android.ui.deeplink.DeepLinkResolver
+import dev.hho.android.ui.items.ViewModelTracker
+import dev.hho.android.ui.scan.ScanResolver
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import kotlinx.coroutines.withTimeout
+import kotlinx.serialization.json.JsonPrimitive
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import java.time.LocalDate
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ReceivingViewModelTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var vm: ReceivingViewModel
+    private var syncCalls = 0
+    private var clock = 0L
+    private val viewModels = ViewModelTracker()
+
+    private lateinit var drill: ItemEntity
+    private lateinit var saw: ItemEntity
+    private lateinit var tape: ItemEntity
+
+    @Before fun setUp() = runBlocking {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+        db = inMemoryHhoDatabase()
+        drill = item("drill", "Drill")
+        saw = item("saw", "Saw")
+        tape = item("tape", "Tape")
+        for ((n, item) in listOf(drill, saw, tape).withIndex()) {
+            db.itemDao().upsert(item)
+            db.itemIdentificationDao().upsert(
+                ItemIdentificationEntity("id$n", 1L, item.id, "barcode", item.shortCode!!, 1L, 1L, 1L),
+            )
+        }
+        for ((n, item) in listOf(drill, saw).withIndex()) {
+            db.itemIdentificationDao().upsert(
+                ItemIdentificationEntity("dup$n", 1L, item.id, "barcode", "999", 1L, 1L, 1L),
+            )
+        }
+        val ids = UuidV7Generator()
+        val edits = EditRepository(db, OutboxRepository(db, ids), ids) { syncCalls++ }
+        vm = viewModels.track(
+            ReceivingViewModel(
+                repo = ReceivingRepository(db),
+                checkIn = ReceivingCheckIn(db, edits),
+                resolver = ScanResolver(DeepLinkResolver(db.itemDao()), ItemSearch(db.itemDao()), db.itemDao()),
+                itemSearch = ItemSearch(db.itemDao()),
+                itemDao = db.itemDao(),
+            ),
+        )
+        vm.nowMillis = { clock }
+    }
+
+    @After fun tearDown() {
+        viewModels.cancelAll()
+        db.close()
+        Dispatchers.resetMain()
+    }
+
+    private fun item(id: String, name: String) = ItemEntity(
+        id, 1, name, null, null, 0, when (id) { "drill" -> "111"; "saw" -> "222"; else -> "333" }, 1, 1, 1,
+    )
+
+    private fun code(v: String) = listOf(DecodedBarcode(v, BarcodeFormat.QR_CODE))
+
+    private fun await(what: String = "condition", condition: () -> Boolean) = runBlocking {
+        withTimeout(10_000) { while (!condition()) kotlinx.coroutines.delay(10) }
+    }
+
+    private fun sessionState() = vm.session.value
+
+    private fun line(id: String) = sessionState()?.lines?.firstOrNull { it.itemId == id }
+
+    private fun startSession(vendor: String = "Acme", order: String = "PO-7", date: String = "2026-03-04"): String {
+        vm.newSession()
+        vm.createSession(vendor, order, date)
+        await { sessionState() != null }
+        return sessionState()!!.session.id
+    }
+
+    private fun scan(value: String) {
+        clock += 10_000
+        vm.onBarcodes(code(value))
+    }
+
+    @Test fun headerRequiresVendorAndValidDate() {
+        vm.newSession()
+        vm.createSession("  ", "PO", "")
+        assertNotNull(vm.header.value.vendorError)
+        assertEquals(ReceivingMode.Header, vm.mode.value)
+
+        vm.createSession("Acme", "PO", "04/03/2026")
+        assertNotNull(vm.header.value.dateError)
+        assertNull(vm.header.value.vendorError)
+        assertEquals(ReceivingMode.Header, vm.mode.value)
+        assertTrue(runBlocking { db.receivingDao().observeByStatus(ReceivingStatus.OPEN).first() }.isEmpty())
+    }
+
+    @Test fun validHeaderStartsAndOpensSession() {
+        val id = startSession(order = " PO-7 ")
+        val s = sessionState()!!.session
+        assertEquals(id, s.id)
+        assertEquals("Acme", s.vendor)
+        assertEquals("PO-7", s.orderReference)
+        assertEquals(LocalDate.of(2026, 3, 4), s.purchasedOn)
+        assertEquals(ReceivingMode.Session(id), vm.mode.value)
+        await { vm.openSessions.value.size == 1 }
+    }
+
+    @Test fun blankOrderAndDateAreOptional() {
+        startSession(order = "", date = "")
+        assertNull(sessionState()!!.session.orderReference)
+        assertNull(sessionState()!!.session.purchasedOn)
+    }
+
+    @Test fun pickerAddsExpectedLineOnceAndPromotesNothingTwice() {
+        startSession()
+        vm.setQuery("dri")
+        await { vm.pickerResults.value.map { it.id } == listOf("drill") }
+        vm.addExpected(vm.pickerResults.value.single())
+        await { line("drill") != null }
+        assertEquals(1, line("drill")!!.discrepancy.expectedQty)
+
+        vm.setExpected("drill", 4)
+        await { line("drill")!!.discrepancy.expectedQty == 4 }
+        vm.addExpected(drill)
+        await { sessionState()!!.message?.contains("already") == true }
+        assertEquals(4, line("drill")!!.discrepancy.expectedQty)
+    }
+
+    @Test fun scanSingleIncrementsAndSummaryIsLive() {
+        startSession()
+        vm.addExpected(drill)
+        await { line("drill") != null }
+        vm.setExpected("drill", 2)
+        await { line("drill")?.discrepancy?.expectedQty == 2 }
+        vm.setScanning(true)
+        assertFalse(vm.paused)
+
+        scan("111")
+        await { line("drill")?.discrepancy?.receivedQty == 1 }
+        assertEquals(1, sessionState()!!.summary.shortLines.size)
+        scan("111")
+        await { line("drill")?.discrepancy?.receivedQty == 2 }
+        assertEquals(1, sessionState()!!.summary.matchedCount)
+        assertEquals(LineStatus.MATCHED, line("drill")!!.discrepancy.status)
+        vm.increment("drill")
+        await { sessionState()!!.summary.overLines.size == 1 }
+        vm.decrement("drill")
+        await { line("drill")!!.discrepancy.receivedQty == 2 }
+        vm.setReceived("drill", 0)
+        await { line("drill")!!.discrepancy.receivedQty == 0 }
+        vm.decrement("drill")
+        Thread.sleep(200)
+        assertEquals(0, line("drill")!!.discrepancy.receivedQty)
+        assertEquals(1, sessionState()!!.summary.shortLines.size)
+    }
+
+    @Test fun unexpectedScanAsksThenConfirmAddsUnplannedLine() {
+        startSession()
+        vm.setScanning(true)
+        scan("222")
+        await { sessionState()?.pendingUnexpected != null }
+        assertEquals("Saw", sessionState()!!.pendingUnexpected!!.name)
+        assertTrue("analysis pauses while asking", vm.paused)
+        assertNull("nothing is written before confirmation", line("saw"))
+
+        vm.confirmUnexpected()
+        await { line("saw") != null }
+        assertEquals(LineStatus.UNEXPECTED, line("saw")!!.discrepancy.status)
+        assertEquals(1, line("saw")!!.discrepancy.receivedQty)
+        assertNull(sessionState()!!.pendingUnexpected)
+        assertEquals(1, sessionState()!!.summary.unexpectedLines.size)
+    }
+
+    @Test fun decliningUnexpectedWritesNothing() {
+        startSession()
+        vm.setScanning(true)
+        scan("222")
+        await { sessionState()?.pendingUnexpected != null }
+        vm.dismissUnexpected()
+        await { sessionState()!!.pendingUnexpected == null }
+        assertTrue(sessionState()!!.lines.isEmpty())
+        assertFalse(vm.paused)
+    }
+
+    @Test fun noMatchShowsMessageAndWritesNothing() {
+        startSession()
+        vm.setScanning(true)
+        scan("nope")
+        await { sessionState()?.message?.contains("nope") == true }
+        assertTrue(sessionState()!!.lines.isEmpty())
+        assertNull(sessionState()!!.pendingUnexpected)
+    }
+
+    @Test fun multipleMatchesAskThenCountChosenItem() {
+        startSession()
+        vm.addExpected(saw)
+        await { line("saw") != null }
+        vm.setScanning(true)
+        scan("999")
+        await { sessionState()?.choices?.size == 2 }
+        vm.choose("saw")
+        await { line("saw")?.discrepancy?.receivedQty == 1 }
+        assertNull(sessionState()!!.choices)
+    }
+
+    @Test fun sameCodeInFrameIsNotCountedTwice() {
+        startSession()
+        vm.addExpected(drill)
+        await { line("drill") != null }
+        vm.setScanning(true)
+        scan("111")
+        await { line("drill")?.discrepancy?.receivedQty == 1 }
+        clock += 1_000
+        vm.onBarcodes(code("111"))
+        assertFalse("a repeat in the suppression window starts no resolve", vm.paused)
+        Thread.sleep(200)
+        assertEquals(1, line("drill")!!.discrepancy.receivedQty)
+    }
+
+    @Test fun checkInQueuesAdjustmentsAndStampsAndSyncsOnce() {
+        val id = startSession()
+        vm.addExpected(drill)
+        vm.addExpected(saw)
+        await { sessionState()!!.lines.size == 2 }
+        vm.setReceived("drill", 3)
+        await { line("drill")!!.discrepancy.receivedQty == 3 }
+
+        vm.requestCheckIn()
+        await { sessionState()!!.confirmingCheckIn }
+        vm.confirmCheckIn()
+        vm.confirmCheckIn()
+        await { sessionState()!!.checkedIn }
+
+        assertNull(sessionState()!!.checkInError)
+        assertEquals(ReceivingStatus.COMPLETED, sessionState()!!.session.status)
+        val rows = runBlocking { db.outboxDao().getAllOrdered() }.map { LocalMutation.from(it) }
+        val adjustments = rows.filter { it.entityType == "stock_adjustment" }
+        assertEquals(1, adjustments.size)
+        assertEquals("3", (adjustments.single().fields["delta"] as JsonPrimitive).content)
+        assertEquals(1, rows.count { it.entityType == "purchased_from_block" })
+        assertEquals(1, syncCalls)
+        assertEquals(id, sessionState()!!.session.id)
+    }
+
+    @Test fun repeatCheckInIsAlreadyCompletedAndWritesNothingMore() {
+        startSession()
+        vm.addExpected(drill)
+        await { line("drill") != null }
+        vm.setReceived("drill", 1)
+        await { line("drill")!!.discrepancy.receivedQty == 1 }
+        vm.confirmCheckIn()
+        await { sessionState()!!.checkedIn }
+        val before = runBlocking { db.outboxDao().getAllOrdered() }.size
+
+        vm.confirmCheckIn()
+        await { sessionState()!!.checkInError != null }
+        assertTrue(sessionState()!!.checkInError!!.contains("already"))
+        assertEquals(before, runBlocking { db.outboxDao().getAllOrdered() }.size)
+        assertEquals(1, syncCalls)
+    }
+
+    @Test fun cancelClosesSessionAndReturnsToList() {
+        val id = startSession()
+        vm.requestCancel()
+        await { sessionState()!!.confirmingCancel }
+        vm.confirmCancel()
+        await { vm.mode.value == ReceivingMode.Sessions }
+        val stored = runBlocking { db.receivingDao().getSession(id) }
+        assertEquals(ReceivingStatus.CANCELLED, stored!!.status)
+        await { vm.openSessions.value.isEmpty() }
+        assertTrue(runBlocking { db.outboxDao().getAllOrdered() }.isEmpty())
+        assertEquals(0, syncCalls)
+    }
+
+    @Test fun severalOpenSessionsCanBeSwitched() {
+        val first = startSession(vendor = "One")
+        vm.showSessions()
+        val second = startSession(vendor = "Two")
+        await { vm.openSessions.value.size == 2 }
+        vm.openSession(first)
+        await { sessionState()?.session?.id == first }
+        vm.openSession(second)
+        await { sessionState()?.session?.id == second }
+    }
+
+    @Test fun burstOfTapsBeforeReEmitLandsExactly() {
+        val sid = startSession()
+        vm.addExpected(drill)
+        await { line("drill") != null }
+        repeat(25) { vm.increment("drill") }
+        await { line("drill")!!.discrepancy.receivedQty == 25 }
+        repeat(10) { vm.decrement("drill") }
+        await { line("drill")!!.discrepancy.receivedQty == 15 }
+        assertEquals(15, runBlocking { db.receivingDao().getLine(sid, "drill")!!.receivedQty })
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/scan/ScanResolverTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/scan/ScanResolverTest.kt
new file mode 100644
index 0000000..cb7cb79
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/scan/ScanResolverTest.kt
@@ -0,0 +1,95 @@
+package dev.hho.android.ui.scan
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.items.ItemSearch
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemIdentificationEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.ui.deeplink.DeepLinkResolver
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ScanResolverTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var resolver: ScanResolver
+    private val id = "0190a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5b"
+
+    private fun item(id: String, name: String, code: String? = null) = ItemEntity(
+        id = id, groupChangeSeq = 1, name = name, description = null, locationId = null,
+        quantity = null, shortCode = code, createdAt = null, updatedAt = null, version = null,
+    )
+
+    private fun ident(rowId: String, itemId: String, value: String) = ItemIdentificationEntity(
+        id = rowId, groupChangeSeq = 1L, itemId = itemId, kind = "barcode", value = value,
+        createdAt = 1L, updatedAt = 1L, version = 1L,
+    )
+
+    @Before fun setUp() {
+        db = inMemoryHhoDatabase()
+        resolver = ScanResolver(DeepLinkResolver(db.itemDao()), ItemSearch(db.itemDao()), db.itemDao())
+    }
+
+    @After fun tearDown() = db.close()
+
+    @Test fun labelUrlByIdResolvesToSingle() = runTest {
+        val a = item(id, "Drill", "AB-1")
+        db.itemDao().upsert(a)
+        assertEquals(ScanResolution.Single(a), resolver.resolve("https://hho.example.com/i/$id"))
+    }
+
+    @Test fun labelUrlByShortCodeResolvesToSingle() = runTest {
+        val a = item(id, "Drill", "AB-1")
+        db.itemDao().upsert(a)
+        assertEquals(ScanResolution.Single(a), resolver.resolve("http://192.168.1.5:7745/i/AB-1"))
+    }
+
+    @Test fun unknownLabelUrlIsNoMatchEvenIfSomeItemHasThatIdentifier() = runTest {
+        val url = "https://hho.example.com/i/$id"
+        db.itemDao().upsert(item("other", "Saw"))
+        db.itemIdentificationDao().upsert(ident("i1", "other", url))
+        val resolution = resolver.resolve(url)
+        assertEquals(ScanResolution.NoMatch(url), resolution)
+        assertFalse((resolution as ScanResolution.NoMatch).canCreate)
+    }
+
+    @Test fun identifierSingleMatch() = runTest {
+        val a = item("a", "Saw")
+        db.itemDao().upsert(a)
+        db.itemDao().upsert(item("b", "Hammer"))
+        db.itemIdentificationDao().upsert(ident("i1", "a", "4006381333931"))
+        assertEquals(ScanResolution.Single(a), resolver.resolve("4006381333931"))
+    }
+
+    @Test fun identifierMultipleMatches() = runTest {
+        val a = item("a", "Saw")
+        val b = item("b", "Hammer")
+        db.itemDao().upsert(a)
+        db.itemDao().upsert(b)
+        db.itemIdentificationDao().upsert(ident("i1", "a", "123"))
+        db.itemIdentificationDao().upsert(ident("i2", "b", "123"))
+        val result = resolver.resolve("123") as ScanResolution.Multiple
+        assertEquals(setOf("a", "b"), result.items.map { it.id }.toSet())
+    }
+
+    @Test fun identifierNoneAndCaseSensitive() = runTest {
+        db.itemDao().upsert(item("a", "Saw"))
+        db.itemIdentificationDao().upsert(ident("i1", "a", "abc"))
+        assertEquals(ScanResolution.NoMatch("ABC"), resolver.resolve("ABC"))
+        assertEquals(ScanResolution.NoMatch("999"), resolver.resolve("999"))
+    }
+
+    @Test fun plainUnmatchedValueCanBeCreated() = runTest {
+        val resolution = resolver.resolve("4006381333931") as ScanResolution.NoMatch
+        assertTrue(resolution.canCreate)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/scan/ScanViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/scan/ScanViewModelTest.kt
new file mode 100644
index 0000000..498e87f
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/scan/ScanViewModelTest.kt
@@ -0,0 +1,208 @@
+package dev.hho.android.ui.scan
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.items.ItemSearch
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.ItemIdentificationEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.scanner.BarcodeFormat
+import dev.hho.android.data.scanner.DecodedBarcode
+import dev.hho.android.ui.deeplink.DeepLinkResolver
+import dev.hho.android.data.ids.UuidV7Generator
+import dev.hho.android.data.outbox.OutboxRepository
+import dev.hho.android.domain.EditRepository
+import dev.hho.android.ui.items.StockActionsViewModel
+import dev.hho.android.ui.items.ViewModelTracker
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ScanViewModelTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var vm: ScanViewModel
+    private var clock = 0L
+    private var syncCalls = 0
+    private val viewModels = ViewModelTracker()
+
+    private fun awaitSheet(): ScanUiState.Sheet = kotlinx.coroutines.runBlocking {
+        kotlinx.coroutines.withTimeout(10_000) { vm.uiState.first { it is ScanUiState.Sheet } as ScanUiState.Sheet }
+    }
+
+    private fun code(v: String) = listOf(DecodedBarcode(v, BarcodeFormat.QR_CODE))
+
+    @Before fun setUp() = kotlinx.coroutines.runBlocking {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+        db = inMemoryHhoDatabase()
+        db.itemDao().upsert(
+            ItemEntity("a", 1, "Saw", null, null, null, null, null, null, null),
+        )
+        db.itemIdentificationDao().upsert(
+            ItemIdentificationEntity("i1", 1L, "a", "barcode", "123", 1L, 1L, 1L),
+        )
+        vm = viewModels.track(
+            ScanViewModel(ScanResolver(DeepLinkResolver(db.itemDao()), ItemSearch(db.itemDao()), db.itemDao())),
+        )
+        vm.nowMillis = { clock }
+    }
+
+    @After fun tearDown() {
+        viewModels.cancelAll()
+        db.close()
+        Dispatchers.resetMain()
+    }
+
+    @Test fun startsScanningNotPaused() {
+        assertEquals(ScanUiState.Scanning, vm.uiState.value)
+        assertFalse(vm.paused)
+    }
+
+    @Test fun matchOpensSheetAndPausesAnalysis() {
+        vm.onBarcodes(code("123"))
+        val sheet = awaitSheet()
+        assertEquals("123", sheet.value)
+        assertTrue(sheet.resolution is ScanResolution.Single)
+        assertTrue(vm.paused)
+    }
+
+    @Test fun noMatchOpensSheetWithNoMatch() {
+        vm.onBarcodes(code("nope"))
+        assertEquals(ScanResolution.NoMatch("nope"), awaitSheet().resolution)
+    }
+
+    @Test fun detectionsWhileSheetOpenAreDropped() {
+        vm.onBarcodes(code("123"))
+        val first = awaitSheet()
+        vm.onBarcodes(code("nope"))
+        assertEquals(first, vm.uiState.value)
+    }
+
+    @Test fun sameCodeStillInFrameDoesNotReopenAfterDismiss() {
+        vm.onBarcodes(code("123"))
+        awaitSheet()
+        vm.dismissSheet()
+        assertFalse(vm.paused)
+        clock += 1_000
+        vm.onBarcodes(code("123"))
+        assertEquals(ScanUiState.Scanning, vm.uiState.value)
+        assertFalse("a suppressed repeat must not start a resolve", vm.paused)
+        clock += 2_500
+        vm.onBarcodes(code("123"))
+        assertEquals(ScanUiState.Scanning, vm.uiState.value)
+        assertFalse("a suppressed repeat must not start a resolve", vm.paused)
+    }
+
+    @Test fun sameCodeReopensAfterLeavingFrameForWindow() {
+        vm.onBarcodes(code("123"))
+        awaitSheet()
+        vm.dismissSheet()
+        clock += ScanViewModel.REPEAT_SUPPRESSION_MILLIS + 1
+        vm.onBarcodes(code("123"))
+        awaitSheet()
+    }
+
+    @Test fun differentCodeOpensImmediatelyAfterDismiss() {
+        vm.onBarcodes(code("123"))
+        awaitSheet()
+        vm.dismissSheet()
+        vm.onBarcodes(code("nope"))
+        awaitSheet()
+    }
+
+    @Test fun chooseNarrowsMultipleToSingle() = kotlinx.coroutines.runBlocking {
+        db.itemDao().upsert(ItemEntity("b", 1, "Hammer", null, null, null, null, null, null, null))
+        db.itemIdentificationDao().upsert(ItemIdentificationEntity("i2", 1L, "b", "barcode", "123", 1L, 1L, 1L))
+        vm.onBarcodes(code("123"))
+        assertTrue(awaitSheet().resolution is ScanResolution.Multiple)
+        vm.choose("b")
+        val single = (vm.uiState.value as ScanUiState.Sheet).resolution as ScanResolution.Single
+        assertEquals("b", single.item.id)
+    }
+
+    private fun <T> next(flow: kotlinx.coroutines.flow.Flow<T>): T = kotlinx.coroutines.runBlocking {
+        kotlinx.coroutines.withTimeout(10_000) { flow.first() }
+    }
+
+    @Test fun createItemEmitsPrefillWithRawScannedValueAndClosesSheet() {
+        vm.onBarcodes(code("  4006381333931 "))
+        awaitSheet()
+        vm.createItem()
+        assertEquals(
+            ScanEvent.CreateItem("barcode", "  4006381333931 "),
+            next(vm.events),
+        )
+        assertEquals(ScanUiState.Scanning, vm.uiState.value)
+        assertFalse(vm.paused)
+    }
+
+    @Test fun createItemIsIgnoredForUnresolvedHhoLabel() {
+        val url = "https://hho.example.com/i/0190a1b2-c3d4-7e5f-8a9b-0c1d2e3f4a5b"
+        vm.onBarcodes(code(url))
+        val sheet = awaitSheet()
+        assertFalse((sheet.resolution as ScanResolution.NoMatch).canCreate)
+        vm.createItem()
+        assertEquals(sheet, vm.uiState.value)
+        assertTrue(kotlinx.coroutines.runBlocking { vm.events.isEmptyNow() })
+    }
+
+    @Test fun createItemIsIgnoredOnMatchSheet() {
+        vm.onBarcodes(code("123"))
+        val sheet = awaitSheet()
+        vm.createItem()
+        assertEquals(sheet, vm.uiState.value)
+        assertTrue(kotlinx.coroutines.runBlocking { vm.events.isEmptyNow() })
+    }
+
+    @Test fun adjustQuantityFromMatchedSheetQueuesAdjustmentThenResumesScanning() {
+        vm.onBarcodes(code("123"))
+        val item = (awaitSheet().resolution as ScanResolution.Single).item
+        val ids = UuidV7Generator()
+        val stock = viewModels.track(
+            StockActionsViewModel(EditRepository(db, OutboxRepository(db, ids), ids) { syncCalls++ }),
+        )
+        assertTrue(vm.paused)
+        stock.submit(item.id, 2L, "Used", "")
+        val done = kotlinx.coroutines.runBlocking {
+            kotlinx.coroutines.withTimeout(10_000) { stock.state.first { it.completed } }
+        }
+        assertTrue(done.completed)
+        assertEquals(1, syncCalls)
+        assertEquals(1, kotlinx.coroutines.runBlocking { db.outboxDao().getAllOrdered().size })
+        vm.dismissSheet()
+        assertFalse(vm.paused)
+    }
+
+    @Test fun adjustQuantityAfterChoosingFromMultipleTargetsChosenItem() = kotlinx.coroutines.runBlocking {
+        db.itemDao().upsert(ItemEntity("b", 1, "Hammer", null, null, null, null, null, null, null))
+        db.itemIdentificationDao().upsert(ItemIdentificationEntity("i2", 1L, "b", "barcode", "123", 1L, 1L, 1L))
+        vm.onBarcodes(code("123"))
+        awaitSheet()
+        vm.choose("b")
+        val target = ((vm.uiState.value as ScanUiState.Sheet).resolution as ScanResolution.Single).item.id
+        val ids = UuidV7Generator()
+        val stock = viewModels.track(
+            StockActionsViewModel(EditRepository(db, OutboxRepository(db, ids), ids) { syncCalls++ }),
+        )
+        stock.submit(target, -1L, "", "")
+        kotlinx.coroutines.withTimeout(10_000) { stock.state.first { it.completed } }
+        val fields = dev.hho.android.data.outbox.LocalMutation.from(db.outboxDao().getAllOrdered().single()).fields
+        assertEquals("b", (fields["item_id"] as kotlinx.serialization.json.JsonPrimitive).content)
+    }
+}
+
+private suspend fun kotlinx.coroutines.flow.Flow<*>.isEmptyNow(): Boolean =
+    kotlinx.coroutines.withTimeoutOrNull(200) { first() } == null
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/syncstatus/ConflictLogViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/syncstatus/ConflictLogViewModelTest.kt
new file mode 100644
index 0000000..4883f1c
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/syncstatus/ConflictLogViewModelTest.kt
@@ -0,0 +1,136 @@
+package dev.hho.android.ui.syncstatus
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.ConflictOrigin
+import dev.hho.android.data.room.ConflictRecordEntity
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.StockAdjustmentEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.ui.items.ViewModelTracker
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import kotlinx.coroutines.withTimeout
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class ConflictLogViewModelTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var vm: ConflictLogViewModel
+    private val viewModels = ViewModelTracker()
+
+    @Before fun setUp() {
+        Dispatchers.setMain(UnconfinedTestDispatcher())
+        db = inMemoryHhoDatabase()
+        vm = viewModels.track(ConflictLogViewModel(db.conflictRecordDao()))
+    }
+
+    @After fun tearDown() {
+        collector.cancel()
+        viewModels.cancelAll()
+        db.close()
+        Dispatchers.resetMain()
+    }
+
+    private fun await(condition: () -> Boolean) = runBlocking {
+        withTimeout(10_000) { while (!condition()) kotlinx.coroutines.delay(10) }
+    }
+
+    private val collector by lazy {
+        kotlinx.coroutines.CoroutineScope(Dispatchers.Unconfined).launch { vm.state.collect { } }
+    }
+
+    private fun rows(expected: Int): List<ConflictUi> {
+        collector
+        await { vm.state.value.size == expected }
+        return vm.state.value
+    }
+
+    private fun conflict(
+        mutation: String = "m1",
+        type: String = "item",
+        entity: String = "item-1",
+        field: String = "name",
+        losing: String? = "\"mine\"",
+        server: String? = "\"theirs\"",
+        at: Long = 100L,
+        origin: String = ConflictOrigin.LOCAL_PUSH,
+    ) = ConflictRecordEntity(
+        mutationId = mutation, entityType = type, entityId = entity, fieldName = field,
+        losingValueJson = losing, serverValueJson = server, detectedAt = at, origin = origin,
+    )
+
+    private fun insert(vararg c: ConflictRecordEntity) = runBlocking { c.forEach { db.conflictRecordDao().insertIgnore(it) } }
+
+    private fun item(id: String, name: String) = ItemEntity(id, 1, name, null, null, 0, null, 1, 1, 1)
+
+    @Test fun `newest first with item name and child type resolved via item id`() {
+        runBlocking {
+            db.itemDao().upsert(item("item-1", "Drill"))
+            db.stockAdjustmentDao().upsert(StockAdjustmentEntity("adj-1", 1, "item-1", 1, 1, null, null, 1, 1, 1))
+        }
+        insert(
+            conflict(mutation = "old", at = 100),
+            conflict(mutation = "new", type = "stock_adjustment", entity = "adj-1", field = "delta", at = 300),
+            conflict(mutation = "mid", type = "purchased_from_block", entity = "abcdefghijk", field = "vendor", at = 200),
+        )
+        val r = rows(3)
+        assertEquals(listOf(300L, 200L, 100L), r.map { it.detectedAt })
+        assertEquals("Drill", r[0].entityLabel)
+        assertEquals("purchased_from_block abcdefgh", r[1].entityLabel)
+        assertEquals("Drill", r[2].entityLabel)
+        assertEquals("Rejected when this device pushed", r[2].originLabel)
+    }
+
+    @Test fun `whole entity sentinel is labelled whole item`() {
+        insert(conflict(field = "_entity", losing = "{\"name\":\"x\"}", server = null))
+        val c = rows(1).single()
+        assertEquals("whole item", c.fieldLabel)
+        assertEquals("{\"name\":\"x\"}", c.rejectedValue)
+        assertEquals("not yet known", c.keptValue)
+    }
+
+    @Test fun `json values render plainly`() {
+        assertEquals("mine", renderJsonValue("\"mine\"", "n/a"))
+        assertEquals("42", renderJsonValue("42", "n/a"))
+        assertEquals("true", renderJsonValue("true", "n/a"))
+        assertEquals("—", renderJsonValue("null", "n/a"))
+        assertEquals("n/a", renderJsonValue(null, "n/a"))
+        assertEquals("{\"a\":1}", renderJsonValue("{ \"a\" : 1 }", "n/a"))
+        assertEquals("not json {", renderJsonValue("not json {", "n/a"))
+    }
+
+    @Test fun `synthetic server mutation id is not shown`() {
+        insert(
+            conflict(mutation = "server:77", origin = ConflictOrigin.SERVER_LOG, entity = "a"),
+            conflict(mutation = "real-1", entity = "b", at = 50),
+        )
+        val r = rows(2)
+        assertNull(r[0].mutationId)
+        assertEquals("From the server log (any device in the group)", r[0].originLabel)
+        assertEquals("real-1", r[1].mutationId)
+    }
+
+    @Test fun `live update when a row is inserted and empty state before`() {
+        collector
+        assertTrue(vm.state.value.isEmpty())
+        insert(conflict())
+        assertEquals(1, rows(1).size)
+        insert(conflict(mutation = "m2", at = 900))
+        assertEquals(900L, rows(2).first().detectedAt)
+    }
+}
diff --git a/android-app/app/src/test/kotlin/dev/hho/android/ui/syncstatus/SyncStatusViewModelTest.kt b/android-app/app/src/test/kotlin/dev/hho/android/ui/syncstatus/SyncStatusViewModelTest.kt
new file mode 100644
index 0000000..f40182b
--- /dev/null
+++ b/android-app/app/src/test/kotlin/dev/hho/android/ui/syncstatus/SyncStatusViewModelTest.kt
@@ -0,0 +1,168 @@
+package dev.hho.android.ui.syncstatus
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import dev.hho.android.data.room.HhoDatabase
+import dev.hho.android.data.room.ItemEntity
+import dev.hho.android.data.room.OutboxMutationEntity
+import dev.hho.android.data.room.OutboxState
+import dev.hho.android.data.room.PhotoQueueEntryEntity
+import dev.hho.android.data.room.PhotoState
+import dev.hho.android.data.room.SyncRunStateEntity
+import dev.hho.android.data.room.inMemoryHhoDatabase
+import dev.hho.android.data.sync.PhotoQueueStatus
+import dev.hho.android.data.sync.SyncStatusRepository
+import dev.hho.android.ui.items.ViewModelTracker
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import kotlinx.coroutines.withTimeout
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [36])
+class SyncStatusViewModelTest {
+    private lateinit var db: HhoDatabase
+    private lateinit var vm: SyncStatusViewModel
+    private lateinit var dispatcher: kotlinx.coroutines.test.TestDispatcher
+    private var syncCalls = 0
+    private val viewModels = ViewModelTracker()
+
+    @Before fun setUp() {
+        dispatcher = UnconfinedTestDispatcher()
+        Dispatchers.setMain(dispatcher)
+        db = inMemoryHhoDatabase()
+        val photoStatus = object : PhotoQueueStatus {
+            override fun observePendingCount(): Flow<Int> =
+                db.photoQueueDao().observeCount(listOf(PhotoState.QUEUED, PhotoState.UPLOADING, PhotoState.WAITING_PARENT))
+
+            override fun observeFailedCount(): Flow<Int> = db.photoQueueDao().observeCount(listOf(PhotoState.FAILED))
+        }
+        vm = viewModels.track(
+            SyncStatusViewModel(
+                SyncStatusRepository(db.outboxDao(), photoStatus, db.syncRunStateDao()),
+                db.outboxDao(),
+                db.photoQueueDao(),
+                db.itemDao(),
+                db.conflictRecordDao(),
+            ) { syncCalls++ },
+        )
+    }
+
+    @After fun tearDown() {
+        viewModels.cancelAll()
+        db.close()
+        Dispatchers.resetMain()
+    }
+
+    private fun await(condition: () -> Boolean) = runBlocking {
+        withTimeout(10_000) { while (!condition()) kotlinx.coroutines.delay(10) }
+    }
+
+    private fun subscribe() = runBlocking { vm.state.first() }
+
+    private fun outbox(id: String, type: String, entity: String, state: String, error: String? = null, fields: String = "{}") =
+        OutboxMutationEntity(
+            mutationId = id, entityType = type, entityId = entity, op = "upsert", baseVersion = 1,
+            fieldsJson = fields, state = state, lastError = error, lastAttemptAt = 500L, createdAt = 100L,
+        )
+
+    private fun photo(id: String, item: String, state: String, error: String? = null, attempts: Int = 0) =
+        PhotoQueueEntryEntity(id, item, "/x/$id", "sha", 1, "photo", state, attempts, null, error, 10L)
+
+    private fun item(id: String, name: String) = ItemEntity(id, 1, name, null, null, 0, null, 1, 1, 1)
+
+    @Test fun noFailureShowsEmptyUpToDateState() {
+        subscribe()
+        val ui = vm.state.value
+        assertEquals(SyncHeadline.UP_TO_DATE, ui.headline)
+        assertTrue(ui.failedMutations.isEmpty() && ui.failedPhotos.isEmpty())
+        assertNull(ui.status.lastSyncedAt)
+    }
+
+    @Test fun statusReflectsOutboxPhotoAndRunStateLive() = runBlocking {
+        subscribe()
+        db.outboxDao().insert(outbox("m1", "item", "i1", OutboxState.PENDING))
+        db.photoQueueDao().insert(photo("p1", "i1", PhotoState.QUEUED))
+        await { vm.state.value.status.pendingCount == 1 && vm.state.value.status.photoQueueDepth == 1 }
+        assertEquals(SyncHeadline.PENDING, vm.state.value.headline)
+
+        db.syncRunStateDao().upsert(SyncRunStateEntity(lastRunAt = 9_000L))
+        await { vm.state.value.status.lastSyncedAt == 9_000L }
+
+        db.outboxDao().markFailed("m1", "boom")
+        await { vm.state.value.headline == SyncHeadline.PROBLEM }
+        assertEquals(0, vm.state.value.status.pendingCount)
+    }
+
+    @Test fun failuresListShowsItemNamesAndSanitizedErrors() = runBlocking {
+        db.itemDao().upsert(item("drill", "Drill"))
+        db.itemDao().upsert(item("saw", "Saw"))
+        db.outboxDao().insert(outbox("m1", "item", "drill", OutboxState.FAILED, "Unreadable local edit: bad json"))
+        db.outboxDao().insert(
+            outbox("m2", "stock_adjustment", "adj1", OutboxState.FAILED, "rejected: unknown field", """{"item_id":"saw","delta":2}"""),
+        )
+        db.outboxDao().insert(outbox("m3", "label", "lbl-9", OutboxState.FAILED, "gone"))
+        db.outboxDao().insert(outbox("m4", "item", "drill", OutboxState.PENDING))
+        db.photoQueueDao().insert(photo("p1", "saw", PhotoState.FAILED, "file missing", 5))
+        db.photoQueueDao().insert(photo("p2", "ghost", PhotoState.FAILED, null, 2))
+        db.photoQueueDao().insert(photo("p3", "saw", PhotoState.QUEUED))
+        subscribe()
+        await { vm.state.value.failedMutations.size == 3 && vm.state.value.failedPhotos.size == 2 }
+
+        val ui = vm.state.value
+        assertEquals(
+            listOf("item: Drill", "stock_adjustment: Saw", "label: lbl-9"),
+            ui.failedMutations.map { it.label },
+        )
+        assertEquals("Unreadable local edit: bad json", ui.failedMutations[0].error)
+        assertEquals(500L, ui.failedMutations[0].at)
+        assertEquals(listOf("Saw", "ghost"), ui.failedPhotos.map { it.itemName })
+        assertEquals("file missing", ui.failedPhotos[0].error)
+        assertEquals(5, ui.failedPhotos[0].attempts)
+        assertEquals(5, ui.status.failedCount)
+        assertEquals(1, ui.status.pendingCount)
+    }
+
+    @Test fun lastErrorFrom426RunIsShown() = runBlocking {
+        subscribe()
+        db.syncRunStateDao().upsert(
+            SyncRunStateEntity(lastRunAt = 7_000L, lastError = "Client too old: server requires at least 1.4.0", lastErrorAt = 7_000L),
+        )
+        await { vm.state.value.status.lastError != null }
+        val ui = vm.state.value
+        assertEquals("Client too old: server requires at least 1.4.0", ui.status.lastError)
+        assertNull(ui.status.lastSyncedAt)
+        assertEquals(SyncHeadline.PROBLEM, ui.headline)
+    }
+
+    @Test fun syncNowCallsSchedulerOncePerClickAndGuardsDoubleClicks() {
+        assertFalse(vm.syncing.value)
+        vm.onSyncNow()
+        vm.onSyncNow()
+        vm.onSyncNow()
+        assertEquals(1, syncCalls)
+        assertTrue(vm.syncing.value)
+
+        val scope = TestScope(dispatcher.scheduler)
+        scope.advanceTimeBy(2_000L)
+        assertFalse(vm.syncing.value)
+        vm.onSyncNow()
+        assertEquals(2, syncCalls)
+    }
+}
diff --git a/android-app/app/src/test/resources/golden/stocktake-expected-state.json b/android-app/app/src/test/resources/golden/stocktake-expected-state.json
new file mode 100644
index 0000000..253cc7c
--- /dev/null
+++ b/android-app/app/src/test/resources/golden/stocktake-expected-state.json
@@ -0,0 +1,248 @@
+{
+  "items": [
+    {
+      "id": "00000000-0000-7000-8000-000100000001",
+      "name": "Item 01",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 8
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000002",
+      "name": "Item 02",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 18
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000003",
+      "name": "Item 03",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 14
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000004",
+      "name": "Item 04",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 8
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000005",
+      "name": "Item 05",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 26
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000006",
+      "name": "Item 06 (counted)",
+      "description": "recounted 06",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000007",
+      "name": "Item 07 (counted)",
+      "description": "recounted 07",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000008",
+      "name": "Item 08 (counted)",
+      "description": "recounted 08",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000009",
+      "name": "Item 09 (counted)",
+      "description": "recounted 09",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000010",
+      "name": "Item 10 (counted)",
+      "description": "recounted 10",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000011",
+      "name": "Item 11 (counted)",
+      "description": "recounted 11",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000012",
+      "name": "Item 12 (counted)",
+      "description": "recounted 12",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000013",
+      "name": "Item 13 (counted)",
+      "description": "recounted 13",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000014",
+      "name": "Item 14 (counted)",
+      "description": "recounted 14",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000015",
+      "name": "Item 15 (counted)",
+      "description": "recounted 15",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000016",
+      "name": "Item 16 (counted)",
+      "description": "recounted 16",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000017",
+      "name": "Item 17 (counted)",
+      "description": "recounted 17",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000018",
+      "name": "Item 18",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000002",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000019",
+      "name": "Item 19",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000003",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000020",
+      "name": "Item 20",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000004",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000021",
+      "name": "Item 21",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000002",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000022",
+      "name": "Item 22",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000003",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000023",
+      "name": "Item 23",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000004",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000024",
+      "name": "Item 24",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000002",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000025",
+      "name": "Item 25",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000003",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000026",
+      "name": "Item 26",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000004",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000027",
+      "name": "Item 27",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000002",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000028",
+      "name": "Item 28",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000029",
+      "name": "Item 29",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    },
+    {
+      "id": "00000000-0000-7000-8000-000100000030",
+      "name": "Item 30",
+      "description": "seed",
+      "location_id": "00000000-0000-7000-8000-000200000001",
+      "quantity": 10
+    }
+  ],
+  "item_labels": [
+    {
+      "item_id": "00000000-0000-7000-8000-000100000001",
+      "label_id": "00000000-0000-7000-8000-000300000001"
+    },
+    {
+      "item_id": "00000000-0000-7000-8000-000100000002",
+      "label_id": "00000000-0000-7000-8000-000300000001"
+    },
+    {
+      "item_id": "00000000-0000-7000-8000-000100000028",
+      "label_id": "00000000-0000-7000-8000-000300000003"
+    },
+    {
+      "item_id": "00000000-0000-7000-8000-000100000028",
+      "label_id": "00000000-0000-7000-8000-000300000004"
+    },
+    {
+      "item_id": "00000000-0000-7000-8000-000100000029",
+      "label_id": "00000000-0000-7000-8000-000300000003"
+    },
+    {
+      "item_id": "00000000-0000-7000-8000-000100000029",
+      "label_id": "00000000-0000-7000-8000-000300000004"
+    },
+    {
+      "item_id": "00000000-0000-7000-8000-000100000030",
+      "label_id": "00000000-0000-7000-8000-000300000003"
+    },
+    {
+      "item_id": "00000000-0000-7000-8000-000100000030",
+      "label_id": "00000000-0000-7000-8000-000300000004"
+    }
+  ]
+}
diff --git a/android-app/app/src/test/resources/golden/stocktake-push-request.json b/android-app/app/src/test/resources/golden/stocktake-push-request.json
new file mode 100644
index 0000000..f319115
--- /dev/null
+++ b/android-app/app/src/test/resources/golden/stocktake-push-request.json
@@ -0,0 +1,560 @@
+{
+  "device_id": "stocktake-device-1",
+  "mutations": [
+    {
+      "mutation_id": "019e7044-8801-70b6-9c9f-108f9d9a3fbd",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70b6-ab3c-f3701fd0089c",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000001",
+        "delta": 4,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70b7-b5b6-895ff26d9de7",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000006",
+      "base_version": 1,
+      "fields": {
+        "name": "Item 06 (counted)",
+        "description": "recounted 06"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70b8-b85d-371ce2496990",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000018",
+      "base_version": 1,
+      "fields": {
+        "location_id": "00000000-0000-7000-8000-000200000002"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70b9-9ab3-4b452cb0e5d2",
+      "entity_type": "item_label",
+      "entity_id": "019e7044-8800-70b7-9cf4-23daa86aa6fa",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000028",
+        "label_id": "00000000-0000-7000-8000-000300000003"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70ba-b3bc-b0fc49e49440",
+      "entity_type": "item_label",
+      "entity_id": "00000000-0000-7000-8000-000400000001",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000028",
+        "label_id": "00000000-0000-7000-8000-000300000001"
+      },
+      "op": "delete"
+    },
+    {
+      "mutation_id": "019e7044-8801-70bb-874c-70182c05c5cf",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70b8-a6d7-91403b13ed19",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000002",
+        "delta": -3,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70bc-867a-c65976722ae7",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000007",
+      "base_version": 1,
+      "fields": {
+        "name": "Item 07 (counted)",
+        "description": "recounted 07"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70bd-bcfd-bb17e56ea549",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000019",
+      "base_version": 1,
+      "fields": {
+        "location_id": "00000000-0000-7000-8000-000200000003"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70be-b00e-7ef3414642a9",
+      "entity_type": "item_label",
+      "entity_id": "019e7044-8800-70b9-bad9-6dd449034499",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000028",
+        "label_id": "00000000-0000-7000-8000-000300000004"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70bf-b2e6-583b67052530",
+      "entity_type": "item_label",
+      "entity_id": "00000000-0000-7000-8000-000400000002",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000028",
+        "label_id": "00000000-0000-7000-8000-000300000002"
+      },
+      "op": "delete"
+    },
+    {
+      "mutation_id": "019e7044-8801-70c0-afc3-fe33add2c73d",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70ba-bd5d-d3eb4eaddd16",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000003",
+        "delta": 7,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70c1-821a-686312998a20",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000008",
+      "base_version": 1,
+      "fields": {
+        "name": "Item 08 (counted)",
+        "description": "recounted 08"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70c2-8529-0c814caf6bab",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000020",
+      "base_version": 1,
+      "fields": {
+        "location_id": "00000000-0000-7000-8000-000200000004"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70c3-9f04-9ccea4dc24c2",
+      "entity_type": "item_label",
+      "entity_id": "019e7044-8800-70bb-ba77-c76ce8529295",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000029",
+        "label_id": "00000000-0000-7000-8000-000300000003"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70c4-a4a8-61d33f296356",
+      "entity_type": "item_label",
+      "entity_id": "00000000-0000-7000-8000-000400000003",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000029",
+        "label_id": "00000000-0000-7000-8000-000300000001"
+      },
+      "op": "delete"
+    },
+    {
+      "mutation_id": "019e7044-8801-70c5-8581-95d37a0a5c72",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70bc-aa39-5ceb53e77f77",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000004",
+        "delta": -2,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70c6-b3f6-85867227273d",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000009",
+      "base_version": 1,
+      "fields": {
+        "name": "Item 09 (counted)",
+        "description": "recounted 09"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70c7-81c5-f8cb648f4022",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000021",
+      "base_version": 1,
+      "fields": {
+        "location_id": "00000000-0000-7000-8000-000200000002"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70c8-b8cc-576f912ccb7d",
+      "entity_type": "item_label",
+      "entity_id": "019e7044-8800-70bd-b3b6-99bc19aa6d42",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000029",
+        "label_id": "00000000-0000-7000-8000-000300000004"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70c9-9bbb-714d66a1c17d",
+      "entity_type": "item_label",
+      "entity_id": "00000000-0000-7000-8000-000400000004",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000029",
+        "label_id": "00000000-0000-7000-8000-000300000002"
+      },
+      "op": "delete"
+    },
+    {
+      "mutation_id": "019e7044-8801-70ca-8798-9634d411a91a",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70be-99f0-92d03e12fccd",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000005",
+        "delta": 5,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70cb-9c90-119ca3e8fe4e",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000010",
+      "base_version": 1,
+      "fields": {
+        "name": "Item 10 (counted)",
+        "description": "recounted 10"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70cc-a092-f6da5bc05ffe",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000022",
+      "base_version": 1,
+      "fields": {
+        "location_id": "00000000-0000-7000-8000-000200000003"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70cd-a1f6-c6657dd13c23",
+      "entity_type": "item_label",
+      "entity_id": "019e7044-8800-70bf-a1d5-2c17c4e2a585",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000030",
+        "label_id": "00000000-0000-7000-8000-000300000003"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70ce-8d30-a196d0667540",
+      "entity_type": "item_label",
+      "entity_id": "00000000-0000-7000-8000-000400000005",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000030",
+        "label_id": "00000000-0000-7000-8000-000300000001"
+      },
+      "op": "delete"
+    },
+    {
+      "mutation_id": "019e7044-8801-70cf-9f4e-d1a57ac27a2d",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70c0-bd5a-b0ad55b964ec",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000001",
+        "delta": -1,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70d0-8fa3-27f05e0911aa",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000011",
+      "base_version": 1,
+      "fields": {
+        "name": "Item 11 (counted)",
+        "description": "recounted 11"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70d1-a5d3-80e7f013bd6a",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000023",
+      "base_version": 1,
+      "fields": {
+        "location_id": "00000000-0000-7000-8000-000200000004"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70d2-bf08-4805c7c8a475",
+      "entity_type": "item_label",
+      "entity_id": "019e7044-8800-70c1-a1de-dc2383d87283",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000030",
+        "label_id": "00000000-0000-7000-8000-000300000004"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70d3-a154-92b766a47b05",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70c2-82fa-e7b1bfd159ba",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000002",
+        "delta": 3,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70d4-be82-1129de756e56",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000012",
+      "base_version": 1,
+      "fields": {
+        "name": "Item 12 (counted)",
+        "description": "recounted 12"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70d5-aa0a-ff51fcb7c4fc",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000024",
+      "base_version": 1,
+      "fields": {
+        "location_id": "00000000-0000-7000-8000-000200000002"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70d6-b0d4-3db240b338bd",
+      "entity_type": "item_label",
+      "entity_id": "019e7044-8800-70c3-b5dc-520b5a06ca9b",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000001",
+        "label_id": "00000000-0000-7000-8000-000300000001"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70d7-9525-189d23431d03",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70c4-bbb9-7719aa351349",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000003",
+        "delta": -4,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70d8-869c-d6107a0abd5b",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000013",
+      "base_version": 1,
+      "fields": {
+        "name": "Item 13 (counted)",
+        "description": "recounted 13"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70d9-b7e0-3557ab9d11a8",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000025",
+      "base_version": 1,
+      "fields": {
+        "location_id": "00000000-0000-7000-8000-000200000003"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70da-880b-711eaf2b81e5",
+      "entity_type": "item_label",
+      "entity_id": "019e7044-8800-70c5-952d-350c2496d795",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000002",
+        "label_id": "00000000-0000-7000-8000-000300000001"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70db-bbb5-5b933a9609b7",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70c6-923b-de470a6c1128",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000004",
+        "delta": 6,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70dc-955b-a5c060892c18",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000014",
+      "base_version": 1,
+      "fields": {
+        "name": "Item 14 (counted)",
+        "description": "recounted 14"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70dd-8081-9e5f91c7e1df",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000026",
+      "base_version": 1,
+      "fields": {
+        "location_id": "00000000-0000-7000-8000-000200000004"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70de-b08c-81a505ab91fc",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70c7-af2a-24384b86fa1b",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000005",
+        "delta": 2,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70df-a2ea-22c94d8f4095",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000015",
+      "base_version": 1,
+      "fields": {
+        "name": "Item 15 (counted)",
+        "description": "recounted 15"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70e0-b018-196c7b390a6b",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000027",
+      "base_version": 1,
+      "fields": {
+        "location_id": "00000000-0000-7000-8000-000200000002"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70e1-8cc7-00046febc437",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70c8-8c8b-8d29a84e0cf6",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000001",
+        "delta": -5,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70e2-8b0b-85ef5836c1d4",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000016",
+      "base_version": 1,
+      "fields": {
+        "name": "Item 16 (counted)",
+        "description": "recounted 16"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70e3-aa5f-6ee574b26f75",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70c9-90e6-f779837a1067",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000002",
+        "delta": 8,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70e4-a410-e2da2473173c",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000017",
+      "base_version": 1,
+      "fields": {
+        "name": "Item 17 (counted)",
+        "description": "recounted 17"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70e5-9cf4-fc937c4ff7ec",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70ca-90cc-b6e7c84a0237",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000003",
+        "delta": 1,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70e6-8802-227d46ca4585",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70cb-85e9-8cd86aa7f43d",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000004",
+        "delta": -6,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    },
+    {
+      "mutation_id": "019e7044-8801-70e7-a0c2-b47dfe0edb13",
+      "entity_type": "stock_adjustment",
+      "entity_id": "019e7044-8800-70cc-bdbd-2ab9ba755f6a",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000005",
+        "delta": 9,
+        "reason": "stocktake"
+      },
+      "op": "upsert"
+    }
+  ]
+}
diff --git a/android-app/app/src/test/resources/golden/stocktake-seed-push-request.json b/android-app/app/src/test/resources/golden/stocktake-seed-push-request.json
new file mode 100644
index 0000000..1510240
--- /dev/null
+++ b/android-app/app/src/test/resources/golden/stocktake-seed-push-request.json
@@ -0,0 +1,491 @@
+{
+  "device_id": "stocktake-seed-device",
+  "mutations": [
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000001",
+      "entity_type": "location",
+      "entity_id": "00000000-0000-7000-8000-000200000001",
+      "base_version": 0,
+      "fields": {
+        "name": "Location 1"
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000002",
+      "entity_type": "location",
+      "entity_id": "00000000-0000-7000-8000-000200000002",
+      "base_version": 0,
+      "fields": {
+        "name": "Location 2"
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000003",
+      "entity_type": "location",
+      "entity_id": "00000000-0000-7000-8000-000200000003",
+      "base_version": 0,
+      "fields": {
+        "name": "Location 3"
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000004",
+      "entity_type": "location",
+      "entity_id": "00000000-0000-7000-8000-000200000004",
+      "base_version": 0,
+      "fields": {
+        "name": "Location 4"
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000005",
+      "entity_type": "label",
+      "entity_id": "00000000-0000-7000-8000-000300000001",
+      "base_version": 0,
+      "fields": {
+        "name": "Label 1",
+        "color": "#000001"
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000006",
+      "entity_type": "label",
+      "entity_id": "00000000-0000-7000-8000-000300000002",
+      "base_version": 0,
+      "fields": {
+        "name": "Label 2",
+        "color": "#000002"
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000007",
+      "entity_type": "label",
+      "entity_id": "00000000-0000-7000-8000-000300000003",
+      "base_version": 0,
+      "fields": {
+        "name": "Label 3",
+        "color": "#000003"
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000008",
+      "entity_type": "label",
+      "entity_id": "00000000-0000-7000-8000-000300000004",
+      "base_version": 0,
+      "fields": {
+        "name": "Label 4",
+        "color": "#000004"
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000009",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000001",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 01",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000010",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000002",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 02",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000011",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000003",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 03",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000012",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000004",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 04",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000013",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000005",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 05",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000014",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000006",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 06",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000015",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000007",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 07",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000016",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000008",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 08",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000017",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000009",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 09",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000018",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000010",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 10",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000019",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000011",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 11",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000020",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000012",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 12",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000021",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000013",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 13",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000022",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000014",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 14",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000023",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000015",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 15",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000024",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000016",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 16",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000025",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000017",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 17",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000026",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000018",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 18",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000027",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000019",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 19",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000028",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000020",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 20",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000029",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000021",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 21",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000030",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000022",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 22",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000031",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000023",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 23",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000032",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000024",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 24",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000033",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000025",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 25",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000034",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000026",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 26",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000035",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000027",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 27",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000036",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000028",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 28",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000037",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000029",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 29",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000038",
+      "entity_type": "item",
+      "entity_id": "00000000-0000-7000-8000-000100000030",
+      "base_version": 0,
+      "fields": {
+        "name": "Item 30",
+        "description": "seed",
+        "location_id": "00000000-0000-7000-8000-000200000001",
+        "quantity": 10
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000039",
+      "entity_type": "item_label",
+      "entity_id": "00000000-0000-7000-8000-000400000001",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000028",
+        "label_id": "00000000-0000-7000-8000-000300000001"
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000040",
+      "entity_type": "item_label",
+      "entity_id": "00000000-0000-7000-8000-000400000002",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000028",
+        "label_id": "00000000-0000-7000-8000-000300000002"
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000041",
+      "entity_type": "item_label",
+      "entity_id": "00000000-0000-7000-8000-000400000003",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000029",
+        "label_id": "00000000-0000-7000-8000-000300000001"
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000042",
+      "entity_type": "item_label",
+      "entity_id": "00000000-0000-7000-8000-000400000004",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000029",
+        "label_id": "00000000-0000-7000-8000-000300000002"
+      }
+    },
+    {
+      "mutation_id": "00000000-0000-7000-8000-000500000043",
+      "entity_type": "item_label",
+      "entity_id": "00000000-0000-7000-8000-000400000005",
+      "base_version": 0,
+      "fields": {
+        "item_id": "00000000-0000-7000-8000-000100000030",
+        "label_id": "00000000-0000-7000-8000-000300000001"
+      }
+    }
+  ]
+}
diff --git a/android-app/app/src/testFoss/kotlin/dev/hho/android/di/ScannerModuleTest.kt b/android-app/app/src/testFoss/kotlin/dev/hho/android/di/ScannerModuleTest.kt
new file mode 100644
index 0000000..f202bb4
--- /dev/null
+++ b/android-app/app/src/testFoss/kotlin/dev/hho/android/di/ScannerModuleTest.kt
@@ -0,0 +1,24 @@
+package dev.hho.android.di
+
+import dagger.Component
+import dev.hho.android.data.scanner.BarcodeScanner
+import dev.hho.android.data.scanner.ZxingBarcodeScanner
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import javax.inject.Singleton
+
+@Singleton
+@Component(modules = [ScannerModule::class])
+interface ScannerTestComponent {
+    fun barcodeScanner(): BarcodeScanner
+}
+
+class ScannerModuleTest {
+
+    @Test
+    fun `BarcodeScanner resolves to ZxingBarcodeScanner`() {
+        val component = DaggerScannerTestComponent.create()
+
+        assertTrue(component.barcodeScanner() is ZxingBarcodeScanner)
+    }
+}
diff --git a/android-app/app/src/testGms/kotlin/dev/hho/android/data/scanner/MlKitBarcodeScannerTest.kt b/android-app/app/src/testGms/kotlin/dev/hho/android/data/scanner/MlKitBarcodeScannerTest.kt
new file mode 100644
index 0000000..e800ac9
--- /dev/null
+++ b/android-app/app/src/testGms/kotlin/dev/hho/android/data/scanner/MlKitBarcodeScannerTest.kt
@@ -0,0 +1,85 @@
+package dev.hho.android.data.scanner
+
+import androidx.camera.core.ImageInfo
+import androidx.camera.core.ImageProxy
+import com.google.mlkit.vision.barcode.common.Barcode
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class MlKitBarcodeScannerTest {
+
+    @Test
+    fun `maps every ML Kit format this project names`() {
+        assertEquals(BarcodeFormat.QR_CODE, mapMlKitFormat(Barcode.FORMAT_QR_CODE))
+        assertEquals(BarcodeFormat.AZTEC, mapMlKitFormat(Barcode.FORMAT_AZTEC))
+        assertEquals(BarcodeFormat.DATA_MATRIX, mapMlKitFormat(Barcode.FORMAT_DATA_MATRIX))
+        assertEquals(BarcodeFormat.PDF_417, mapMlKitFormat(Barcode.FORMAT_PDF417))
+        assertEquals(BarcodeFormat.CODE_39, mapMlKitFormat(Barcode.FORMAT_CODE_39))
+        assertEquals(BarcodeFormat.CODE_93, mapMlKitFormat(Barcode.FORMAT_CODE_93))
+        assertEquals(BarcodeFormat.CODE_128, mapMlKitFormat(Barcode.FORMAT_CODE_128))
+        assertEquals(BarcodeFormat.CODABAR, mapMlKitFormat(Barcode.FORMAT_CODABAR))
+        assertEquals(BarcodeFormat.ITF, mapMlKitFormat(Barcode.FORMAT_ITF))
+        assertEquals(BarcodeFormat.EAN_8, mapMlKitFormat(Barcode.FORMAT_EAN_8))
+        assertEquals(BarcodeFormat.EAN_13, mapMlKitFormat(Barcode.FORMAT_EAN_13))
+        assertEquals(BarcodeFormat.UPC_A, mapMlKitFormat(Barcode.FORMAT_UPC_A))
+        assertEquals(BarcodeFormat.UPC_E, mapMlKitFormat(Barcode.FORMAT_UPC_E))
+    }
+
+    @Test
+    fun `falls back to UNKNOWN for a format this project does not name`() {
+        assertEquals(BarcodeFormat.UNKNOWN, mapMlKitFormat(Barcode.FORMAT_UNKNOWN))
+        assertEquals(BarcodeFormat.UNKNOWN, mapMlKitFormat(Barcode.FORMAT_ALL_FORMATS))
+        assertEquals(BarcodeFormat.UNKNOWN, mapMlKitFormat(-1))
+    }
+
+    @Test
+    fun `maps a detection with a non-null raw value into a DecodedBarcode`() {
+        val result = mapMlKitBarcode(rawValue = "0012345678905", mlKitFormat = Barcode.FORMAT_EAN_13)
+
+        assertEquals(DecodedBarcode("0012345678905", BarcodeFormat.EAN_13), result)
+    }
+
+    @Test
+    fun `drops a detection with a null raw value instead of reporting a placeholder`() {
+        assertNull(mapMlKitBarcode(rawValue = null, mlKitFormat = Barcode.FORMAT_QR_CODE))
+    }
+
+    @Test
+    fun `scan returns an empty list and does not close the proxy when the frame has no backing image`() =
+        runTest {
+            val scanner = MlKitBarcodeScanner()
+            val imageProxy = NoImageFakeImageProxy()
+
+            val result = scanner.scan(imageProxy)
+
+            assertEquals(emptyList<DecodedBarcode>(), result)
+            assertEquals(0, imageProxy.closeCount)
+        }
+}
+
+private class NoImageFakeImageProxy : ImageProxy {
+    var closeCount = 0
+        private set
+
+    override fun close() {
+        closeCount++
+    }
+
+    override fun getCropRect() = throw UnsupportedOperationException("not exercised by this test")
+
+    override fun setCropRect(rect: android.graphics.Rect?) = Unit
+
+    override fun getFormat(): Int = 0
+
+    override fun getHeight(): Int = 0
+
+    override fun getWidth(): Int = 0
+
+    override fun getPlanes(): Array<ImageProxy.PlaneProxy> = emptyArray()
+
+    override fun getImageInfo(): ImageInfo = throw UnsupportedOperationException("not exercised by this test")
+
+    override fun getImage(): android.media.Image? = null
+}
diff --git a/android-app/app/src/testGms/kotlin/dev/hho/android/di/ScannerModuleTest.kt b/android-app/app/src/testGms/kotlin/dev/hho/android/di/ScannerModuleTest.kt
new file mode 100644
index 0000000..6a31ba0
--- /dev/null
+++ b/android-app/app/src/testGms/kotlin/dev/hho/android/di/ScannerModuleTest.kt
@@ -0,0 +1,24 @@
+package dev.hho.android.di
+
+import dagger.Component
+import dev.hho.android.data.scanner.BarcodeScanner
+import dev.hho.android.data.scanner.MlKitBarcodeScanner
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import javax.inject.Singleton
+
+@Singleton
+@Component(modules = [ScannerModule::class])
+interface ScannerTestComponent {
+    fun barcodeScanner(): BarcodeScanner
+}
+
+class ScannerModuleTest {
+
+    @Test
+    fun `BarcodeScanner resolves to MlKitBarcodeScanner`() {
+        val component = DaggerScannerTestComponent.create()
+
+        assertTrue(component.barcodeScanner() is MlKitBarcodeScanner)
+    }
+}
diff --git a/android-app/build.gradle.kts b/android-app/build.gradle.kts
new file mode 100644
index 0000000..1a6641b
--- /dev/null
+++ b/android-app/build.gradle.kts
@@ -0,0 +1,17 @@
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath(libs.kotlin.gradle.plugin)
+        classpath(libs.ksp.gradle.plugin)
+    }
+}
+
+plugins {
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.kotlin.compose) apply false
+    alias(libs.plugins.ksp) apply false
+    alias(libs.plugins.hilt) apply false
+}
diff --git a/android-app/buildSrc/build.gradle.kts b/android-app/buildSrc/build.gradle.kts
new file mode 100644
index 0000000..9471240
--- /dev/null
+++ b/android-app/buildSrc/build.gradle.kts
@@ -0,0 +1,16 @@
+plugins {
+    `kotlin-dsl`
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation("junit:junit:4.13.2")
+}
+
+tasks.test {
+    useJUnit()
+}
diff --git a/android-app/buildSrc/src/main/kotlin/dev/hho/android/buildsrc/ClientVersion.kt b/android-app/buildSrc/src/main/kotlin/dev/hho/android/buildsrc/ClientVersion.kt
new file mode 100644
index 0000000..f377e29
--- /dev/null
+++ b/android-app/buildSrc/src/main/kotlin/dev/hho/android/buildsrc/ClientVersion.kt
@@ -0,0 +1,15 @@
+package dev.hho.android.buildsrc
+
+object ClientVersion {
+    private val STRICT_MAJOR_MINOR_PATCH = Regex("^[0-9]+\\.[0-9]+\\.[0-9]+$")
+
+    fun validate(raw: String): String {
+        require(STRICT_MAJOR_MINOR_PATCH.matches(raw)) {
+            "hhoClientVersion \"$raw\" is not a valid X-HHO-Client-Version value: must be exactly " +
+                "MAJOR.MINOR.PATCH (three dot-separated non-negative integers, e.g. \"1.4.2\") with no " +
+                "pre-release or build suffix. See server/internal/httpapi/middleware/clientversion.go " +
+                "and assumption A147 in docs/sdlc/hho-ecosystem/assumptions.md."
+        }
+        return raw
+    }
+}
diff --git a/android-app/buildSrc/src/test/kotlin/dev/hho/android/buildsrc/ClientVersionTest.kt b/android-app/buildSrc/src/test/kotlin/dev/hho/android/buildsrc/ClientVersionTest.kt
new file mode 100644
index 0000000..0d66d83
--- /dev/null
+++ b/android-app/buildSrc/src/test/kotlin/dev/hho/android/buildsrc/ClientVersionTest.kt
@@ -0,0 +1,80 @@
+package dev.hho.android.buildsrc
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+class ClientVersionTest {
+    @Test
+    fun `a strict MAJOR MINOR PATCH value is returned unchanged`() {
+        assertEquals("1.2.3", ClientVersion.validate("1.2.3"))
+    }
+
+    @Test
+    fun `an all-zero version is valid`() {
+        assertEquals("0.1.0", ClientVersion.validate("0.1.0"))
+    }
+
+    @Test
+    fun `a leading zero component is accepted, matching the server's isDigits plus strconv Atoi parser`() {
+        assertEquals("01.2.3", ClientVersion.validate("01.2.3"))
+    }
+
+    @Test
+    fun `a multi-digit component is valid`() {
+        assertEquals("12.34.567", ClientVersion.validate("12.34.567"))
+    }
+
+    @Test
+    fun `too few components is rejected`() {
+        assertThrows(IllegalArgumentException::class.java) { ClientVersion.validate("1.2") }
+    }
+
+    @Test
+    fun `too many components is rejected`() {
+        assertThrows(IllegalArgumentException::class.java) { ClientVersion.validate("1.2.3.4") }
+    }
+
+    @Test
+    fun `a pre-release suffix is rejected, not stripped`() {
+        assertThrows(IllegalArgumentException::class.java) { ClientVersion.validate("1.2.3-rc1") }
+    }
+
+    @Test
+    fun `a debug suffix is rejected, not stripped`() {
+        assertThrows(IllegalArgumentException::class.java) { ClientVersion.validate("1.2.3-debug") }
+    }
+
+    @Test
+    fun `a build metadata suffix is rejected, not stripped`() {
+        assertThrows(IllegalArgumentException::class.java) { ClientVersion.validate("1.2.3+b5") }
+    }
+
+    @Test
+    fun `a negative component is rejected`() {
+        assertThrows(IllegalArgumentException::class.java) { ClientVersion.validate("-1.2.3") }
+    }
+
+    @Test
+    fun `a non-numeric component is rejected`() {
+        assertThrows(IllegalArgumentException::class.java) { ClientVersion.validate("a.b.c") }
+    }
+
+    @Test
+    fun `an empty string is rejected`() {
+        assertThrows(IllegalArgumentException::class.java) { ClientVersion.validate("") }
+    }
+
+    @Test
+    fun `whitespace around an otherwise-valid value is rejected`() {
+        assertThrows(IllegalArgumentException::class.java) { ClientVersion.validate(" 1.2.3") }
+        assertThrows(IllegalArgumentException::class.java) { ClientVersion.validate("1.2.3 ") }
+    }
+
+    @Test
+    fun `the failure message names the offending value so a bad build fails loudly and legibly`() {
+        val error = assertThrows(IllegalArgumentException::class.java) { ClientVersion.validate("0.1.0-debug") }
+        assertEquals(true, error.message?.contains("0.1.0-debug"))
+        assertEquals(true, error.message?.contains("MAJOR.MINOR.PATCH"))
+    }
+}
diff --git a/android-app/gradle.properties b/android-app/gradle.properties
new file mode 100644
index 0000000..7dc276c
--- /dev/null
+++ b/android-app/gradle.properties
@@ -0,0 +1,5 @@
+org.gradle.jvmargs=-Xmx3072m -XX:MaxMetaspaceSize=1024m -Dfile.encoding=UTF-8
+org.gradle.parallel=true
+org.gradle.caching=true
+
+kotlin.code.style=official
diff --git a/android-app/gradle/libs.versions.toml b/android-app/gradle/libs.versions.toml
new file mode 100644
index 0000000..a0c00a2
--- /dev/null
+++ b/android-app/gradle/libs.versions.toml
@@ -0,0 +1,110 @@
+[versions]
+agp = "9.3.2"
+kotlin = "2.4.10"
+ksp = "2.3.11"
+hilt = "2.60.1"
+
+minSdk = "26"
+targetSdk = "36"
+compileSdk = "36"
+jvmTarget = "17"
+
+composeBom = "2026.06.01"
+coreKtx = "1.18.0"
+activityCompose = "1.13.0"
+lifecycle = "2.10.0"
+hiltNavigationCompose = "1.3.0"
+datastorePreferences = "1.1.7"
+
+kotlinxCoroutines = "1.11.0"
+okhttp = "4.12.0"
+
+openapiGenerator = "7.25.0"
+kotlinxSerializationJson = "1.11.0"
+
+room = "2.8.5"
+
+workManager = "2.12.0"
+hiltWork = "1.3.0"
+
+cameraX = "1.6.2"
+appcompat = "1.7.1"
+
+mlkitBarcodeScanning = "17.3.0"
+zxingCore = "3.5.4"
+
+junit = "4.13.2"
+
+robolectric = "4.17"
+androidxTestCore = "1.7.0"
+androidxTestExtJunit = "1.3.0"
+androidxTestRunner = "1.7.0"
+androidxTestRules = "1.7.0"
+espresso = "3.7.0"
+
+[libraries]
+androidx-core-ktx = { module = "androidx.core:core-ktx", version.ref = "coreKtx" }
+androidx-lifecycle-runtime-ktx = { module = "androidx.lifecycle:lifecycle-runtime-ktx", version.ref = "lifecycle" }
+androidx-lifecycle-viewmodel-compose = { module = "androidx.lifecycle:lifecycle-viewmodel-compose", version.ref = "lifecycle" }
+androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "activityCompose" }
+
+androidx-compose-bom = { module = "androidx.compose:compose-bom", version.ref = "composeBom" }
+androidx-compose-ui = { module = "androidx.compose.ui:ui" }
+androidx-compose-ui-graphics = { module = "androidx.compose.ui:ui-graphics" }
+androidx-compose-ui-tooling = { module = "androidx.compose.ui:ui-tooling" }
+androidx-compose-ui-tooling-preview = { module = "androidx.compose.ui:ui-tooling-preview" }
+androidx-compose-material3 = { module = "androidx.compose.material3:material3" }
+
+hilt-android = { module = "com.google.dagger:hilt-android", version.ref = "hilt" }
+hilt-compiler = { module = "com.google.dagger:hilt-android-compiler", version.ref = "hilt" }
+androidx-hilt-navigation-compose = { module = "androidx.hilt:hilt-navigation-compose", version.ref = "hiltNavigationCompose" }
+androidx-datastore-preferences = { module = "androidx.datastore:datastore-preferences", version.ref = "datastorePreferences" }
+
+kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinxCoroutines" }
+kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinxCoroutines" }
+okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }
+okhttp-mockwebserver = { module = "com.squareup.okhttp3:mockwebserver", version.ref = "okhttp" }
+kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinxSerializationJson" }
+
+androidx-room-runtime = { module = "androidx.room:room-runtime", version.ref = "room" }
+androidx-room-ktx = { module = "androidx.room:room-ktx", version.ref = "room" }
+androidx-room-testing = { module = "androidx.room:room-testing", version.ref = "room" }
+androidx-room-compiler = { module = "androidx.room:room-compiler", version.ref = "room" }
+
+androidx-work-runtime-ktx = { module = "androidx.work:work-runtime-ktx", version.ref = "workManager" }
+androidx-hilt-work = { module = "androidx.hilt:hilt-work", version.ref = "hiltWork" }
+androidx-hilt-compiler = { module = "androidx.hilt:hilt-compiler", version.ref = "hiltWork" }
+androidx-work-testing = { module = "androidx.work:work-testing", version.ref = "workManager" }
+
+androidx-camera-core = { module = "androidx.camera:camera-core", version.ref = "cameraX" }
+androidx-camera-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "cameraX" }
+androidx-camera-view = { module = "androidx.camera:camera-view", version.ref = "cameraX" }
+androidx-appcompat = { module = "androidx.appcompat:appcompat", version.ref = "appcompat" }
+androidx-camera-lifecycle = { module = "androidx.camera:camera-lifecycle", version.ref = "cameraX" }
+
+mlkit-barcode-scanning = { module = "com.google.mlkit:barcode-scanning", version.ref = "mlkitBarcodeScanning" }
+
+zxing-core = { module = "com.google.zxing:core", version.ref = "zxingCore" }
+
+junit = { module = "junit:junit", version.ref = "junit" }
+robolectric = { module = "org.robolectric:robolectric", version.ref = "robolectric" }
+androidx-test-core = { module = "androidx.test:core", version.ref = "androidxTestCore" }
+androidx-test-ext-junit = { module = "androidx.test.ext:junit", version.ref = "androidxTestExtJunit" }
+androidx-test-runner = { module = "androidx.test:runner", version.ref = "androidxTestRunner" }
+androidx-test-rules = { module = "androidx.test:rules", version.ref = "androidxTestRules" }
+androidx-test-espresso-core = { module = "androidx.test.espresso:espresso-core", version.ref = "espresso" }
+androidx-compose-ui-test-junit4 = { module = "androidx.compose.ui:ui-test-junit4" }
+hilt-android-testing = { module = "com.google.dagger:hilt-android-testing", version.ref = "hilt" }
+
+dagger-compiler = { module = "com.google.dagger:dagger-compiler", version.ref = "hilt" }
+
+kotlin-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
+ksp-gradle-plugin = { module = "com.google.devtools.ksp:symbol-processing-gradle-plugin", version.ref = "ksp" }
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "agp" }
+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" }
+hilt = { id = "com.google.dagger.hilt.android", version.ref = "hilt" }
+openapi-generator = { id = "org.openapi.generator", version.ref = "openapiGenerator" }
diff --git a/android-app/gradle/wrapper/gradle-wrapper.jar b/android-app/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..eddabd2
Binary files /dev/null and b/android-app/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/android-app/gradle/wrapper/gradle-wrapper.properties b/android-app/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..760c459
--- /dev/null
+++ b/android-app/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,10 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionSha256Sum=acd53f1edaf02f1a8ff99879f8a34b302661a057d9b063ae9e35b552f804d20a
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.7.1-bin.zip
+networkTimeout=10000
+retries=0
+retryBackOffMs=500
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/android-app/gradlew b/android-app/gradlew
new file mode 100755
index 0000000..249efbb
--- /dev/null
+++ b/android-app/gradlew
@@ -0,0 +1,248 @@
+#!/bin/sh
+
+#
+# Copyright © 2015 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   gradlew start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh gradlew
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/android-app/gradlew.bat b/android-app/gradlew.bat
new file mode 100644
index 0000000..8508ef6
--- /dev/null
+++ b/android-app/gradlew.bat
@@ -0,0 +1,82 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  gradlew startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables, and ensure extensions are enabled
+setlocal EnableExtensions
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+"%COMSPEC%" /c exit 1
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+"%COMSPEC%" /c exit 1
+
+:execute
+@rem Setup the command line
+
+
+
+@rem Execute gradlew
+@rem endlocal doesn't take effect until after the line is parsed and variables are expanded
+@rem which allows us to clear the local environment before executing the java command
+endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel
+
+:exitWithErrorLevel
+@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts
+"%COMSPEC%" /c exit %ERRORLEVEL%
diff --git a/android-app/settings.gradle.kts b/android-app/settings.gradle.kts
new file mode 100644
index 0000000..acc79ef
--- /dev/null
+++ b/android-app/settings.gradle.kts
@@ -0,0 +1,20 @@
+pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+@Suppress("UnstableApiUsage")
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = "hho-android"
+
+include(":app")
diff --git a/fastlane/metadata/android/en-US/changelogs/1.txt b/fastlane/metadata/android/en-US/changelogs/1.txt
new file mode 100644
index 0000000..feb0d17
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/1.txt
@@ -0,0 +1 @@
+Initial release.
diff --git a/fastlane/metadata/android/en-US/full_description.txt b/fastlane/metadata/android/en-US/full_description.txt
new file mode 100644
index 0000000..9ff65a1
--- /dev/null
+++ b/fastlane/metadata/android/en-US/full_description.txt
@@ -0,0 +1,9 @@
+HHO (Household Objects) is a client for the self-hosted HHO home inventory server.
+
+Keep track of what your household owns: what is in the garage, which box holds the holiday lights, whether the drill is still under warranty.
+
+* Works offline and syncs with your own HHO server when a connection is available
+* Scan barcodes and QR codes with the camera to find and update items quickly
+* No cloud account and no subscription: your data stays on your hardware
+
+This app needs an HHO server that you run yourself.
diff --git a/fastlane/metadata/android/en-US/short_description.txt b/fastlane/metadata/android/en-US/short_description.txt
new file mode 100644
index 0000000..d75082f
--- /dev/null
+++ b/fastlane/metadata/android/en-US/short_description.txt
@@ -0,0 +1 @@
+Offline-first home inventory client for a self-hosted HHO server
diff --git a/fastlane/metadata/android/en-US/title.txt b/fastlane/metadata/android/en-US/title.txt
new file mode 100644
index 0000000..c2fde1e
--- /dev/null
+++ b/fastlane/metadata/android/en-US/title.txt
@@ -0,0 +1 @@
+HHO