From bfedf257c780c560862e9ba6bd3cb076d0c76e03 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 15:50:03 -0400
Subject: [PATCH 01/20] Add design spec for CCR equipment support (#804)

Covers three phases: a rebreather equipment type with CCR/SCR attributes,
reusable cylinder configurations (schema v139) with a conservative merge
that never overwrites downloaded gas mixes, and built-in rebreather service
kinds for scrubber repack, O2 cell replacement, and annual service.
---
 .../specs/2026-08-05-ccr-equipment-design.md  | 347 ++++++++++++++++++
 1 file changed, 347 insertions(+)
 create mode 100644 docs/superpowers/specs/2026-08-05-ccr-equipment-design.md

diff --git a/docs/superpowers/specs/2026-08-05-ccr-equipment-design.md b/docs/superpowers/specs/2026-08-05-ccr-equipment-design.md
new file mode 100644
index 0000000000..c656d1e535
--- /dev/null
+++ b/docs/superpowers/specs/2026-08-05-ccr-equipment-design.md
@@ -0,0 +1,347 @@
+# CCR as Equipment Type, Cylinder Configurations, and Rebreather Service
+
+**Date:** 2026-08-05
+**Issue:** [#804](https://github.com/submersion-app/submersion/issues/804)
+**Status:** Approved design, pending implementation plan
+
+## Motivation
+
+Issue #804 reports that there is no way to record which rebreather was used on
+a dive. Open-circuit gear is covered by the `regulator` equipment type, and CCR
+gas is covered by tanks and tank roles, but the unit itself has no
+representation. The reporter's workaround is to register the CCR controller as
+a dive computer and infer the unit from it.
+
+The issue makes three asks:
+
+1. An equipment type for rebreathers, so a specific unit can be linked to a
+   dive.
+2. Reusable configurations per unit, because entering diluent and bailout
+   setups by hand "can otherwise be quite involved."
+3. Service-date tracking per unit.
+
+All three are in scope, phased.
+
+## Current state (survey findings)
+
+The app already models more of CCR diving than the issue implies. What is
+missing is a physical unit to attach it to.
+
+- `DiveMode` (`lib/core/constants/enums.dart:318`) already has
+  `oc` / `ccr` / `scr` / `gauge`; `dives.dive_mode` defaults to `'oc'`.
+- `TankRole` (`enums.dart:292`) already includes `diluent`, `oxygenSupply`,
+  and `bailout` alongside the OC roles.
+- Dives already carry CCR setpoints, and `ScrType` (CMF / PASCR / ESCR)
+  already exists.
+- `EquipmentType` (`enums.dart:4`) is a hardcoded Dart enum of 19 values with
+  no rebreather. Values persist as raw strings in `equipment.type`
+  (`database.dart:872`), so adding a value is cheap but splitting one later
+  would be a data migration.
+- Everything type-specific about an equipment item lives in
+  `EquipmentAttributeCatalog`
+  (`lib/features/equipment/domain/constants/equipment_attribute_catalog.dart`),
+  a per-type map of typed attribute definitions stored as KV rows in
+  `equipment_attributes` (v115, PR #608). Adding attributes for a new type
+  requires no schema migration.
+- Equipment type labels render from the enum's hardcoded English `displayName`
+  (`equipment_edit_page.dart:207`) and are **not** localized. Attributes
+  **are**, via `attrLabel_<key>` / `attrChoice_<key>_<option>` across 11
+  locales.
+- `ServiceSchedule` supports `intervalDays` / `intervalDives` /
+  `intervalHours` per clock, and `ServiceDueEngine`
+  (`domain/services/service_due_engine.dart:58`) already computes
+  hours-since-anchor by summing dive durations for dives linked to the item,
+  anchored on the last matching `ServiceRecord`.
+- Built-in service kinds seed from `kSeedBuiltInServiceKindsSql`
+  (`database.dart:2114`) with stable slug ids and `INSERT OR IGNORE`, so
+  re-running is a no-op. Its SELECT list hardcodes `NULL` for
+  `default_interval_hours` — no existing built-in uses an hours interval.
+- Two adjacent concepts exist but neither carries a gas mix or a role:
+  - `EquipmentSet` answers "what gear did I bring?" `EquipmentSetItems` is
+    literally just `(set_id, equipment_id)`. Sets have geofences, a default
+    flag, and are auto-applied to imported dives by `DiveEquipmentDefaulter`.
+  - `TankPreset` answers "what kind of cylinder is this?" — a single-cylinder
+    spec (volume, working pressure, material), diver-scoped, with seeded
+    built-ins such as AL80.
+  - Gas mix and role live only on per-dive `DiveTanks` rows. That absence is
+    exactly the re-entry tedium the issue describes, and it is identical for a
+    technical open-circuit diver entering doubles plus two deco stages.
+
+## Design decisions
+
+| Decision | Choice | Rationale |
+| --- | --- | --- |
+| Type granularity | One `rebreather` type plus a `unit_type` choice attribute | Matches the existing pattern (`suit_style`, `bcd_style`). Serves SCR divers without a second type. "Show me all my rebreathers" stays a one-value query. Splitting later would be a data migration. |
+| Configuration home | New generic entity, optionally owned by a unit | The tedium is identical for technical OC. A CCR-only table would be generalized later anyway. |
+| Configuration payload | Cylinders only | Setpoints stay per-dive where they already live. A generic gas plan and a CCR config then share one shape with no always-null OC columns. |
+| Apply flow | Manual, with smart merge | Never silently mutates gas data a dive computer already supplied. |
+| Cylinder spec source | Inline snapshot, no FK to `tank_presets` | A config records what you actually dive, not a live pointer. |
+
+## Phase 1 — `EquipmentType.rebreather`
+
+One enum value plus one catalog entry. No schema migration.
+
+```
+EquipmentType.rebreather('Rebreather')
+```
+
+Catalog entry in `EquipmentAttributeCatalog._byType`:
+
+| Key | Kind | Dimension | Choices |
+| --- | --- | --- | --- |
+| `unit_type` | choice | — | `eccr`, `mccr`, `hccr`, `scr_cmf`, `scr_pascr`, `scr_escr` |
+| `mount_configuration` | choice | — | `back`, `chest`, `sidemount` |
+| `scrubber_type` | choice | — | `axial`, `radial` |
+| `scrubber_duration_h` | number | none | — |
+| `o2_cell_count` | number | none | — |
+| `diluent_cylinder_l` | number | volumeL | — |
+| `o2_cylinder_l` | number | volumeL | — |
+| `depth_rating_m` | number | depthM | — |
+
+The universal attributes `buoyancy_kg` and `dry_weight_kg` are appended
+automatically by `attributesFor`. This matters beyond bookkeeping: the weight
+planner already reads those attribute keys, so a rebreather starts
+contributing to weighting predictions with no additional wiring.
+
+`scrubber_duration_h` is the unit's rated duration, a property of the unit and
+its sorb. It is recorded here and deliberately not duplicated onto
+configurations.
+
+### Localization
+
+The type label needs no ARB work (it renders from `displayName`). The
+attributes add roughly 23 new keys — 8 `attrLabel_*` plus 15
+`attrChoice_*` — across 11 locales, along with arms in the
+`equipment_attribute_l10n.dart` resolver switch. This is the bulk of Phase 1's
+diff.
+
+## Phase 2 — Cylinder configurations (schema v139)
+
+### Schema version
+
+Main is at `currentSchemaVersion = 137`. PR #603 (divelogs) claims v138. This
+work claims **v139**. Per project convention, re-grep `currentSchemaVersion` on
+current `origin/main` before implementing and renumber above it if main has
+advanced.
+
+### Tables
+
+```
+cylinder_configs
+  id            TEXT PK
+  diver_id      TEXT NULL  -> divers(id)
+  equipment_id  TEXT NULL  -> equipment(id)  ON DELETE SET NULL
+  name          TEXT NOT NULL
+  description   TEXT NOT NULL DEFAULT ''
+  sort_order    INT NOT NULL DEFAULT 0
+  created_at    INT NOT NULL
+  updated_at    INT NOT NULL
+  hlc           TEXT NULL
+
+cylinder_config_items
+  id                          TEXT PK
+  config_id                   TEXT NOT NULL
+                              -> cylinder_configs(id) ON DELETE CASCADE
+  sort_order                  INT NOT NULL DEFAULT 0
+  label                       TEXT NULL
+  tank_role                   TEXT NOT NULL      -- TankRole.name
+  volume_l                    REAL NULL
+  working_pressure_bar        REAL NULL
+  tank_material               TEXT NULL          -- TankMaterial.name
+  o2_percent                  REAL NOT NULL DEFAULT 21
+  he_percent                  REAL NOT NULL DEFAULT 0
+  default_start_pressure_bar  REAL NULL
+  created_at                  INT NOT NULL
+  updated_at                  INT NOT NULL
+  hlc                         TEXT NULL
+```
+
+`equipment_id` set means "a configuration for my JJ"; null means a generic gas
+plan usable by any diver on any dive.
+
+**No foreign key to `tank_presets`.** A preset picker populates `volume_l`,
+`working_pressure_bar`, and `tank_material` at edit time and is then out of the
+picture. This removes deleted presets breaking configs, a two-branch read path
+at apply time, and preset edits silently rewriting the historical meaning of a
+config.
+
+**`ON DELETE SET NULL` on `equipment_id`.** Deleting a rebreather demotes its
+configurations to generic gas plans rather than destroying them. Equipment
+already supports a retired status (#636), so hard deletion is the rare path,
+and losing a painstakingly entered bailout plan as a side effect of tidying
+gear is the worse failure.
+
+Migration follows the project's standard shape: an idempotent
+`_assertCylinderConfigSchema()` (CREATE TABLE IF NOT EXISTS) called from both
+the `if (from < 139)` `onUpgrade` block and the `beforeOpen` backstop, so a
+database stranded at any lower version self-heals.
+
+### The merge algorithm
+
+Implemented as `CylinderConfigApplier`, a pure service taking existing tanks
+plus config items and returning a list of operations. No database access, no
+`DateTime.now()` — mirroring `ServiceDueEngine`.
+
+```
+match key = tank_role
+
+for each config item, in sort_order:
+    find FIRST UNCLAIMED existing DiveTank with the same tank_role
+      found -> claim it. Fill ONLY columns that are NULL on it.
+               Never touch o2_percent or he_percent.
+      none  -> INSERT a new DiveTank; tank_order appended after
+               the current maximum.
+
+result: a summary — "Added 3 cylinders, kept 1"
+```
+
+Field mapping from `cylinder_config_items` to `dive_tanks`:
+
+| Config item | Dive tank | Fillable on claim |
+| --- | --- | --- |
+| `tank_role` | `tank_role` | match key, never written |
+| `volume_l` | `volume` | yes (nullable) |
+| `working_pressure_bar` | `working_pressure` | yes (nullable) |
+| `tank_material` | `tank_material` | yes (nullable) |
+| `default_start_pressure_bar` | `start_pressure` | yes (nullable) |
+| `label` | `tank_name` | yes (nullable) |
+| `o2_percent` | `o2_percent` | **no** — insert only |
+| `he_percent` | `he_percent` | **no** — insert only |
+
+All five fillable columns are `.nullable()` on `DiveTanks`, so "is null" is a
+real test for each. The two gas columns are the only ones carrying non-null
+defaults, which is precisely why they are insert-only.
+
+**Why gas mix is never overwritten.** `DiveTanks.o2Percent` is
+`withDefault(const Constant(21.0))` and `hePercent` defaults to `0`. A tank
+reading air is therefore indistinguishable from a tank nobody filled in: there
+is no null to test against, so there is no honest way to detect "unset." Absent
+gas on a dive is a nuisance; wrong gas on a dive is a safety-relevant falsehood
+in a logbook divers plan future dives from.
+
+**Why "first unclaimed."** A CCR diver routinely carries two `bailout`
+cylinders, so `tank_role` is not unique. Claiming greedily in order makes
+"config has 2 bailouts, dive already has 1" resolve to keep-one-add-one rather
+than duplicating or clobbering.
+
+### Structure
+
+New feature directory `lib/features/cylinder_configs/`, laid out like the
+existing `lib/features/tank_presets/`:
+
+```
+lib/features/cylinder_configs/
+  data/repositories/cylinder_config_repository.dart
+  domain/entities/cylinder_config.dart
+  domain/entities/cylinder_config_item.dart
+  domain/services/cylinder_config_applier.dart
+  presentation/pages/cylinder_config_list_page.dart
+  presentation/pages/cylinder_config_edit_page.dart
+  presentation/providers/cylinder_config_providers.dart
+  presentation/widgets/apply_configuration_menu.dart
+  presentation/widgets/cylinder_config_item_editor.dart
+```
+
+It is its own feature rather than living under `equipment/` because a config
+with a null `equipment_id` is not equipment, and `equipment/` is already large.
+
+### UI surfaces
+
+- **Dive edit, cylinders card** (`dive_log/presentation/widgets/cylinders_card.dart`):
+  an "Apply configuration" menu. Configurations are grouped by owning unit,
+  with generic ones under "Gas plans". Applying shows a summary snackbar.
+  Note the known `SnackBar` action trap (#406): the action closure must not
+  capture a `BuildContext` that may be disposed.
+- **Rebreather detail page**: a "Configurations" card listing that unit's
+  configurations with add / edit / reorder, following the structure of
+  `service_clocks_card.dart`.
+- **Configuration list and edit pages**, reached from the Equipment tab
+  alongside Equipment Sets. The editor is a reorderable cylinder list; each row
+  has role, gas mix, spec (with preset picker), optional start pressure, and
+  label.
+
+All displayed volumes, pressures, and depths route through the existing unit
+formatter and respect the active diver's unit settings.
+
+### Sync
+
+- `cylinderConfigs` — a top-level HLC entity (own id and hlc).
+- `cylinderConfigItems` — an HLC child modeled directly on `equipmentAttributes`
+  and `equipmentSetGeofences`: serializer sites, `mergeOrder` placed after
+  `equipment` and `tank_presets`, `entityHasUpdatedAt`, `parentRefs`,
+  `_hlcTables`, `_hlcTargets`, per-row tombstones on child delete, and
+  registration in the streaming base export (`_baseTables`).
+
+## Phase 3 — Rebreather service kinds
+
+Three new rows in `kSeedBuiltInServiceKindsSql`, plus one structural fix to
+that SQL.
+
+| Slug | Name | Applicable types | Interval | Auto-attach |
+| --- | --- | --- | --- | --- |
+| `scrubber-repack` | Scrubber repack | `["rebreather"]` | 3.0 hours | yes |
+| `o2-cell-replacement` | O2 cell replacement | `["rebreather"]` | 365 days | yes |
+| `rebreather-annual` | Rebreather annual service | `["rebreather"]` | 365 days | yes |
+
+The seed's SELECT currently hardcodes `NULL` for `default_interval_hours`;
+`scrubber-repack` is the first built-in that needs a real value, so the seed
+gains an hours column. `INSERT OR IGNORE` on stable slugs keeps it idempotent,
+matching the existing kinds' re-seed behavior.
+
+`ServiceDueEngine` needs no changes. A scrubber clock is `intervalHours`
+anchored on the last "Scrubber repack" record, which the engine already
+computes.
+
+**Documented caveat:** `hoursSince` sums dive *duration*, which approximates
+loop time but is not identical — it excludes pre-breathe and surface loop
+time. For a consumable whose manufacturer rating already carries a safety
+margin this is acceptable, but it must be stated in the UI copy rather than
+left for a diver to discover.
+
+## Testing
+
+Test-driven, applier first.
+
+- `cylinder_config_applier_test.dart` (pure, written before the implementation):
+  empty dive; partial role overlap; duplicate roles on both sides; downloaded
+  gas mix preserved; null-only field fill; `tank_order` appending; ordering
+  stability.
+- Repository tests against an in-memory database with **foreign keys enabled** —
+  fixtures that leave them off mask insert-order bugs.
+- `migration_v139_cylinder_configs_test.dart` using
+  `greaterThanOrEqualTo(139)` plus `contains(139)` from the start, not an
+  exact-latest tripwire. Assert both the upgrade path and a fresh in-memory
+  database, which are separate failure modes.
+- Sync round-trip tests for both new entities, including child tombstones.
+- Widget tests for the apply menu and the configuration editor.
+- Equipment attribute tests extended for the `rebreather` type, including
+  choice-key resolution.
+
+Target 80% coverage on new code per project convention.
+
+## Out of scope
+
+- **Linking a rebreather to a dive computer entity.** The issue author's
+  workaround registers the CCR controller as a dive computer. This design does
+  not unify those: a Petrel used as a controller stays a `DiveComputer` and the
+  unit becomes an `Equipment` row. A diver can keep doing both. Unifying them
+  is a separate modeling question.
+- **Auto-applying configurations to downloaded or imported dives.**
+  `DiveEquipmentDefaulter` is untouched. A diver with several fills would
+  otherwise get the wrong one applied silently.
+- **Per-dive scrubber budget display.** Phase 3 tracks scrubber life as a
+  service clock only.
+
+## Phasing
+
+Three PRs, in order:
+
+1. **Phase 1** — `EquipmentType.rebreather`, catalog attributes, localization.
+   No migration. Independently shippable and closes the issue's headline ask.
+2. **Phase 3** — rebreather service kinds and the seed's hours column. Depends
+   on Phase 1 for `applicable_types`. No migration beyond re-running the seed.
+3. **Phase 2** — cylinder configurations, schema v139. The largest piece;
+   depends on Phase 1 only for the optional owning-unit link.
+
+Phase 3 lands before Phase 2 because it is small, mechanical, and gated on
+Phase 1 alone, so it does not need to wait behind a schema migration.

From a68bcb509b5d91e34c07cca1ff63aac6b650ff5d Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 16:05:03 -0400
Subject: [PATCH 02/20] Add implementation plan for CCR equipment support
 (#804)

16 tasks across three phases, sequenced 1 -> 3 -> 2 so the rebreather type
and its service kinds ship before the schema v139 cylinder configuration
work.
---
 .../plans/2026-08-05-ccr-equipment.md         | 2756 +++++++++++++++++
 1 file changed, 2756 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-08-05-ccr-equipment.md

diff --git a/docs/superpowers/plans/2026-08-05-ccr-equipment.md b/docs/superpowers/plans/2026-08-05-ccr-equipment.md
new file mode 100644
index 0000000000..ece7fd4999
--- /dev/null
+++ b/docs/superpowers/plans/2026-08-05-ccr-equipment.md
@@ -0,0 +1,2756 @@
+# CCR Equipment Support Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Let a diver record which rebreather was used on a dive, reuse named diluent/bailout cylinder configurations instead of re-entering them, and track rebreather-specific service clocks.
+
+**Architecture:** Three independent phases. Phase 1 adds `EquipmentType.rebreather` plus a data-driven attribute catalog entry — no schema migration, because equipment attributes are KV rows in the existing `equipment_attributes` table. Phase 3 adds three built-in `ServiceKind` rows to the idempotent seed SQL; `ServiceDueEngine` already computes hours-based clocks and needs no changes. Phase 2 adds two new synced tables (`cylinder_configs`, `cylinder_config_items`) at schema v139, with a pure `CylinderConfigApplier` service that merges a configuration into a dive's cylinders without ever overwriting gas mixes.
+
+**Tech Stack:** Flutter 3.x, Drift ORM (SQLite), Riverpod, go_router, `flutter_test`, `drift/native` in-memory databases for repository and migration tests.
+
+**Spec:** `docs/superpowers/specs/2026-08-05-ccr-equipment-design.md`
+**Issue:** [#804](https://github.com/submersion-app/submersion/issues/804)
+**Worktree:** `/Users/ericgriffin/repos/submersion-app/submersion/.claude/worktrees/feat-804-ccr-equipment`, branch `worktree-feat-804-ccr-equipment`
+
+## Global Constraints
+
+- **Run all commands from the worktree root.** Do not `cd` to the main checkout. Its `.dart_tool` and Drift codegen are separate and stale relative to this branch.
+- **Never run bare `git stash` / `git stash pop`.** The stash stack is shared across worktrees. Use a temporary WIP commit instead.
+- **`dart format .`** (whole project, not just changed files) must run before every commit. The pre-push hook runs `dart format --set-exit-if-changed`.
+- **`flutter analyze`** must be clean. Never pipe it through `tail`/`head` — that masks the exit code. Infos are treated as fatal in CI.
+- **No emojis** in code, comments, or documentation.
+- **Immutability:** entities are `Equatable` with `copyWith`. Never mutate.
+- **Units:** every displayed volume, pressure, depth, and mass routes through the existing `UnitFormatter` and respects the active diver's unit settings. Store metric internally.
+- **Localization:** there are **11 ARB files** in `lib/l10n/arb/` (en + 10 others). Every new user-facing string needs a key in all 11, followed by `flutter gen-l10n` (or `flutter pub get`) to regenerate `app_localizations*.dart`.
+- **Attribute keys, choice keys, and service-kind slugs are stable identifiers persisted in the database.** They are never translated and never renamed after merge.
+- **Schema version:** Phase 2 claims **v139**. Before implementing Task 12, re-run `grep -n "currentSchemaVersion = " lib/core/database/database.dart` on a fresh merge of `origin/main`. Main was at 137 and PR #603 claimed 138 as of 2026-08-05. If main has advanced past 138, renumber to the next free value everywhere the number appears and relax any pre-existing exact-latest migration tripwire to `greaterThanOrEqualTo`.
+- **Codegen:** after any change to `lib/core/database/database.dart`, run `dart run build_runner build --delete-conflicting-outputs`. Analyze will fail on undefined generated getters otherwise.
+- **Commit messages:** no `Co-Authored-By` line, no Claude Code session URL, no generated-with attribution.
+
+## Test code depth in this plan
+
+Tasks carrying novel logic — the attribute catalog, the seed SQL, the merge
+algorithm, the migration, the repository, the apply service — ship **complete
+test bodies**. Write them as given.
+
+Tasks 12, 13, 14, and 16 are registration and UI wiring against patterns
+already established in this codebase. They list **named tests with their exact
+assertions described**, plus a "read this file first" step naming the precedent
+to copy. Write the bodies in the precedent file's style. If a precedent's
+fixture helper is named differently from what this plan suggests, the
+precedent wins — do not introduce a parallel helper.
+
+## File structure
+
+```
+lib/core/constants/enums.dart                      EquipmentType.rebreather
+lib/core/database/database.dart                    2 tables, v139 migration,
+                                                   seed SQL hours column
+lib/core/router/app_router.dart                    2 routes
+lib/core/services/sync/                            2 entity registrations
+lib/l10n/arb/app_*.arb  (11 files)                 ~35 new keys
+
+lib/features/equipment/
+  domain/constants/equipment_attribute_catalog.dart   rebreather attributes
+  presentation/utils/equipment_attribute_l10n.dart    18 resolver arms
+  presentation/widgets/service_clocks_card.dart       hours-source caption
+  presentation/pages/equipment_detail_page.dart       mounts configs card
+
+lib/features/cylinder_configs/                     NEW FEATURE
+  domain/entities/cylinder_config.dart             the config
+  domain/entities/cylinder_config_item.dart        one cylinder in it
+  domain/services/cylinder_config_applier.dart     pure merge algorithm
+  data/repositories/cylinder_config_repository.dart   persistence + sync
+  data/services/cylinder_config_apply_service.dart    plan -> dive_tanks
+  presentation/providers/cylinder_config_providers.dart
+  presentation/pages/cylinder_config_list_page.dart
+  presentation/pages/cylinder_config_edit_page.dart
+  presentation/widgets/cylinder_config_item_editor.dart
+  presentation/widgets/apply_configuration_menu.dart
+  presentation/widgets/unit_configurations_card.dart
+
+lib/features/dive_log/
+  presentation/widgets/cylinders_card.dart         hosts the apply menu
+```
+
+The merge algorithm is deliberately isolated from persistence: the applier is
+pure and exhaustively unit-tested, while the apply service only translates its
+output into writes. That split is what makes the "never overwrite gas" rule
+testable without a database fixture.
+
+---
+
+# Phase 1 — `EquipmentType.rebreather`
+
+No schema migration. Tasks 1-4.
+
+---
+
+### Task 1: Add the `rebreather` equipment type
+
+**Files:**
+- Modify: `lib/core/constants/enums.dart:4-27` (the `EquipmentType` enum)
+- Test: `test/features/equipment/domain/equipment_attribute_catalog_test.dart`
+
+**Interfaces:**
+- Consumes: nothing.
+- Produces: `EquipmentType.rebreather`, whose `.name` serializes to the string `'rebreather'` in `equipment.type`, and whose `displayName` is `'Rebreather'`.
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `test/features/equipment/domain/equipment_attribute_catalog_test.dart`:
+
+```dart
+  test('rebreather is a distinct equipment type with a stable name', () {
+    expect(EquipmentType.values, contains(EquipmentType.rebreather));
+    expect(EquipmentType.rebreather.name, 'rebreather');
+    expect(EquipmentType.rebreather.displayName, 'Rebreather');
+  });
+```
+
+If the file's existing imports do not already include it, add:
+
+```dart
+import 'package:submersion/core/constants/enums.dart';
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `flutter test test/features/equipment/domain/equipment_attribute_catalog_test.dart`
+Expected: compile error, `The getter 'rebreather' isn't defined for the type 'EquipmentType'`.
+
+- [ ] **Step 3: Add the enum value**
+
+In `lib/core/constants/enums.dart`, insert `rebreather` after `tank` in the `EquipmentType` enum so related breathing-system types sit together:
+
+```dart
+enum EquipmentType {
+  regulator('Regulator'),
+  bcd('BCD'),
+  wetsuit('Wetsuit'),
+  drysuit('Drysuit'),
+  fins('Fins'),
+  mask('Mask'),
+  computer('Dive Computer'),
+  transmitter('Transmitter'),
+  tank('Tank'),
+  rebreather('Rebreather'),
+  weights('Weights'),
+  light('Light'),
+  camera('Camera'),
+  smb('SMB'),
+  reel('Reel'),
+  knife('Knife'),
+  hood('Hood'),
+  gloves('Gloves'),
+  boots('Boots'),
+  other('Other');
+
+  final String displayName;
+  const EquipmentType(this.displayName);
+}
+```
+
+Do **not** reorder any existing value. `EquipmentType` values persist as raw strings in `equipment.type` (`lib/core/database/database.dart:872`), so ordinal position is not persisted, but several UI dropdowns iterate `EquipmentType.values` and reordering would silently reshuffle them.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `flutter test test/features/equipment/domain/equipment_attribute_catalog_test.dart`
+Expected: PASS
+
+- [ ] **Step 5: Verify nothing else broke**
+
+Run: `flutter analyze`
+Expected: no issues. Watch specifically for non-exhaustive `switch` warnings on `EquipmentType` — if any appear, they are real: add a `rebreather` arm to each reported switch before continuing.
+
+Run: `flutter test test/features/equipment/`
+Expected: all pass.
+
+- [ ] **Step 6: Commit**
+
+```bash
+dart format .
+git add -A
+git commit -m "Add rebreather equipment type (#804)"
+```
+
+---
+
+### Task 2: Add rebreather attributes to the catalog
+
+**Files:**
+- Modify: `lib/features/equipment/domain/constants/equipment_attribute_catalog.dart`
+- Test: `test/features/equipment/domain/equipment_attribute_catalog_test.dart`
+
+**Interfaces:**
+- Consumes: `EquipmentType.rebreather` (Task 1).
+- Produces: eight `EquipmentAttributeDef` entries reachable via `EquipmentAttributeCatalog.attributesFor(EquipmentType.rebreather)` and `EquipmentAttributeCatalog.defFor(key)`. Attribute keys: `unit_type`, `mount_configuration`, `scrubber_type`, `scrubber_duration_h`, `o2_cell_count`, `diluent_cylinder_l`, `o2_cylinder_l`, `depth_rating_m`.
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `test/features/equipment/domain/equipment_attribute_catalog_test.dart`:
+
+```dart
+  group('rebreather attributes', () {
+    test('exposes the curated rebreather keys plus the universal ones', () {
+      final keys = EquipmentAttributeCatalog.attributesFor(
+        EquipmentType.rebreather,
+      ).map((d) => d.key).toList();
+
+      expect(keys, [
+        'unit_type',
+        'mount_configuration',
+        'scrubber_type',
+        'scrubber_duration_h',
+        'o2_cell_count',
+        'diluent_cylinder_l',
+        'o2_cylinder_l',
+        'depth_rating_m',
+        'buoyancy_kg',
+        'dry_weight_kg',
+      ]);
+    });
+
+    test('unit_type covers both CCR and SCR variants', () {
+      final def = EquipmentAttributeCatalog.defFor('unit_type');
+      expect(def, isNotNull);
+      expect(def!.kind, AttributeKind.choice);
+      expect(def.choiceKeys, [
+        'eccr',
+        'mccr',
+        'hccr',
+        'scr_cmf',
+        'scr_pascr',
+        'scr_escr',
+      ]);
+    });
+
+    test('onboard cylinder attributes carry the volume dimension', () {
+      for (final key in ['diluent_cylinder_l', 'o2_cylinder_l']) {
+        final def = EquipmentAttributeCatalog.defFor(key);
+        expect(def, isNotNull, reason: key);
+        expect(def!.kind, AttributeKind.number, reason: key);
+        expect(def.dimension, AttributeDimension.volumeL, reason: key);
+      }
+    });
+
+    test('scrubber duration is dimensionless hours, not a unit-converted '
+        'quantity', () {
+      final def = EquipmentAttributeCatalog.defFor('scrubber_duration_h');
+      expect(def!.kind, AttributeKind.number);
+      expect(def.dimension, AttributeDimension.none);
+    });
+  });
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `flutter test test/features/equipment/domain/equipment_attribute_catalog_test.dart`
+Expected: FAIL — `attributesFor` returns only the two universal attributes, so the first expectation fails on list equality, and `defFor('unit_type')` returns null.
+
+- [ ] **Step 3: Add the catalog entry**
+
+In `lib/features/equipment/domain/constants/equipment_attribute_catalog.dart`, add a `rebreather` entry to the `_byType` map. Place it immediately after the `EquipmentType.tank` entry to mirror the enum ordering:
+
+```dart
+    EquipmentType.rebreather: [
+      EquipmentAttributeDef(
+        key: 'unit_type',
+        kind: AttributeKind.choice,
+        choiceKeys: [
+          'eccr',
+          'mccr',
+          'hccr',
+          'scr_cmf',
+          'scr_pascr',
+          'scr_escr',
+        ],
+      ),
+      EquipmentAttributeDef(
+        key: 'mount_configuration',
+        kind: AttributeKind.choice,
+        choiceKeys: ['back', 'chest', 'sidemount'],
+      ),
+      EquipmentAttributeDef(
+        key: 'scrubber_type',
+        kind: AttributeKind.choice,
+        choiceKeys: ['axial', 'radial'],
+      ),
+      // Rated scrubber duration in hours. Dimensionless: hours are hours in
+      // every market, so there is nothing for UnitFormatter to convert.
+      EquipmentAttributeDef(
+        key: 'scrubber_duration_h',
+        kind: AttributeKind.number,
+      ),
+      EquipmentAttributeDef(key: 'o2_cell_count', kind: AttributeKind.number),
+      EquipmentAttributeDef(
+        key: 'diluent_cylinder_l',
+        kind: AttributeKind.number,
+        dimension: AttributeDimension.volumeL,
+      ),
+      EquipmentAttributeDef(
+        key: 'o2_cylinder_l',
+        kind: AttributeKind.number,
+        dimension: AttributeDimension.volumeL,
+      ),
+      EquipmentAttributeDef(
+        key: 'depth_rating_m',
+        kind: AttributeKind.number,
+        dimension: AttributeDimension.depthM,
+      ),
+    ],
+```
+
+Note that `depth_rating_m` is deliberately reused verbatim from the `camera` entry. It is the same concept with the same dimension, so it shares one label key and needs no new ARB entry. `_byKey` is built by folding over `_byType`, and later duplicates simply overwrite earlier identical ones, so no change is needed there.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `flutter test test/features/equipment/domain/equipment_attribute_catalog_test.dart`
+Expected: PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Add rebreather attribute catalog entry (#804)"
+```
+
+---
+
+### Task 3: Localize the rebreather attributes
+
+**Files:**
+- Modify: `lib/l10n/arb/app_en.arb` and the 10 sibling `app_*.arb` files
+- Modify: `lib/features/equipment/presentation/utils/equipment_attribute_l10n.dart`
+- Test: `test/features/equipment/domain/equipment_attribute_catalog_test.dart`
+
+**Interfaces:**
+- Consumes: the eight attribute keys and eleven choice keys from Task 2.
+- Produces: `attributeLabel(l10n, key)` and `attributeChoiceLabel(l10n, key, option)` return real translations rather than falling back to the raw key.
+
+Seven new label keys are needed. `depth_rating_m` already exists (`app_en.arb:13737`) and is reused.
+
+- [ ] **Step 1: Write the failing test**
+
+This test guards the invariant that matters: every curated key resolves to something other than itself. Append to `test/features/equipment/domain/equipment_attribute_catalog_test.dart`:
+
+```dart
+  testWidgets('every rebreather attribute and choice resolves to a label',
+      (tester) async {
+    late AppLocalizations l10n;
+    await tester.pumpWidget(
+      MaterialApp(
+        locale: const Locale('en'),
+        localizationsDelegates: AppLocalizations.localizationsDelegates,
+        supportedLocales: AppLocalizations.supportedLocales,
+        home: Builder(
+          builder: (context) {
+            l10n = AppLocalizations.of(context)!;
+            return const SizedBox.shrink();
+          },
+        ),
+      ),
+    );
+
+    final defs = EquipmentAttributeCatalog.attributesFor(
+      EquipmentType.rebreather,
+    );
+    for (final def in defs) {
+      expect(
+        attributeLabel(l10n, def.key),
+        isNot(def.key),
+        reason: 'missing attrLabel_${def.key}',
+      );
+      for (final option in def.choiceKeys) {
+        expect(
+          attributeChoiceLabel(l10n, def.key, option),
+          isNot(option),
+          reason: 'missing attrChoice_${def.key}_$option',
+        );
+      }
+    }
+  });
+```
+
+Add these imports to the file if absent:
+
+```dart
+import 'package:flutter/material.dart';
+import 'package:submersion/l10n/arb/app_localizations.dart';
+import 'package:submersion/features/equipment/presentation/utils/equipment_attribute_l10n.dart';
+```
+
+Pinning `locale: const Locale('en')` on the `MaterialApp` is required. Without it the host locale leaks in and the test resolves against whatever locale the machine happens to have.
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `flutter test test/features/equipment/domain/equipment_attribute_catalog_test.dart`
+Expected: FAIL — `attributeLabel` falls through its switch to `_ => key`, so `attributeLabel(l10n, 'unit_type')` returns `'unit_type'`.
+
+- [ ] **Step 3: Add the English ARB entries**
+
+In `lib/l10n/arb/app_en.arb`, add after `"attrLabel_dry_weight_kg"`:
+
+```json
+  "attrLabel_unit_type": "Unit type",
+  "attrLabel_mount_configuration": "Mount",
+  "attrLabel_scrubber_type": "Scrubber type",
+  "attrLabel_scrubber_duration_h": "Scrubber duration (h)",
+  "attrLabel_o2_cell_count": "O2 cells",
+  "attrLabel_diluent_cylinder_l": "Diluent cylinder",
+  "attrLabel_o2_cylinder_l": "O2 cylinder",
+  "attrChoice_unit_type_eccr": "Electronic CCR (eCCR)",
+  "attrChoice_unit_type_mccr": "Manual CCR (mCCR)",
+  "attrChoice_unit_type_hccr": "Hybrid CCR (hCCR)",
+  "attrChoice_unit_type_scr_cmf": "SCR - constant mass flow",
+  "attrChoice_unit_type_scr_pascr": "SCR - passive addition",
+  "attrChoice_unit_type_scr_escr": "SCR - electronically controlled",
+  "attrChoice_mount_configuration_back": "Back mount",
+  "attrChoice_mount_configuration_chest": "Chest mount",
+  "attrChoice_mount_configuration_sidemount": "Sidemount",
+  "attrChoice_scrubber_type_axial": "Axial",
+  "attrChoice_scrubber_type_radial": "Radial"
+```
+
+Match the surrounding style: these keys carry no `@` description entries.
+
+- [ ] **Step 4: Translate into the other 10 locales**
+
+Add the same 18 keys to every other `app_*.arb` file with real translations. Rules that matter:
+
+- `eCCR`, `mCCR`, `hCCR`, `SCR`, `CCR` are international abbreviations. Keep them verbatim in every locale; translate only the surrounding words.
+- `O2` stays `O2` everywhere.
+- `app_ar.arb` and `app_he.arb` are RTL. Write natural RTL text; do not insert directional control characters.
+
+Confirm the file count first:
+
+```bash
+ls lib/l10n/arb/*.arb | wc -l   # must print 11
+```
+
+- [ ] **Step 5: Add the resolver arms**
+
+In `lib/features/equipment/presentation/utils/equipment_attribute_l10n.dart`, add to the `attributeLabel` switch, before the `_ => key` fallback:
+
+```dart
+  'unit_type' => l10n.attrLabel_unit_type,
+  'mount_configuration' => l10n.attrLabel_mount_configuration,
+  'scrubber_type' => l10n.attrLabel_scrubber_type,
+  'scrubber_duration_h' => l10n.attrLabel_scrubber_duration_h,
+  'o2_cell_count' => l10n.attrLabel_o2_cell_count,
+  'diluent_cylinder_l' => l10n.attrLabel_diluent_cylinder_l,
+  'o2_cylinder_l' => l10n.attrLabel_o2_cylinder_l,
+```
+
+And to the `attributeChoiceLabel` switch, before its fallback:
+
+```dart
+      'unit_type_eccr' => l10n.attrChoice_unit_type_eccr,
+      'unit_type_mccr' => l10n.attrChoice_unit_type_mccr,
+      'unit_type_hccr' => l10n.attrChoice_unit_type_hccr,
+      'unit_type_scr_cmf' => l10n.attrChoice_unit_type_scr_cmf,
+      'unit_type_scr_pascr' => l10n.attrChoice_unit_type_scr_pascr,
+      'unit_type_scr_escr' => l10n.attrChoice_unit_type_scr_escr,
+      'mount_configuration_back' => l10n.attrChoice_mount_configuration_back,
+      'mount_configuration_chest' => l10n.attrChoice_mount_configuration_chest,
+      'mount_configuration_sidemount' =>
+        l10n.attrChoice_mount_configuration_sidemount,
+      'scrubber_type_axial' => l10n.attrChoice_scrubber_type_axial,
+      'scrubber_type_radial' => l10n.attrChoice_scrubber_type_radial,
+```
+
+`depth_rating_m` needs no new arm — it is already in the switch at line 31.
+
+- [ ] **Step 6: Regenerate localizations**
+
+Run: `flutter gen-l10n`
+Expected: `lib/l10n/arb/app_localizations*.dart` regenerate with the new getters.
+
+Run this from the **worktree root**. Generated l10n written from the main checkout lands in the wrong tree.
+
+- [ ] **Step 7: Run test to verify it passes**
+
+Run: `flutter test test/features/equipment/domain/equipment_attribute_catalog_test.dart`
+Expected: PASS
+
+- [ ] **Step 8: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Localize rebreather equipment attributes (#804)"
+```
+
+---
+
+### Task 4: Verify the rebreather round-trips through the equipment UI
+
+**Files:**
+- Test: `test/features/equipment/data/equipment_attribute_repository_test.dart`
+
+**Interfaces:**
+- Consumes: `EquipmentType.rebreather`, the catalog entry, `EquipmentAttribute.curated`.
+- Produces: nothing new. This task proves Phase 1 is genuinely usable before moving on.
+
+The attribute methods live on `EquipmentRepository`
+(`lib/features/equipment/data/repositories/equipment_repository_impl.dart`),
+not on a separate attribute repository. The exact signatures are
+`Future<void> saveAttributes(String equipmentId, List<EquipmentAttribute> desired)`
+(line 815) and
+`Future<List<EquipmentAttribute>> getAttributesForEquipment(String equipmentId)`
+(line 782). Note that `saveAttributes` filters out attributes where
+`hasValue` is false, so an attribute with neither `valueText` nor `valueNum`
+is silently dropped by design.
+
+- [ ] **Step 1: Write the test**
+
+Append to `test/features/equipment/data/equipment_attribute_repository_test.dart`, following the fixture setup already used by the tests in that file:
+
+```dart
+  test('a rebreather item persists and reloads its curated attributes',
+      () async {
+    const equipmentId = 'rb-1';
+    await repository.saveAttributes(equipmentId, [
+      EquipmentAttribute.curated(
+        equipmentId: equipmentId,
+        key: 'unit_type',
+        valueText: 'eccr',
+      ),
+      EquipmentAttribute.curated(
+        equipmentId: equipmentId,
+        key: 'scrubber_duration_h',
+        valueNum: 3.0,
+      ),
+      EquipmentAttribute.curated(
+        equipmentId: equipmentId,
+        key: 'o2_cell_count',
+        valueNum: 3,
+      ),
+    ]);
+
+    final loaded = await repository.getAttributesForEquipment(equipmentId);
+    final byKey = {for (final a in loaded) a.key: a};
+
+    expect(byKey['unit_type']!.valueText, 'eccr');
+    expect(byKey['scrubber_duration_h']!.valueNum, 3.0);
+    expect(byKey['o2_cell_count']!.valueNum, 3);
+
+    // Curated ids are deterministic so independent devices converge.
+    expect(byKey['unit_type']!.id, 'attr_${equipmentId}_unit_type');
+  });
+```
+
+If the existing tests in this file name the repository variable or setup helper differently, follow that file's conventions rather than introducing new ones. Read the top of the file first.
+
+- [ ] **Step 2: Run the test**
+
+Run: `flutter test test/features/equipment/data/equipment_attribute_repository_test.dart`
+Expected: PASS immediately. Phase 1 added no storage code — the attribute table is type-agnostic, and this test proves it.
+
+If it fails, the failure is real and belongs to Task 2's catalog wiring. Fix before continuing.
+
+- [ ] **Step 3: Manual smoke check**
+
+Run: `flutter run -d macos`
+
+Verify by hand:
+1. Equipment tab, add item, type dropdown offers **Rebreather**.
+2. Selecting it shows the eight attribute fields with translated labels.
+3. `Unit type` offers all six choices with readable names.
+4. `Diluent cylinder` and `O2 cylinder` display in the diver's configured volume unit.
+5. Save, reopen the item, values persist.
+
+- [ ] **Step 4: Run the full equipment suite**
+
+Run: `flutter test test/features/equipment/`
+Expected: all pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+dart format .
+git add -A
+git commit -m "Add rebreather attribute persistence test (#804)"
+```
+
+---
+
+# Phase 3 — Rebreather service kinds
+
+Depends on Phase 1 (needs `'rebreather'` for `applicable_types`). Tasks 5-7. Sequenced before Phase 2 because it is small, mechanical, and gated on Phase 1 alone.
+
+---
+
+### Task 5: Add an hours column to the built-in service kind seed
+
+**Files:**
+- Modify: `lib/core/database/database.dart:2113-2141` (`kSeedBuiltInServiceKindsSql`)
+- Test: `test/core/database/service_ledger_schema_test.dart`
+
+**Interfaces:**
+- Consumes: nothing.
+- Produces: `kSeedBuiltInServiceKindsSql` gains an `hours` column in its inline `SELECT`, so built-in kinds can carry a `default_interval_hours`.
+
+The current SQL hardcodes `NULL` for `default_interval_hours` because no built-in has ever needed one. This task changes the shape without changing any existing kind's behavior — a pure refactor, verified by a test that pins the existing kinds first.
+
+- [ ] **Step 1: Write the characterization test**
+
+Append to `test/core/database/service_ledger_schema_test.dart`:
+
+```dart
+  test('existing built-in service kinds keep null hour intervals', () async {
+    final db = AppDatabase(NativeDatabase.memory());
+    addTearDown(db.close);
+
+    final rows = await db
+        .customSelect(
+          'SELECT id, default_interval_days, default_interval_dives, '
+          'default_interval_hours FROM service_kinds WHERE is_built_in = 1',
+        )
+        .get();
+    final byId = {for (final r in rows) r.read<String>('id'): r};
+
+    expect(byId.keys, containsAll(<String>[
+      'hydro',
+      'vip',
+      'o2-clean',
+      'regulator-service',
+      'computer-battery',
+      'transmitter-battery',
+      'bcd-inspection',
+      'drysuit-seals',
+      'general-service',
+    ]));
+
+    expect(byId['hydro']!.read<int?>('default_interval_days'), 1825);
+    expect(byId['hydro']!.read<double?>('default_interval_hours'), isNull);
+    expect(
+      byId['regulator-service']!.read<int?>('default_interval_dives'),
+      100,
+    );
+    expect(
+      byId['general-service']!.read<int?>('default_interval_days'),
+      isNull,
+    );
+  });
+```
+
+- [ ] **Step 2: Run test to verify it passes**
+
+Run: `flutter test test/core/database/service_ledger_schema_test.dart`
+Expected: PASS. This is a characterization test — it pins current behavior so the refactor in Step 3 cannot change it silently.
+
+- [ ] **Step 3: Add the hours column to the seed SQL**
+
+In `lib/core/database/database.dart`, replace `kSeedBuiltInServiceKindsSql` with:
+
+```dart
+/// Built-in service kinds: identical on every device, stable slug ids
+/// (service_schedules.service_kind_id references them), INSERT OR IGNORE
+/// so re-running is a no-op. Intervals per tech-diving convention.
+const String kSeedBuiltInServiceKindsSql = '''
+  INSERT OR IGNORE INTO service_kinds
+    (id, diver_id, name, applicable_types, default_interval_days,
+     default_interval_dives, default_interval_hours, auto_attach,
+     is_built_in, created_at, updated_at)
+  SELECT t.id, NULL, t.name, t.types, t.days, t.dives, t.hours, t.auto, 1,
+         n.now_ms, n.now_ms
+  FROM (
+    SELECT 'hydro' AS id, 'Hydrostatic test' AS name, '["tank"]' AS types,
+           1825 AS days, NULL AS dives, NULL AS hours, 1 AS auto
+    UNION ALL SELECT 'vip', 'Visual inspection (VIP)', '["tank"]',
+           365, NULL, NULL, 1
+    UNION ALL SELECT 'o2-clean', 'O2 clean', '["tank"]', 365, NULL, NULL, 0
+    UNION ALL SELECT 'regulator-service', 'Regulator service',
+           '["regulator"]', 365, 100, NULL, 1
+    UNION ALL SELECT 'computer-battery', 'Computer battery', '["computer"]',
+           730, NULL, NULL, 1
+    UNION ALL SELECT 'transmitter-battery', 'Transmitter battery',
+           '["transmitter"]', 365, NULL, NULL, 1
+    UNION ALL SELECT 'bcd-inspection', 'BCD/wing inspection', '["bcd"]',
+           365, NULL, NULL, 1
+    UNION ALL SELECT 'drysuit-seals', 'Drysuit seals', '["drysuit"]',
+           730, NULL, NULL, 0
+    UNION ALL SELECT 'general-service', 'General service', '[]',
+           NULL, NULL, NULL, 0
+  ) t
+  CROSS JOIN (SELECT CAST(strftime('%s','now') AS INTEGER) * 1000 AS now_ms) n
+''';
+```
+
+Every row gained an `hours` position between `dives` and `auto`. The first `SELECT` declares the column alias; the `UNION ALL` rows are positional. Getting the column count wrong on any single row is a SQLite error at seed time, which surfaces as a database that fails to open — so count them.
+
+- [ ] **Step 4: Run test to verify it still passes**
+
+Run: `flutter test test/core/database/service_ledger_schema_test.dart`
+Expected: PASS, unchanged. If any assertion now fails, a positional column slipped.
+
+- [ ] **Step 5: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Allow built-in service kinds to declare hour intervals (#804)"
+```
+
+---
+
+### Task 6: Seed the three rebreather service kinds
+
+**Files:**
+- Modify: `lib/core/database/database.dart` (`kSeedBuiltInServiceKindsSql`)
+- Test: `test/core/database/service_ledger_schema_test.dart`
+
+**Interfaces:**
+- Consumes: the `hours` column from Task 5; `'rebreather'` from Task 1.
+- Produces: built-in service kind slugs `scrubber-repack`, `o2-cell-replacement`, `rebreather-annual`, all with `applicable_types = '["rebreather"]'` and `auto_attach = 1`.
+
+- [ ] **Step 1: Write the failing test**
+
+Append to `test/core/database/service_ledger_schema_test.dart`:
+
+```dart
+  test('rebreather built-in service kinds seed with the expected clocks',
+      () async {
+    final db = AppDatabase(NativeDatabase.memory());
+    addTearDown(db.close);
+
+    final rows = await db
+        .customSelect(
+          "SELECT id, name, applicable_types, default_interval_days, "
+          "default_interval_hours, auto_attach FROM service_kinds "
+          "WHERE id IN ('scrubber-repack', 'o2-cell-replacement', "
+          "'rebreather-annual')",
+        )
+        .get();
+    final byId = {for (final r in rows) r.read<String>('id'): r};
+
+    expect(byId.length, 3);
+
+    final scrubber = byId['scrubber-repack']!;
+    expect(scrubber.read<double?>('default_interval_hours'), 3.0);
+    expect(scrubber.read<int?>('default_interval_days'), isNull);
+    expect(scrubber.read<int>('auto_attach'), 1);
+
+    final cells = byId['o2-cell-replacement']!;
+    expect(cells.read<int?>('default_interval_days'), 365);
+    expect(cells.read<double?>('default_interval_hours'), isNull);
+
+    final annual = byId['rebreather-annual']!;
+    expect(annual.read<int?>('default_interval_days'), 365);
+
+    for (final row in byId.values) {
+      expect(row.read<String>('applicable_types'), '["rebreather"]');
+    }
+  });
+
+  test('re-running the built-in seed is a no-op', () async {
+    final db = AppDatabase(NativeDatabase.memory());
+    addTearDown(db.close);
+
+    await db.customStatement(kSeedBuiltInServiceKindsSql);
+    await db.customStatement(kSeedBuiltInServiceKindsSql);
+
+    final count = await db
+        .customSelect(
+          "SELECT COUNT(*) AS c FROM service_kinds "
+          "WHERE id = 'scrubber-repack'",
+        )
+        .getSingle();
+    expect(count.read<int>('c'), 1);
+  });
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `flutter test test/core/database/service_ledger_schema_test.dart`
+Expected: FAIL — `expect(byId.length, 3)` gets 0.
+
+- [ ] **Step 3: Add the three rows**
+
+In `kSeedBuiltInServiceKindsSql`, insert before the `general-service` row so the catch-all stays last:
+
+```sql
+    UNION ALL SELECT 'scrubber-repack', 'Scrubber repack', '["rebreather"]',
+           NULL, NULL, 3.0, 1
+    UNION ALL SELECT 'o2-cell-replacement', 'O2 cell replacement',
+           '["rebreather"]', 365, NULL, NULL, 1
+    UNION ALL SELECT 'rebreather-annual', 'Rebreather annual service',
+           '["rebreather"]', 365, NULL, NULL, 1
+```
+
+The column order is `id, name, types, days, dives, hours, auto`. Scrubber repack is hours-only: a scrubber is consumed by loop time, not by the calendar.
+
+3.0 hours is a deliberately conservative default across the 2-6 hour range real units are rated for. The diver overrides it per unit on the schedule, which is exactly what `ServiceSchedule.intervalHours` is for.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `flutter test test/core/database/service_ledger_schema_test.dart`
+Expected: PASS
+
+- [ ] **Step 5: Verify existing databases pick the kinds up**
+
+The seed already runs from both `onCreate` (`database.dart:4169`) and the v122 `beforeOpen` backstop (`database.dart:3675`), and `INSERT OR IGNORE` makes it idempotent. No new migration is needed. Prove it against an upgraded database:
+
+```dart
+  test('a database created before the rebreather kinds gains them on reopen',
+      () async {
+    final db = AppDatabase(NativeDatabase.memory());
+    addTearDown(db.close);
+
+    await db.customStatement(
+      "DELETE FROM service_kinds WHERE id = 'scrubber-repack'",
+    );
+    expect(
+      (await db
+              .customSelect(
+                "SELECT COUNT(*) AS c FROM service_kinds "
+                "WHERE id = 'scrubber-repack'",
+              )
+              .getSingle())
+          .read<int>('c'),
+      0,
+    );
+
+    await db.customStatement(kSeedBuiltInServiceKindsSql);
+
+    expect(
+      (await db
+              .customSelect(
+                "SELECT COUNT(*) AS c FROM service_kinds "
+                "WHERE id = 'scrubber-repack'",
+              )
+              .getSingle())
+          .read<int>('c'),
+      1,
+    );
+  });
+```
+
+Run: `flutter test test/core/database/service_ledger_schema_test.dart`
+Expected: PASS
+
+- [ ] **Step 6: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Seed rebreather service kinds for scrubber, cells, and annual (#804)"
+```
+
+---
+
+### Task 7: Document the loop-time approximation in the UI
+
+**Files:**
+- Modify: `lib/features/equipment/presentation/widgets/service_clocks_card.dart`
+- Modify: all 11 `lib/l10n/arb/app_*.arb` files
+- Test: `test/features/equipment/presentation/` (add `service_clocks_hours_caption_test.dart`)
+
+**Interfaces:**
+- Consumes: the `scrubber-repack` kind from Task 6.
+- Produces: a caption on hours-based clocks reading "Counted from logged dive time" (English).
+
+`ServiceDueEngine` sums dive **duration** for hours-based clocks (`service_due_engine.dart:59-61`). That approximates rebreather loop time but excludes pre-breathe and surface loop time. A diver trusting a scrubber clock deserves to know what it counts.
+
+- [ ] **Step 1: Read the widget first**
+
+Run: `cat lib/features/equipment/presentation/widgets/service_clocks_card.dart`
+
+Find where an hours-based `ServiceClockStatus` renders its remaining value. Match the file's existing text style and theme usage rather than inventing new patterns.
+
+- [ ] **Step 2: Write the failing test**
+
+Create `test/features/equipment/presentation/service_clocks_hours_caption_test.dart`. Build the widget with one hours-based clock and one days-based clock, then assert:
+
+```dart
+    expect(find.text('Counted from logged dive time'), findsOneWidget);
+```
+
+Construct the fixture with a `ServiceSchedule` carrying `intervalHours: 3.0` and a `ServiceKind` with `id: 'scrubber-repack'`. Pin `locale: const Locale('en')` on the host `MaterialApp` — an unpinned locale makes this test machine-dependent.
+
+- [ ] **Step 3: Run test to verify it fails**
+
+Run: `flutter test test/features/equipment/presentation/service_clocks_hours_caption_test.dart`
+Expected: FAIL — `findsNothing` where one widget was expected.
+
+- [ ] **Step 4: Add the ARB key**
+
+To `lib/l10n/arb/app_en.arb`:
+
+```json
+  "serviceClockHoursSource": "Counted from logged dive time"
+```
+
+Translate into the other 10 ARB files, then run `flutter gen-l10n`.
+
+- [ ] **Step 5: Render the caption**
+
+In `service_clocks_card.dart`, show `l10n.serviceClockHoursSource` beneath the remaining-hours figure, only when the clock's effective interval is hours-based. Use the same muted caption treatment the file already uses for secondary text.
+
+- [ ] **Step 6: Run test to verify it passes**
+
+Run: `flutter test test/features/equipment/presentation/service_clocks_hours_caption_test.dart`
+Expected: PASS
+
+- [ ] **Step 7: Run the full equipment suite**
+
+Run: `flutter test test/features/equipment/`
+Expected: all pass. If other widget tests in this directory now fail on text-finder counts, they are asserting against the card's rendered text and need their expectations updated — a known consequence of adding text to a shared widget.
+
+- [ ] **Step 8: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Caption hours-based service clocks with their data source (#804)"
+```
+
+---
+
+# Phase 2 — Cylinder configurations
+
+Schema v139. Tasks 8-16. The largest phase; depends on Phase 1 only for the optional owning-unit link.
+
+---
+
+### Task 8: Domain entities
+
+**Files:**
+- Create: `lib/features/cylinder_configs/domain/entities/cylinder_config.dart`
+- Create: `lib/features/cylinder_configs/domain/entities/cylinder_config_item.dart`
+- Test: `test/features/cylinder_configs/domain/entities/cylinder_config_test.dart`
+
+**Interfaces:**
+- Consumes: `TankRole` and `TankMaterial` from `lib/core/constants/enums.dart`.
+- Produces:
+  - `CylinderConfig({required String id, String? diverId, String? equipmentId, required String name, String description = '', int sortOrder = 0, List<CylinderConfigItem> items = const [], required DateTime createdAt, required DateTime updatedAt})` with `copyWith` and `bool get isOwnedByUnit`.
+  - `CylinderConfigItem({required String id, required String configId, int sortOrder = 0, String? label, required TankRole tankRole, double? volumeL, double? workingPressureBar, TankMaterial? tankMaterial, double o2Percent = 21, double hePercent = 0, double? defaultStartPressureBar, required DateTime createdAt, required DateTime updatedAt})` with `copyWith`.
+
+- [ ] **Step 1: Write the failing test**
+
+Create `test/features/cylinder_configs/domain/entities/cylinder_config_test.dart`:
+
+```dart
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+
+void main() {
+  final now = DateTime.utc(2026, 8, 5);
+
+  CylinderConfigItem item({
+    String id = 'i1',
+    TankRole role = TankRole.bailout,
+    double o2 = 21,
+  }) => CylinderConfigItem(
+    id: id,
+    configId: 'c1',
+    tankRole: role,
+    o2Percent: o2,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  test('a config with an equipmentId is owned by a unit', () {
+    final owned = CylinderConfig(
+      id: 'c1',
+      name: 'JJ trimix',
+      equipmentId: 'rb-1',
+      createdAt: now,
+      updatedAt: now,
+    );
+    expect(owned.isOwnedByUnit, isTrue);
+
+    final generic = owned.copyWith(clearEquipmentId: true);
+    expect(generic.isOwnedByUnit, isFalse);
+    expect(generic.name, 'JJ trimix');
+  });
+
+  test('items default to air and back gas is not assumed', () {
+    final i = item();
+    expect(i.o2Percent, 21);
+    expect(i.hePercent, 0);
+    expect(i.tankRole, TankRole.bailout);
+    expect(i.volumeL, isNull);
+    expect(i.tankMaterial, isNull);
+  });
+
+  test('equality is by value, so provider rebuilds are stable', () {
+    expect(item(), equals(item()));
+    expect(item(o2: 32), isNot(equals(item())));
+  });
+
+  test('copyWith replaces the item list wholesale', () {
+    final config = CylinderConfig(
+      id: 'c1',
+      name: 'Doubles + 50',
+      createdAt: now,
+      updatedAt: now,
+      items: [item(id: 'a')],
+    );
+    final updated = config.copyWith(items: [item(id: 'a'), item(id: 'b')]);
+    expect(config.items.length, 1);
+    expect(updated.items.length, 2);
+  });
+}
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `flutter test test/features/cylinder_configs/domain/entities/cylinder_config_test.dart`
+Expected: FAIL — the files do not exist.
+
+- [ ] **Step 3: Write the entities**
+
+Create `lib/features/cylinder_configs/domain/entities/cylinder_config_item.dart`:
+
+```dart
+import 'package:equatable/equatable.dart';
+
+import 'package:submersion/core/constants/enums.dart';
+
+/// One cylinder in a reusable configuration. The cylinder spec is a snapshot,
+/// not a reference: a tank preset may populate volume/pressure/material at
+/// edit time, but the config then owns those values. A configuration records
+/// what the diver actually dives, so later edits to a preset must not rewrite
+/// its meaning.
+class CylinderConfigItem extends Equatable {
+  final String id;
+  final String configId;
+  final int sortOrder;
+
+  /// Free-text label such as "Bailout 1" or "AL80 EAN50". Maps to
+  /// dive_tanks.tank_name when applied.
+  final String? label;
+
+  final TankRole tankRole;
+  final double? volumeL;
+  final double? workingPressureBar;
+  final TankMaterial? tankMaterial;
+  final double o2Percent;
+  final double hePercent;
+  final double? defaultStartPressureBar;
+  final DateTime createdAt;
+  final DateTime updatedAt;
+
+  const CylinderConfigItem({
+    required this.id,
+    required this.configId,
+    this.sortOrder = 0,
+    this.label,
+    required this.tankRole,
+    this.volumeL,
+    this.workingPressureBar,
+    this.tankMaterial,
+    this.o2Percent = 21,
+    this.hePercent = 0,
+    this.defaultStartPressureBar,
+    required this.createdAt,
+    required this.updatedAt,
+  });
+
+  CylinderConfigItem copyWith({
+    String? id,
+    String? configId,
+    int? sortOrder,
+    String? label,
+    bool clearLabel = false,
+    TankRole? tankRole,
+    double? volumeL,
+    bool clearVolumeL = false,
+    double? workingPressureBar,
+    bool clearWorkingPressureBar = false,
+    TankMaterial? tankMaterial,
+    bool clearTankMaterial = false,
+    double? o2Percent,
+    double? hePercent,
+    double? defaultStartPressureBar,
+    bool clearDefaultStartPressureBar = false,
+    DateTime? createdAt,
+    DateTime? updatedAt,
+  }) => CylinderConfigItem(
+    id: id ?? this.id,
+    configId: configId ?? this.configId,
+    sortOrder: sortOrder ?? this.sortOrder,
+    label: clearLabel ? null : (label ?? this.label),
+    tankRole: tankRole ?? this.tankRole,
+    volumeL: clearVolumeL ? null : (volumeL ?? this.volumeL),
+    workingPressureBar: clearWorkingPressureBar
+        ? null
+        : (workingPressureBar ?? this.workingPressureBar),
+    tankMaterial: clearTankMaterial
+        ? null
+        : (tankMaterial ?? this.tankMaterial),
+    o2Percent: o2Percent ?? this.o2Percent,
+    hePercent: hePercent ?? this.hePercent,
+    defaultStartPressureBar: clearDefaultStartPressureBar
+        ? null
+        : (defaultStartPressureBar ?? this.defaultStartPressureBar),
+    createdAt: createdAt ?? this.createdAt,
+    updatedAt: updatedAt ?? this.updatedAt,
+  );
+
+  @override
+  List<Object?> get props => [
+    id,
+    configId,
+    sortOrder,
+    label,
+    tankRole,
+    volumeL,
+    workingPressureBar,
+    tankMaterial,
+    o2Percent,
+    hePercent,
+    defaultStartPressureBar,
+  ];
+}
+```
+
+Create `lib/features/cylinder_configs/domain/entities/cylinder_config.dart`:
+
+```dart
+import 'package:equatable/equatable.dart';
+
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+
+/// A named, reusable set of cylinders. When [equipmentId] is set the config
+/// reads as "a configuration for this rebreather"; when null it is a generic
+/// gas plan any dive can use. Deleting the owning unit sets the column null
+/// rather than cascading, demoting the config instead of destroying it.
+class CylinderConfig extends Equatable {
+  final String id;
+  final String? diverId;
+  final String? equipmentId;
+  final String name;
+  final String description;
+  final int sortOrder;
+  final List<CylinderConfigItem> items;
+  final DateTime createdAt;
+  final DateTime updatedAt;
+
+  const CylinderConfig({
+    required this.id,
+    this.diverId,
+    this.equipmentId,
+    required this.name,
+    this.description = '',
+    this.sortOrder = 0,
+    this.items = const [],
+    required this.createdAt,
+    required this.updatedAt,
+  });
+
+  bool get isOwnedByUnit => equipmentId != null;
+
+  CylinderConfig copyWith({
+    String? id,
+    String? diverId,
+    bool clearDiverId = false,
+    String? equipmentId,
+    bool clearEquipmentId = false,
+    String? name,
+    String? description,
+    int? sortOrder,
+    List<CylinderConfigItem>? items,
+    DateTime? createdAt,
+    DateTime? updatedAt,
+  }) => CylinderConfig(
+    id: id ?? this.id,
+    diverId: clearDiverId ? null : (diverId ?? this.diverId),
+    equipmentId: clearEquipmentId ? null : (equipmentId ?? this.equipmentId),
+    name: name ?? this.name,
+    description: description ?? this.description,
+    sortOrder: sortOrder ?? this.sortOrder,
+    items: items ?? this.items,
+    createdAt: createdAt ?? this.createdAt,
+    updatedAt: updatedAt ?? this.updatedAt,
+  );
+
+  @override
+  List<Object?> get props => [
+    id,
+    diverId,
+    equipmentId,
+    name,
+    description,
+    sortOrder,
+    items,
+  ];
+}
+```
+
+`createdAt` and `updatedAt` are deliberately excluded from `props` on both entities, matching `EquipmentSet`. Timestamps churn on every write and would defeat Riverpod's equality-based rebuild suppression.
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `flutter test test/features/cylinder_configs/domain/entities/cylinder_config_test.dart`
+Expected: PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Add cylinder configuration domain entities (#804)"
+```
+
+---
+
+### Task 9: The merge algorithm
+
+**Files:**
+- Create: `lib/features/cylinder_configs/domain/services/cylinder_config_applier.dart`
+- Test: `test/features/cylinder_configs/domain/services/cylinder_config_applier_test.dart`
+
+**Interfaces:**
+- Consumes: `CylinderConfigItem` (Task 8), `TankRole`, `TankMaterial`.
+- Produces:
+  - `class ExistingTank` — the applier's input view of a `dive_tanks` row: `({String id, TankRole tankRole, double? volumeL, double? workingPressureBar, TankMaterial? tankMaterial, double? startPressureBar, String? tankName, int tankOrder})`.
+  - `sealed class CylinderConfigOp` with subtypes `InsertTank` and `FillTank`.
+  - `class CylinderConfigPlan { List<CylinderConfigOp> ops; int insertedCount; int keptCount; }`
+  - `CylinderConfigApplier.plan({required List<ExistingTank> existing, required List<CylinderConfigItem> items}) -> CylinderConfigPlan`
+
+This is the highest-risk code in the plan and the reason it is a pure service: no database, no `DateTime.now()`, mirroring `ServiceDueEngine`.
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `test/features/cylinder_configs/domain/services/cylinder_config_applier_test.dart`:
+
+```dart
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+import 'package:submersion/features/cylinder_configs/domain/services/cylinder_config_applier.dart';
+
+void main() {
+  final now = DateTime.utc(2026, 8, 5);
+  const applier = CylinderConfigApplier();
+
+  CylinderConfigItem cfg({
+    required String id,
+    required TankRole role,
+    int order = 0,
+    double o2 = 21,
+    double he = 0,
+    double? volume,
+    double? pressure,
+    TankMaterial? material,
+    double? startPressure,
+    String? label,
+  }) => CylinderConfigItem(
+    id: id,
+    configId: 'c1',
+    sortOrder: order,
+    tankRole: role,
+    o2Percent: o2,
+    hePercent: he,
+    volumeL: volume,
+    workingPressureBar: pressure,
+    tankMaterial: material,
+    defaultStartPressureBar: startPressure,
+    label: label,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  ExistingTank tank({
+    required String id,
+    required TankRole role,
+    double? volume,
+    double? pressure,
+    TankMaterial? material,
+    double? startPressure,
+    String? name,
+    int order = 0,
+  }) => ExistingTank(
+    id: id,
+    tankRole: role,
+    volumeL: volume,
+    workingPressureBar: pressure,
+    tankMaterial: material,
+    startPressureBar: startPressure,
+    tankName: name,
+    tankOrder: order,
+  );
+
+  test('an empty dive gets every cylinder inserted, in sort order', () {
+    final plan = applier.plan(
+      existing: const [],
+      items: [
+        cfg(id: 'b', role: TankRole.oxygenSupply, order: 1),
+        cfg(id: 'a', role: TankRole.diluent, order: 0),
+        cfg(id: 'c', role: TankRole.bailout, order: 2),
+      ],
+    );
+
+    expect(plan.insertedCount, 3);
+    expect(plan.keptCount, 0);
+    expect(plan.ops.whereType<FillTank>(), isEmpty);
+
+    final inserts = plan.ops.whereType<InsertTank>().toList();
+    expect(
+      inserts.map((o) => o.item.tankRole),
+      [TankRole.diluent, TankRole.oxygenSupply, TankRole.bailout],
+    );
+    expect(inserts.map((o) => o.tankOrder), [0, 1, 2]);
+  });
+
+  test('inserted tank order continues after the existing maximum', () {
+    final plan = applier.plan(
+      existing: [tank(id: 't1', role: TankRole.diluent, order: 7)],
+      items: [
+        cfg(id: 'a', role: TankRole.diluent, order: 0),
+        cfg(id: 'b', role: TankRole.bailout, order: 1),
+      ],
+    );
+
+    final inserts = plan.ops.whereType<InsertTank>().toList();
+    expect(inserts, hasLength(1));
+    expect(inserts.single.tankOrder, 8);
+  });
+
+  test('a downloaded gas mix is never overwritten', () {
+    final plan = applier.plan(
+      existing: [tank(id: 't1', role: TankRole.diluent)],
+      items: [cfg(id: 'a', role: TankRole.diluent, o2: 18, he: 45)],
+    );
+
+    expect(plan.insertedCount, 0);
+    expect(plan.keptCount, 1);
+
+    final fill = plan.ops.whereType<FillTank>().single;
+    expect(fill.tankId, 't1');
+    // No gas fields on FillTank at all: overwriting is not expressible.
+    expect(fill.volumeL, isNull);
+    expect(fill.workingPressureBar, isNull);
+  });
+
+  test('only null columns are filled on a claimed tank', () {
+    final plan = applier.plan(
+      existing: [
+        tank(
+          id: 't1',
+          role: TankRole.bailout,
+          volume: 11.1,
+          name: 'Downloaded',
+        ),
+      ],
+      items: [
+        cfg(
+          id: 'a',
+          role: TankRole.bailout,
+          volume: 5.7,
+          pressure: 207,
+          material: TankMaterial.aluminum,
+          startPressure: 200,
+          label: 'Bailout 1',
+        ),
+      ],
+    );
+
+    final fill = plan.ops.whereType<FillTank>().single;
+    expect(fill.volumeL, isNull, reason: 'already 11.1, must not be touched');
+    expect(fill.tankName, isNull, reason: 'already named');
+    expect(fill.workingPressureBar, 207);
+    expect(fill.tankMaterial, TankMaterial.aluminum);
+    expect(fill.startPressureBar, 200);
+  });
+
+  test('duplicate roles claim one existing tank each, then insert', () {
+    final plan = applier.plan(
+      existing: [tank(id: 't1', role: TankRole.bailout, order: 0)],
+      items: [
+        cfg(id: 'a', role: TankRole.bailout, order: 0, pressure: 207),
+        cfg(id: 'b', role: TankRole.bailout, order: 1, pressure: 232),
+      ],
+    );
+
+    expect(plan.keptCount, 1);
+    expect(plan.insertedCount, 1);
+    expect(plan.ops.whereType<FillTank>().single.tankId, 't1');
+    expect(
+      plan.ops.whereType<InsertTank>().single.item.workingPressureBar,
+      232,
+    );
+  });
+
+  test('two existing tanks of one role are both claimed before inserting', () {
+    final plan = applier.plan(
+      existing: [
+        tank(id: 't1', role: TankRole.bailout, order: 0),
+        tank(id: 't2', role: TankRole.bailout, order: 1),
+      ],
+      items: [
+        cfg(id: 'a', role: TankRole.bailout, order: 0),
+        cfg(id: 'b', role: TankRole.bailout, order: 1),
+      ],
+    );
+
+    expect(plan.keptCount, 2);
+    expect(plan.insertedCount, 0);
+    expect(
+      plan.ops.whereType<FillTank>().map((o) => o.tankId),
+      ['t1', 't2'],
+    );
+  });
+
+  test('extra existing tanks the config does not mention are left alone', () {
+    final plan = applier.plan(
+      existing: [
+        tank(id: 't1', role: TankRole.diluent),
+        tank(id: 't2', role: TankRole.stage),
+      ],
+      items: [cfg(id: 'a', role: TankRole.diluent)],
+    );
+
+    expect(plan.keptCount, 1);
+    expect(plan.insertedCount, 0);
+    expect(plan.ops.whereType<FillTank>().map((o) => o.tankId), ['t1']);
+  });
+
+  test('a claimed tank needing no fill produces no FillTank op', () {
+    final plan = applier.plan(
+      existing: [
+        tank(
+          id: 't1',
+          role: TankRole.diluent,
+          volume: 3,
+          pressure: 232,
+          material: TankMaterial.steel,
+          startPressure: 200,
+          name: 'Dil',
+        ),
+      ],
+      items: [cfg(id: 'a', role: TankRole.diluent, volume: 3, pressure: 232)],
+    );
+
+    expect(plan.keptCount, 1);
+    expect(plan.ops, isEmpty);
+  });
+
+  test('an empty config is a no-op', () {
+    final plan = applier.plan(
+      existing: [tank(id: 't1', role: TankRole.diluent)],
+      items: const [],
+    );
+    expect(plan.ops, isEmpty);
+    expect(plan.insertedCount, 0);
+    expect(plan.keptCount, 0);
+  });
+}
+```
+
+- [ ] **Step 2: Run tests to verify they fail**
+
+Run: `flutter test test/features/cylinder_configs/domain/services/cylinder_config_applier_test.dart`
+Expected: FAIL — the file does not exist.
+
+- [ ] **Step 3: Write the applier**
+
+Create `lib/features/cylinder_configs/domain/services/cylinder_config_applier.dart`:
+
+```dart
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+
+/// The applier's read-only view of an existing dive_tanks row.
+class ExistingTank {
+  final String id;
+  final TankRole tankRole;
+  final double? volumeL;
+  final double? workingPressureBar;
+  final TankMaterial? tankMaterial;
+  final double? startPressureBar;
+  final String? tankName;
+  final int tankOrder;
+
+  const ExistingTank({
+    required this.id,
+    required this.tankRole,
+    this.volumeL,
+    this.workingPressureBar,
+    this.tankMaterial,
+    this.startPressureBar,
+    this.tankName,
+    this.tankOrder = 0,
+  });
+}
+
+sealed class CylinderConfigOp {
+  const CylinderConfigOp();
+}
+
+/// Create a new dive_tanks row from [item] at [tankOrder].
+class InsertTank extends CylinderConfigOp {
+  final CylinderConfigItem item;
+  final int tankOrder;
+
+  const InsertTank({required this.item, required this.tankOrder});
+}
+
+/// Fill columns that are NULL on an existing dive_tanks row. Every field here
+/// is nullable and null means "leave this column alone".
+///
+/// There are deliberately no o2Percent or hePercent fields. dive_tanks
+/// defaults them to 21.0 and 0.0, so a tank reading air is indistinguishable
+/// from a tank nobody filled in -- there is no null to test against, and
+/// therefore no honest way to detect "unset". Omitting the fields makes
+/// overwriting a gas mix unexpressible rather than merely discouraged.
+class FillTank extends CylinderConfigOp {
+  final String tankId;
+  final double? volumeL;
+  final double? workingPressureBar;
+  final TankMaterial? tankMaterial;
+  final double? startPressureBar;
+  final String? tankName;
+
+  const FillTank({
+    required this.tankId,
+    this.volumeL,
+    this.workingPressureBar,
+    this.tankMaterial,
+    this.startPressureBar,
+    this.tankName,
+  });
+
+  bool get isEmpty =>
+      volumeL == null &&
+      workingPressureBar == null &&
+      tankMaterial == null &&
+      startPressureBar == null &&
+      tankName == null;
+}
+
+class CylinderConfigPlan {
+  final List<CylinderConfigOp> ops;
+  final int insertedCount;
+  final int keptCount;
+
+  const CylinderConfigPlan({
+    required this.ops,
+    required this.insertedCount,
+    required this.keptCount,
+  });
+}
+
+/// Merges a cylinder configuration into a dive's existing cylinders.
+///
+/// Pure: no database, no DateTime.now(). Callers persist the returned ops.
+/// Mirrors ServiceDueEngine so the merge rules can be tested exhaustively
+/// without a database fixture.
+class CylinderConfigApplier {
+  const CylinderConfigApplier();
+
+  CylinderConfigPlan plan({
+    required List<ExistingTank> existing,
+    required List<CylinderConfigItem> items,
+  }) {
+    final ordered = [...items]
+      ..sort((a, b) => a.sortOrder.compareTo(b.sortOrder));
+
+    final claimed = <String>{};
+    final ops = <CylinderConfigOp>[];
+    var inserted = 0;
+    var kept = 0;
+
+    var nextOrder = existing.isEmpty
+        ? 0
+        : existing.map((t) => t.tankOrder).reduce((a, b) => a > b ? a : b) + 1;
+
+    for (final item in ordered) {
+      // First unclaimed existing tank with the same role. Roles are not
+      // unique -- a CCR diver routinely carries two bailout cylinders -- so
+      // claiming greedily in order is what makes "config has 2 bailouts,
+      // dive already has 1" resolve to keep-one-add-one.
+      ExistingTank? match;
+      for (final tank in existing) {
+        if (tank.tankRole == item.tankRole && !claimed.contains(tank.id)) {
+          match = tank;
+          break;
+        }
+      }
+
+      if (match == null) {
+        ops.add(InsertTank(item: item, tankOrder: nextOrder));
+        nextOrder++;
+        inserted++;
+        continue;
+      }
+
+      claimed.add(match.id);
+      kept++;
+
+      final fill = FillTank(
+        tankId: match.id,
+        volumeL: match.volumeL == null ? item.volumeL : null,
+        workingPressureBar: match.workingPressureBar == null
+            ? item.workingPressureBar
+            : null,
+        tankMaterial: match.tankMaterial == null ? item.tankMaterial : null,
+        startPressureBar: match.startPressureBar == null
+            ? item.defaultStartPressureBar
+            : null,
+        tankName: match.tankName == null ? item.label : null,
+      );
+      if (!fill.isEmpty) ops.add(fill);
+    }
+
+    return CylinderConfigPlan(
+      ops: ops,
+      insertedCount: inserted,
+      keptCount: kept,
+    );
+  }
+}
+```
+
+- [ ] **Step 4: Run tests to verify they pass**
+
+Run: `flutter test test/features/cylinder_configs/domain/services/cylinder_config_applier_test.dart`
+Expected: all 9 PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Add cylinder configuration merge algorithm (#804)"
+```
+
+---
+
+### Task 10: Drift tables and schema v139
+
+**Files:**
+- Modify: `lib/core/database/database.dart` (table classes, `@DriftDatabase` tables list, `currentSchemaVersion`, `migrationVersions`, `onUpgrade`, `beforeOpen`)
+- Test: `test/core/database/migration_v139_cylinder_configs_test.dart`
+
+**Interfaces:**
+- Consumes: nothing.
+- Produces: Drift tables `CylinderConfigs` and `CylinderConfigItems`, reachable as `db.cylinderConfigs` and `db.cylinderConfigItems`; `_assertCylinderConfigSchema()`.
+
+- [ ] **Step 1: Re-check the schema version**
+
+Run:
+
+```bash
+git fetch origin main
+git log origin/main --oneline -1
+grep -n "currentSchemaVersion = " lib/core/database/database.dart
+```
+
+If `origin/main` has advanced past 138, merge it and claim the next free number instead of 139, substituting it everywhere below. Also relax any pre-existing migration test asserting an exact latest version to `greaterThanOrEqualTo`.
+
+- [ ] **Step 2: Write the failing test**
+
+Create `test/core/database/migration_v139_cylinder_configs_test.dart`:
+
+```dart
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/database/database.dart';
+
+void main() {
+  test('v139 is in the migration ladder', () {
+    expect(
+      AppDatabase.currentSchemaVersion,
+      greaterThanOrEqualTo(139),
+    );
+    expect(AppDatabase.migrationVersions, contains(139));
+  });
+
+  test('a fresh database has both cylinder config tables', () async {
+    final db = AppDatabase(NativeDatabase.memory());
+    addTearDown(db.close);
+
+    final configCols = await db
+        .customSelect("PRAGMA table_info('cylinder_configs')")
+        .get();
+    expect(
+      configCols.map((c) => c.read<String>('name')).toSet(),
+      containsAll([
+        'id',
+        'diver_id',
+        'equipment_id',
+        'name',
+        'description',
+        'sort_order',
+        'created_at',
+        'updated_at',
+        'hlc',
+      ]),
+    );
+
+    final itemCols = await db
+        .customSelect("PRAGMA table_info('cylinder_config_items')")
+        .get();
+    expect(
+      itemCols.map((c) => c.read<String>('name')).toSet(),
+      containsAll([
+        'id',
+        'config_id',
+        'sort_order',
+        'label',
+        'tank_role',
+        'volume_l',
+        'working_pressure_bar',
+        'tank_material',
+        'o2_percent',
+        'he_percent',
+        'default_start_pressure_bar',
+        'created_at',
+        'updated_at',
+        'hlc',
+      ]),
+    );
+  });
+
+  test('deleting the owning equipment demotes the config, not deletes it',
+      () async {
+    final db = AppDatabase(NativeDatabase.memory());
+    addTearDown(db.close);
+    await db.customStatement('PRAGMA foreign_keys = ON');
+
+    final now = DateTime.now().millisecondsSinceEpoch;
+    await db.customStatement(
+      "INSERT INTO equipment (id, name, type, created_at, updated_at) "
+      "VALUES ('rb-1', 'JJ', 'rebreather', $now, $now)",
+    );
+    await db.customStatement(
+      "INSERT INTO cylinder_configs "
+      "(id, equipment_id, name, description, sort_order, "
+      " created_at, updated_at) "
+      "VALUES ('c1', 'rb-1', 'Trimix', '', 0, $now, $now)",
+    );
+
+    await db.customStatement("DELETE FROM equipment WHERE id = 'rb-1'");
+
+    final rows = await db
+        .customSelect(
+          "SELECT id, equipment_id FROM cylinder_configs WHERE id = 'c1'",
+        )
+        .get();
+    expect(rows, hasLength(1), reason: 'config must survive unit deletion');
+    expect(rows.single.read<String?>('equipment_id'), isNull);
+  });
+
+  test('deleting a config cascades to its items', () async {
+    final db = AppDatabase(NativeDatabase.memory());
+    addTearDown(db.close);
+    await db.customStatement('PRAGMA foreign_keys = ON');
+
+    final now = DateTime.now().millisecondsSinceEpoch;
+    await db.customStatement(
+      "INSERT INTO cylinder_configs "
+      "(id, name, description, sort_order, created_at, updated_at) "
+      "VALUES ('c1', 'Doubles', '', 0, $now, $now)",
+    );
+    await db.customStatement(
+      "INSERT INTO cylinder_config_items "
+      "(id, config_id, sort_order, tank_role, o2_percent, he_percent, "
+      " created_at, updated_at) "
+      "VALUES ('i1', 'c1', 0, 'backGas', 21, 0, $now, $now)",
+    );
+
+    await db.customStatement("DELETE FROM cylinder_configs WHERE id = 'c1'");
+
+    final items = await db
+        .customSelect('SELECT id FROM cylinder_config_items')
+        .get();
+    expect(items, isEmpty);
+  });
+
+  test('a database stranded below v139 self-heals via the schema assert',
+      () async {
+    final db = AppDatabase(NativeDatabase.memory());
+    addTearDown(db.close);
+
+    await db.customStatement('DROP TABLE IF EXISTS cylinder_config_items');
+    await db.customStatement('DROP TABLE IF EXISTS cylinder_configs');
+
+    await db.assertCylinderConfigSchemaForTest();
+
+    final tables = await db
+        .customSelect(
+          "SELECT name FROM sqlite_master WHERE type='table' "
+          "AND name LIKE 'cylinder_config%'",
+        )
+        .get();
+    expect(tables.map((t) => t.read<String>('name')).toSet(), {
+      'cylinder_configs',
+      'cylinder_config_items',
+    });
+  });
+}
+```
+
+Both foreign-key tests explicitly enable `PRAGMA foreign_keys = ON`. Drift's in-memory default leaves them off, which would let both tests pass vacuously — the exact trap that has masked insert-order bugs on this codebase before.
+
+- [ ] **Step 3: Run test to verify it fails**
+
+Run: `flutter test test/core/database/migration_v139_cylinder_configs_test.dart`
+Expected: FAIL — `currentSchemaVersion` is 137, and the tables do not exist.
+
+- [ ] **Step 4: Add the Drift table classes**
+
+In `lib/core/database/database.dart`, add after the `TankPresets` class:
+
+```dart
+/// A named, reusable set of cylinders. equipment_id set means "a config for
+/// this rebreather"; null means a generic gas plan. ON DELETE SET NULL
+/// demotes a config when its unit is deleted rather than destroying a
+/// painstakingly entered bailout plan.
+class CylinderConfigs extends Table {
+  TextColumn get id => text()();
+  TextColumn get diverId => text().nullable().references(Divers, #id)();
+  TextColumn get equipmentId => text().nullable().references(
+    Equipment,
+    #id,
+    onDelete: KeyAction.setNull,
+  )();
+  TextColumn get name => text()();
+  TextColumn get description => text().withDefault(const Constant(''))();
+  IntColumn get sortOrder => integer().withDefault(const Constant(0))();
+  IntColumn get createdAt => integer()();
+  IntColumn get updatedAt => integer()();
+
+  /// Hybrid Logical Clock for cross-device conflict resolution
+  /// (nullable: rows written before HLC rollout fall back to updatedAt).
+  TextColumn get hlc => text().nullable()();
+
+  @override
+  Set<Column> get primaryKey => {id};
+}
+
+/// One cylinder in a configuration. The spec columns are a SNAPSHOT: a tank
+/// preset may populate them at edit time, but there is deliberately no FK to
+/// tank_presets. A config records what the diver actually dives, so a later
+/// edit to a preset must not rewrite the meaning of a saved config.
+class CylinderConfigItems extends Table {
+  TextColumn get id => text()();
+  TextColumn get configId => text().references(
+    CylinderConfigs,
+    #id,
+    onDelete: KeyAction.cascade,
+  )();
+  IntColumn get sortOrder => integer().withDefault(const Constant(0))();
+  TextColumn get label => text().nullable()();
+  TextColumn get tankRole => text()(); // TankRole.name
+  RealColumn get volumeL => real().nullable()();
+  RealColumn get workingPressureBar => real().nullable()();
+  TextColumn get tankMaterial => text().nullable()(); // TankMaterial.name
+  RealColumn get o2Percent => real().withDefault(const Constant(21.0))();
+  RealColumn get hePercent => real().withDefault(const Constant(0.0))();
+  RealColumn get defaultStartPressureBar => real().nullable()();
+  IntColumn get createdAt => integer()();
+  IntColumn get updatedAt => integer()();
+
+  /// Hybrid Logical Clock for cross-device conflict resolution
+  /// (nullable: rows written before HLC rollout fall back to updatedAt).
+  TextColumn get hlc => text().nullable()();
+
+  @override
+  Set<Column> get primaryKey => {id};
+}
+```
+
+Register both in the `@DriftDatabase(tables: [...])` annotation, next to `TankPresets`.
+
+- [ ] **Step 5: Add the schema assert and wire the migration**
+
+Add alongside the other `_assert*Schema` methods:
+
+```dart
+  /// v139: cylinder configuration tables. CREATE TABLE IF NOT EXISTS, so this
+  /// is safe to call from both onUpgrade and the beforeOpen backstop
+  /// (parallel-branch version-collision self-heal).
+  Future<void> _assertCylinderConfigSchema() async {
+    await customStatement('''
+      CREATE TABLE IF NOT EXISTS cylinder_configs (
+        id TEXT NOT NULL PRIMARY KEY,
+        diver_id TEXT REFERENCES divers (id),
+        equipment_id TEXT REFERENCES equipment (id) ON DELETE SET NULL,
+        name TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        sort_order INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        hlc TEXT
+      )
+    ''');
+    await customStatement('''
+      CREATE TABLE IF NOT EXISTS cylinder_config_items (
+        id TEXT NOT NULL PRIMARY KEY,
+        config_id TEXT NOT NULL
+          REFERENCES cylinder_configs (id) ON DELETE CASCADE,
+        sort_order INTEGER NOT NULL DEFAULT 0,
+        label TEXT,
+        tank_role TEXT NOT NULL,
+        volume_l REAL,
+        working_pressure_bar REAL,
+        tank_material TEXT,
+        o2_percent REAL NOT NULL DEFAULT 21.0,
+        he_percent REAL NOT NULL DEFAULT 0.0,
+        default_start_pressure_bar REAL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        hlc TEXT
+      )
+    ''');
+    await customStatement(
+      'CREATE INDEX IF NOT EXISTS idx_cylinder_configs_equipment '
+      'ON cylinder_configs (equipment_id)',
+    );
+    await customStatement(
+      'CREATE INDEX IF NOT EXISTS idx_cylinder_config_items_config '
+      'ON cylinder_config_items (config_id)',
+    );
+  }
+
+  /// Test hook for the stranded-database self-heal path.
+  Future<void> assertCylinderConfigSchemaForTest() =>
+      _assertCylinderConfigSchema();
+```
+
+Then:
+1. Set `static const int currentSchemaVersion = 139;`
+2. Append `139` to `migrationVersions`.
+3. In `onUpgrade`, after the highest existing block:
+
+```dart
+        if (from < 139) {
+          await _assertCylinderConfigSchema();
+          await reportProgress();
+        }
+```
+
+4. In the `beforeOpen` backstop, alongside the other asserts:
+
+```dart
+        await _assertCylinderConfigSchema();
+```
+
+- [ ] **Step 6: Regenerate Drift code**
+
+Run: `dart run build_runner build --delete-conflicting-outputs`
+Expected: `database.g.dart` gains `CylinderConfig`/`CylinderConfigItem` data classes and `db.cylinderConfigs` / `db.cylinderConfigItems` accessors.
+
+The generated Drift row classes will be named `CylinderConfig` and `CylinderConfigItem` — colliding with the domain entities from Task 8. Every file importing both must alias one, exactly as the codebase already does elsewhere: `import '.../cylinder_config.dart' as domain;`.
+
+- [ ] **Step 7: Run test to verify it passes**
+
+Run: `flutter test test/core/database/migration_v139_cylinder_configs_test.dart`
+Expected: all 5 PASS.
+
+- [ ] **Step 8: Run the database suite**
+
+Run: `flutter test test/core/database/`
+Expected: all pass. If a pre-existing test asserts an exact latest schema version, relax it to `greaterThanOrEqualTo(N)` plus `contains(N)`.
+
+- [ ] **Step 9: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Add cylinder configuration tables at schema v139 (#804)"
+```
+
+---
+
+### Task 11: Repository
+
+**Files:**
+- Create: `lib/features/cylinder_configs/data/repositories/cylinder_config_repository.dart`
+- Test: `test/features/cylinder_configs/data/cylinder_config_repository_test.dart`
+
+**Interfaces:**
+- Consumes: Drift tables (Task 10), domain entities (Task 8).
+- Produces `CylinderConfigRepository` with:
+  - `Future<List<domain.CylinderConfig>> getAllConfigs({String? diverId, bool includeItems = false})`
+  - `Future<List<domain.CylinderConfig>> getConfigsForEquipment(String equipmentId)`
+  - `Future<domain.CylinderConfig?> getConfigById(String id, {bool includeItems = true})`
+  - `Future<String> createConfig({String? diverId, String? equipmentId, required String name, String description = ''})`
+  - `Future<void> updateConfig(domain.CylinderConfig config)`
+  - `Future<void> deleteConfig(String id)`
+  - `Future<void> saveItems(String configId, List<domain.CylinderConfigItem> items)`
+
+- [ ] **Step 1: Read the pattern to follow**
+
+Run: `cat lib/features/equipment/data/repositories/equipment_set_repository_impl.dart`
+
+Copy its structure exactly: `AppDatabase get _db => DatabaseService.instance.database;`, a `SyncRepository` field, a `const Uuid()` field, `SyncEventBus.notifyLocalChange()` after every write, and deletion-log registration on delete.
+
+- [ ] **Step 2: Write the failing tests**
+
+Create `test/features/cylinder_configs/data/cylinder_config_repository_test.dart`. Follow the fixture pattern in `test/features/equipment/data/repositories/` for standing up an in-memory `AppDatabase` through `DatabaseService` — read one of those files first and copy its `setUp`/`tearDown` verbatim rather than inventing a new fixture.
+
+```dart
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/core/database/database.dart';
+import 'package:submersion/core/services/database_service.dart';
+import 'package:submersion/features/cylinder_configs/data/repositories/cylinder_config_repository.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart'
+    as domain;
+
+void main() {
+  late AppDatabase db;
+  late CylinderConfigRepository repository;
+  final now = DateTime.utc(2026, 8, 5);
+
+  setUp(() async {
+    db = AppDatabase(NativeDatabase.memory());
+    await db.customStatement('PRAGMA foreign_keys = ON');
+    DatabaseService.instance.setDatabaseForTest(db);
+    repository = CylinderConfigRepository();
+  });
+
+  tearDown(() async {
+    await db.close();
+  });
+
+  domain.CylinderConfigItem item({
+    required String id,
+    required String configId,
+    TankRole role = TankRole.bailout,
+    int order = 0,
+    double o2 = 21,
+  }) => domain.CylinderConfigItem(
+    id: id,
+    configId: configId,
+    sortOrder: order,
+    tankRole: role,
+    o2Percent: o2,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  test('creates a config and reads it back', () async {
+    final id = await repository.createConfig(
+      diverId: 'd1',
+      name: 'JJ trimix',
+      description: 'Bottom 18/45',
+    );
+
+    final loaded = await repository.getConfigById(id);
+    expect(loaded, isNotNull);
+    expect(loaded!.name, 'JJ trimix');
+    expect(loaded.description, 'Bottom 18/45');
+    expect(loaded.equipmentId, isNull);
+    expect(loaded.isOwnedByUnit, isFalse);
+  });
+
+  test('getConfigsForEquipment returns only that unit\'s configs', () async {
+    final ts = now.millisecondsSinceEpoch;
+    await db.customStatement(
+      "INSERT INTO equipment (id, name, type, created_at, updated_at) "
+      "VALUES ('rb-1', 'JJ', 'rebreather', $ts, $ts)",
+    );
+    await db.customStatement(
+      "INSERT INTO equipment (id, name, type, created_at, updated_at) "
+      "VALUES ('rb-2', 'rEvo', 'rebreather', $ts, $ts)",
+    );
+
+    await repository.createConfig(equipmentId: 'rb-1', name: 'A');
+    await repository.createConfig(equipmentId: 'rb-1', name: 'B');
+    await repository.createConfig(equipmentId: 'rb-2', name: 'C');
+    await repository.createConfig(name: 'Generic');
+
+    final forUnit = await repository.getConfigsForEquipment('rb-1');
+    expect(forUnit.map((c) => c.name).toSet(), {'A', 'B'});
+  });
+
+  test('getAllConfigs with includeItems hydrates items in sort order',
+      () async {
+    final id = await repository.createConfig(name: 'Doubles + 50');
+    await repository.saveItems(id, [
+      item(id: 'i2', configId: id, role: TankRole.deco, order: 1, o2: 50),
+      item(id: 'i1', configId: id, role: TankRole.backGas, order: 0),
+    ]);
+
+    final configs = await repository.getAllConfigs(includeItems: true);
+    final config = configs.single;
+    expect(config.items.map((i) => i.tankRole), [
+      TankRole.backGas,
+      TankRole.deco,
+    ]);
+    expect(config.items.last.o2Percent, 50);
+  });
+
+  test('saveItems replaces the item set and renumbers sort_order', () async {
+    final id = await repository.createConfig(name: 'Config');
+    await repository.saveItems(id, [
+      item(id: 'i1', configId: id, order: 0),
+      item(id: 'i2', configId: id, order: 1),
+      item(id: 'i3', configId: id, order: 2),
+    ]);
+
+    // Drop the middle item; the survivors renumber from list position.
+    await repository.saveItems(id, [
+      item(id: 'i3', configId: id, order: 99),
+      item(id: 'i1', configId: id, order: 99),
+    ]);
+
+    final config = await repository.getConfigById(id);
+    expect(config!.items.map((i) => i.id), ['i3', 'i1']);
+    expect(config.items.map((i) => i.sortOrder), [0, 1]);
+  });
+
+  test('saveItems writes deletion-log tombstones for removed items',
+      () async {
+    final id = await repository.createConfig(name: 'Config');
+    await repository.saveItems(id, [
+      item(id: 'i1', configId: id, order: 0),
+      item(id: 'i2', configId: id, order: 1),
+    ]);
+
+    await repository.saveItems(id, [item(id: 'i1', configId: id, order: 0)]);
+
+    final tombstones = await db
+        .customSelect(
+          "SELECT record_id FROM deletion_log "
+          "WHERE entity_type = 'cylinderConfigItems'",
+        )
+        .get();
+    expect(
+      tombstones.map((r) => r.read<String>('record_id')),
+      contains('i2'),
+      reason: 'without a tombstone the row resurrects on the next sync pull',
+    );
+  });
+
+  test('deleteConfig removes its items', () async {
+    final id = await repository.createConfig(name: 'Config');
+    await repository.saveItems(id, [item(id: 'i1', configId: id)]);
+
+    await repository.deleteConfig(id);
+
+    expect(await repository.getConfigById(id), isNull);
+    final rows = await db
+        .customSelect('SELECT id FROM cylinder_config_items')
+        .get();
+    expect(rows, isEmpty);
+  });
+
+  test('a config for a deleted unit survives as a generic gas plan',
+      () async {
+    final ts = now.millisecondsSinceEpoch;
+    await db.customStatement(
+      "INSERT INTO equipment (id, name, type, created_at, updated_at) "
+      "VALUES ('rb-1', 'JJ', 'rebreather', $ts, $ts)",
+    );
+    final id = await repository.createConfig(
+      equipmentId: 'rb-1',
+      name: 'Trimix',
+    );
+
+    await db.customStatement("DELETE FROM equipment WHERE id = 'rb-1'");
+
+    final loaded = await repository.getConfigById(id);
+    expect(loaded, isNotNull);
+    expect(loaded!.equipmentId, isNull);
+    expect(loaded.isOwnedByUnit, isFalse);
+  });
+}
+```
+
+Two details that are easy to get wrong. First, `PRAGMA foreign_keys = ON` is mandatory — Drift's in-memory default leaves them off, which would make the last test pass vacuously whether or not `ON DELETE SET NULL` is wired. Second, if `DatabaseService` exposes a differently-named test hook than `setDatabaseForTest`, use whatever the existing equipment repository tests use; do not add a new hook.
+
+The tombstone test matters most. Child rows deleted without a deletion-log entry resurrect on the next sync pull — this codebase has hit that exact data-loss bug before.
+
+- [ ] **Step 3: Run tests to verify they fail**
+
+Run: `flutter test test/features/cylinder_configs/data/cylinder_config_repository_test.dart`
+Expected: FAIL — the repository does not exist.
+
+- [ ] **Step 4: Write the repository**
+
+Create `lib/features/cylinder_configs/data/repositories/cylinder_config_repository.dart`, modeled on `EquipmentSetRepository`. Requirements:
+
+- `saveItems` runs in a single `_db.transaction`, deletes rows absent from the incoming list, registers a deletion-log tombstone for each via `_syncRepository`, then upserts the rest with `sortOrder` renumbered `0..n-1` from list position.
+- Every public write ends with `SyncEventBus.notifyLocalChange()`.
+- `getAllConfigs` orders by `sortOrder` then `name`; items order by `sortOrder`.
+- Map `tankRole` and `tankMaterial` via `.name` on write and a `values.firstWhere(... orElse: ...)` lookup on read, so an unknown persisted string degrades to a sensible default rather than throwing.
+
+- [ ] **Step 5: Run tests to verify they pass**
+
+Run: `flutter test test/features/cylinder_configs/data/cylinder_config_repository_test.dart`
+Expected: all PASS.
+
+- [ ] **Step 6: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Add cylinder configuration repository (#804)"
+```
+
+---
+
+### Task 12: Sync registration
+
+**Files:**
+- Modify: `lib/core/services/sync/sync_data_serializer.dart` (14 sites)
+- Modify: `lib/core/services/sync/sync_service.dart` (4 sites)
+- Test: `test/core/services/sync/cylinder_config_sync_test.dart`
+
+**Interfaces:**
+- Consumes: Drift tables (Task 10).
+- Produces: sync entity keys `'cylinderConfigs'` (top-level) and `'cylinderConfigItems'` (HLC child of `cylinderConfigs`).
+
+- [ ] **Step 1: Enumerate the sites to mirror**
+
+Run:
+
+```bash
+grep -n "equipmentAttributes" lib/core/services/sync/sync_data_serializer.dart
+grep -n "equipmentAttributes" lib/core/services/sync/sync_service.dart
+```
+
+`equipmentAttributes` is the closest precedent: a synced HLC child of a parent entity. As of this writing the serializer sites are at lines 227, 299, 372, 446, 665-666, 1164-1165, 1551-1553, 1923-1925, 2220-2222, 2739-2742, 3451-3452, 3672-3673, 3835-3837, 4318; the service sites are 1149-1150, 1819, 2021. **Re-run the greps** — these shift with every merge.
+
+Add an arm for each of the two new entities at every one of those sites.
+
+- [ ] **Step 2: Write the failing test**
+
+Create `test/core/services/sync/cylinder_config_sync_test.dart` following the existing sync round-trip tests. Cover:
+
+```dart
+  test('a config and its items export and re-import intact', ...);
+  test('a newer HLC on an incoming item wins over the local row', ...);
+  test('a deleted item stays deleted after a pull (tombstone honored)', ...);
+  test('cylinderConfigs merges before cylinderConfigItems', ...);
+```
+
+The merge-order test is the one that catches a real failure: importing a child before its parent violates the foreign key and silently drops the row on a fixture with foreign keys off.
+
+- [ ] **Step 3: Run tests to verify they fail**
+
+Run: `flutter test test/core/services/sync/cylinder_config_sync_test.dart`
+Expected: FAIL — the entity keys are unknown to the serializer.
+
+- [ ] **Step 4: Register both entities**
+
+Mirror `equipmentAttributes` at every site. Specifics that differ:
+
+- **`mergeOrder`**: `cylinderConfigs` after `equipment` (its `equipment_id` FK parent); `cylinderConfigItems` immediately after `cylinderConfigs`.
+- **`parentRefs`**: `cylinderConfigItems` declares `cylinderConfigs` as its parent, keyed on `config_id`.
+- **`entityHasUpdatedAt`**: `true` for both.
+- **`_hlcTables` / `_hlcTargets`**: register both tables.
+- **`_baseTables`** (streaming base export): register both, or a full base restore silently omits every configuration.
+
+- [ ] **Step 5: Run tests to verify they pass**
+
+Run: `flutter test test/core/services/sync/cylinder_config_sync_test.dart`
+Expected: all PASS.
+
+- [ ] **Step 6: Run the full sync suite**
+
+Run: `flutter test test/core/services/sync/`
+Expected: all pass. Sync tests are the most interconnected in the codebase; a missed registration site usually surfaces here rather than in the new file.
+
+- [ ] **Step 7: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Register cylinder configurations as synced entities (#804)"
+```
+
+---
+
+### Task 13: Providers
+
+**Files:**
+- Create: `lib/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart`
+- Test: `test/features/cylinder_configs/presentation/cylinder_config_providers_test.dart`
+
+**Interfaces:**
+- Consumes: `CylinderConfigRepository` (Task 11).
+- Produces:
+  - `cylinderConfigRepositoryProvider` — `Provider<CylinderConfigRepository>`
+  - `cylinderConfigsProvider` — `FutureProvider<List<domain.CylinderConfig>>`, active diver scoped, items included
+  - `cylinderConfigsForEquipmentProvider` — `FutureProvider.family<List<domain.CylinderConfig>, String>`
+  - `cylinderConfigProvider` — `FutureProvider.family<domain.CylinderConfig?, String>`
+
+- [ ] **Step 1: Read the pattern**
+
+Run: `cat lib/features/equipment/presentation/providers/equipment_set_providers.dart`
+
+Import Riverpod through the project barrel `package:submersion/core/providers/provider.dart`, not `flutter_riverpod` directly — the codebase standardizes on the barrel for Riverpod 3 compatibility.
+
+- [ ] **Step 2: Write the failing test**
+
+Create `test/features/cylinder_configs/presentation/cylinder_config_providers_test.dart`:
+
+```dart
+  test('cylinderConfigsProvider returns the active diver\'s configs', ...);
+  test('cylinderConfigsForEquipmentProvider filters by unit', ...);
+  test('invalidating the list provider refetches', ...);
+```
+
+- [ ] **Step 3: Run test to verify it fails**
+
+Run: `flutter test test/features/cylinder_configs/presentation/cylinder_config_providers_test.dart`
+Expected: FAIL — the providers do not exist.
+
+- [ ] **Step 4: Write the providers**
+
+Follow `equipment_set_providers.dart` exactly for diver scoping and invalidation.
+
+- [ ] **Step 5: Run test to verify it passes**
+
+Run: `flutter test test/features/cylinder_configs/presentation/cylinder_config_providers_test.dart`
+Expected: PASS
+
+- [ ] **Step 6: Check for broken consumer tests**
+
+Run: `flutter test`
+Expected: all pass. Adding a provider dependency to an existing widget breaks consumer tests that do not override it, and `flutter analyze` will **not** catch this. The full suite is the only reliable check.
+
+- [ ] **Step 7: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Add cylinder configuration providers (#804)"
+```
+
+---
+
+### Task 14: Configuration list and edit pages
+
+**Files:**
+- Create: `lib/features/cylinder_configs/presentation/pages/cylinder_config_list_page.dart`
+- Create: `lib/features/cylinder_configs/presentation/pages/cylinder_config_edit_page.dart`
+- Create: `lib/features/cylinder_configs/presentation/widgets/cylinder_config_item_editor.dart`
+- Modify: `lib/core/router/app_router.dart` (near the `equipmentSets` route, line ~482)
+- Modify: all 11 `lib/l10n/arb/app_*.arb`
+- Test: `test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart`
+
+**Interfaces:**
+- Consumes: providers (Task 13), entities (Task 8), `TankRole`, `TankMaterial`, `TankPreset`.
+- Produces: routes `cylinderConfigs` (`/gear/cylinder-configs`) and `cylinderConfigEdit` (`/gear/cylinder-configs/:id`).
+
+- [ ] **Step 1: Read the sibling pages**
+
+Run:
+
+```bash
+cat lib/features/equipment/presentation/pages/equipment_set_list_page.dart
+cat lib/features/equipment/presentation/pages/equipment_set_edit_page.dart
+sed -n 470,500p lib/core/router/app_router.dart
+```
+
+Match their scaffold, app bar, empty state, and route registration style.
+
+- [ ] **Step 2: Add the ARB keys**
+
+To `app_en.arb`, then all 10 others, then `flutter gen-l10n`:
+
+```json
+  "cylinderConfigsTitle": "Cylinder configurations",
+  "cylinderConfigsEmpty": "No configurations yet",
+  "cylinderConfigsEmptyBody": "Save a diluent and bailout setup once, then apply it to any dive.",
+  "cylinderConfigNew": "New configuration",
+  "cylinderConfigName": "Name",
+  "cylinderConfigForUnit": "For unit",
+  "cylinderConfigNoUnit": "Generic gas plan",
+  "cylinderConfigAddCylinder": "Add cylinder",
+  "cylinderConfigCylinderRole": "Role",
+  "cylinderConfigStartPressure": "Start pressure",
+  "cylinderConfigLabel": "Label",
+  "cylinderConfigDeleteTitle": "Delete configuration?",
+  "cylinderConfigDeleteBody": "This does not change any dive it was already applied to."
+```
+
+- [ ] **Step 3: Write the failing widget test**
+
+Create `test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart`:
+
+```dart
+  testWidgets('adding a cylinder appends a row with a role selector', ...);
+  testWidgets('reordering cylinders renumbers sort order', ...);
+  testWidgets('choosing a tank preset fills volume and pressure', ...);
+  testWidgets('saving with an empty name shows a validation error', ...);
+```
+
+Pin `locale: const Locale('en')` on the host `MaterialApp`.
+
+- [ ] **Step 4: Run tests to verify they fail**
+
+Run: `flutter test test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart`
+Expected: FAIL — the pages do not exist.
+
+- [ ] **Step 5: Build the pages**
+
+Requirements:
+
+- **List page**: configs grouped by owning unit, generic ones under a "Gas plans" heading. Empty state uses `cylinderConfigsEmpty*`. FAB creates a new config.
+- **Edit page**: name field (required), optional owning-unit dropdown populated from equipment of type `rebreather`, and a `ReorderableListView` of cylinder rows.
+- **Item editor row**: role dropdown from `TankRole.values`; O2 and He percent fields; a "From preset" button that fills `volumeL` / `workingPressureBar` / `tankMaterial` from a chosen `TankPreset` and then leaves them freely editable; optional start pressure; optional label.
+- Volumes and pressures render and parse through `UnitFormatter` against the diver's unit settings.
+- Dispose every `TextEditingController` the page creates.
+
+- [ ] **Step 6: Register the routes**
+
+In `app_router.dart`, add sibling routes next to `equipmentSets`. Register them as **siblings**, not nested children — nesting a route under a shared widget in this codebase produces a doubled page.
+
+- [ ] **Step 7: Run tests to verify they pass**
+
+Run: `flutter test test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart`
+Expected: all PASS.
+
+- [ ] **Step 8: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Add cylinder configuration list and edit pages (#804)"
+```
+
+---
+
+### Task 15: Apply a configuration to a dive
+
+**Files:**
+- Create: `lib/features/cylinder_configs/presentation/widgets/apply_configuration_menu.dart`
+- Create: `lib/features/cylinder_configs/data/services/cylinder_config_apply_service.dart`
+- Modify: `lib/features/dive_log/presentation/widgets/cylinders_card.dart`
+- Modify: all 11 `lib/l10n/arb/app_*.arb`
+- Test: `test/features/cylinder_configs/data/cylinder_config_apply_service_test.dart`
+- Test: `test/features/cylinder_configs/presentation/apply_configuration_menu_test.dart`
+
+**Interfaces:**
+- Consumes: `CylinderConfigApplier` (Task 9), `CylinderConfigRepository` (Task 11), providers (Task 13).
+- Produces: `CylinderConfigApplyService.applyToDive({required String diveId, required String configId}) -> Future<CylinderConfigPlan>` — persists the plan and returns it so the caller can report counts.
+
+- [ ] **Step 1: Add the ARB keys**
+
+To all 11 ARB files, then `flutter gen-l10n`:
+
+```json
+  "applyConfiguration": "Apply configuration",
+  "applyConfigurationGasPlans": "Gas plans",
+  "applyConfigurationResult": "Added {added} cylinders, kept {kept}",
+  "applyConfigurationNothingToDo": "This dive already matches the configuration"
+```
+
+`applyConfigurationResult` takes placeholders, so it needs an `@applyConfigurationResult` block in `app_en.arb` declaring both as `num` with `plural` handling. Follow an existing pluralized key in that file for the exact shape.
+
+- [ ] **Step 2: Write the failing service test**
+
+Create `test/features/cylinder_configs/data/cylinder_config_apply_service_test.dart`. Reuse the same in-memory fixture as Task 11.
+
+```dart
+  // Helper: seed a dive plus a config, returning (diveId, configId).
+  Future<String> seedConfig() async {
+    final id = await configRepository.createConfig(name: 'JJ trimix');
+    await configRepository.saveItems(id, [
+      item(id: 'i1', configId: id, role: TankRole.diluent, order: 0, o2: 18,
+          he: 45, volume: 3, pressure: 232),
+      item(id: 'i2', configId: id, role: TankRole.oxygenSupply, order: 1,
+          o2: 100, volume: 3, pressure: 232),
+      item(id: 'i3', configId: id, role: TankRole.bailout, order: 2, o2: 21,
+          volume: 11.1, pressure: 207),
+    ]);
+    return id;
+  }
+
+  test('applying to a dive with no cylinders inserts all of them', () async {
+    final diveId = await seedDive();
+    final configId = await seedConfig();
+
+    final plan = await service.applyToDive(
+      diveId: diveId,
+      configId: configId,
+    );
+
+    expect(plan.insertedCount, 3);
+    expect(plan.keptCount, 0);
+
+    final tanks = await db
+        .customSelect(
+          "SELECT tank_role, o2_percent, he_percent, tank_order "
+          "FROM dive_tanks WHERE dive_id = '$diveId' ORDER BY tank_order",
+        )
+        .get();
+    expect(tanks.map((t) => t.read<String>('tank_role')), [
+      'diluent',
+      'oxygenSupply',
+      'bailout',
+    ]);
+    expect(tanks.first.read<double>('o2_percent'), 18);
+    expect(tanks.first.read<double>('he_percent'), 45);
+  });
+
+  test('applying preserves a downloaded diluent gas mix', () async {
+    final diveId = await seedDive();
+    final configId = await seedConfig();
+
+    // A Shearwater download already supplied the diluent as air.
+    await db.customStatement(
+      "INSERT INTO dive_tanks "
+      "(id, dive_id, tank_role, o2_percent, he_percent, tank_order) "
+      "VALUES ('t1', '$diveId', 'diluent', 21, 0, 0)",
+    );
+
+    final plan = await service.applyToDive(
+      diveId: diveId,
+      configId: configId,
+    );
+
+    expect(plan.keptCount, 1);
+    expect(plan.insertedCount, 2);
+
+    final diluent = await db
+        .customSelect(
+          "SELECT o2_percent, he_percent, volume, working_pressure "
+          "FROM dive_tanks WHERE id = 't1'",
+        )
+        .getSingle();
+    expect(diluent.read<double>('o2_percent'), 21,
+        reason: 'downloaded gas must never be overwritten');
+    expect(diluent.read<double>('he_percent'), 0);
+    // Null spec columns ARE filled from the config.
+    expect(diluent.read<double?>('volume'), 3);
+    expect(diluent.read<double?>('working_pressure'), 232);
+  });
+
+  test('applying twice is idempotent (second run adds nothing)', () async {
+    final diveId = await seedDive();
+    final configId = await seedConfig();
+
+    await service.applyToDive(diveId: diveId, configId: configId);
+    final second = await service.applyToDive(
+      diveId: diveId,
+      configId: configId,
+    );
+
+    expect(second.insertedCount, 0);
+    expect(second.keptCount, 3);
+
+    final count = await db
+        .customSelect(
+          "SELECT COUNT(*) AS c FROM dive_tanks WHERE dive_id = '$diveId'",
+        )
+        .getSingle();
+    expect(count.read<int>('c'), 3);
+  });
+
+  test('applying fills only null columns on a claimed tank', () async {
+    final diveId = await seedDive();
+    final configId = await seedConfig();
+
+    await db.customStatement(
+      "INSERT INTO dive_tanks "
+      "(id, dive_id, tank_role, o2_percent, he_percent, volume, "
+      " tank_name, tank_order) "
+      "VALUES ('t1', '$diveId', 'bailout', 21, 0, 5.7, 'My AL40', 0)",
+    );
+
+    await service.applyToDive(diveId: diveId, configId: configId);
+
+    final tank = await db
+        .customSelect(
+          "SELECT volume, working_pressure, tank_name "
+          "FROM dive_tanks WHERE id = 't1'",
+        )
+        .getSingle();
+    expect(tank.read<double?>('volume'), 5.7, reason: 'already set');
+    expect(tank.read<String?>('tank_name'), 'My AL40', reason: 'already set');
+    expect(tank.read<double?>('working_pressure'), 207, reason: 'was null');
+  });
+
+  test('inserted tanks continue the existing tank_order', () async {
+    final diveId = await seedDive();
+    final configId = await seedConfig();
+
+    await db.customStatement(
+      "INSERT INTO dive_tanks "
+      "(id, dive_id, tank_role, o2_percent, he_percent, tank_order) "
+      "VALUES ('t1', '$diveId', 'stage', 50, 0, 4)",
+    );
+
+    await service.applyToDive(diveId: diveId, configId: configId);
+
+    final orders = await db
+        .customSelect(
+          "SELECT tank_order FROM dive_tanks WHERE dive_id = '$diveId' "
+          "ORDER BY tank_order",
+        )
+        .get();
+    expect(orders.map((r) => r.read<int>('tank_order')), [4, 5, 6, 7]);
+  });
+```
+
+Provide `seedDive()` as a helper inserting one minimal `dives` row and returning its id, and `item(...)` as in Task 11 with the extra `he`, `volume`, and `pressure` named parameters wired to `hePercent`, `volumeL`, and `workingPressureBar`.
+
+The idempotency test is the one that catches a real bug: a second apply must find every role already claimed and insert nothing.
+
+- [ ] **Step 3: Run tests to verify they fail**
+
+Run: `flutter test test/features/cylinder_configs/data/cylinder_config_apply_service_test.dart`
+Expected: FAIL — the service does not exist.
+
+- [ ] **Step 4: Write the apply service**
+
+Create `cylinder_config_apply_service.dart`. It:
+
+1. Loads the dive's `dive_tanks` rows and maps them to `ExistingTank`.
+2. Loads the config with items.
+3. Calls `const CylinderConfigApplier().plan(...)`.
+4. In one transaction, executes each op: `InsertTank` inserts a new `dive_tanks` row (new UUID, `diveId`, all item fields, `tankOrder` from the op); `FillTank` writes only the non-null fields of the op.
+5. Calls `SyncEventBus.notifyLocalChange()`.
+6. Returns the plan.
+
+The service must never write `o2Percent` or `hePercent` on a `FillTank` — `FillTank` has no such fields, so this is structurally impossible. Do not add them.
+
+- [ ] **Step 5: Run tests to verify they pass**
+
+Run: `flutter test test/features/cylinder_configs/data/cylinder_config_apply_service_test.dart`
+Expected: all PASS.
+
+- [ ] **Step 6: Write the failing menu test**
+
+Create `test/features/cylinder_configs/presentation/apply_configuration_menu_test.dart`:
+
+```dart
+  testWidgets('configs are grouped by owning unit with a Gas plans section',
+      ...);
+  testWidgets('choosing a config shows the added/kept summary', ...);
+  testWidgets('the menu is hidden when the diver has no configs', ...);
+```
+
+- [ ] **Step 7: Build the menu and wire it into the cylinders card**
+
+`apply_configuration_menu.dart` is a `PopupMenuButton` (or equivalent) that lists configs grouped by owning unit, with generic ones under `applyConfigurationGasPlans`. On selection it calls the apply service, invalidates the dive's tank providers, and shows a snackbar with `applyConfigurationResult` (or `applyConfigurationNothingToDo` when both counts are zero).
+
+Capture the `ScaffoldMessengerState` **before** the `await`, and do not let the snackbar's action closure capture a `BuildContext` that may be disposed. This trap has produced a real crash in this codebase.
+
+Add the menu to `cylinders_card.dart` beside the existing add-cylinder affordance.
+
+- [ ] **Step 8: Run tests to verify they pass**
+
+Run: `flutter test test/features/cylinder_configs/`
+Expected: all PASS.
+
+- [ ] **Step 9: Run the dive log suite**
+
+Run: `flutter test test/features/dive_log/`
+Expected: all pass. `cylinders_card.dart` is shared, so text-finder counts in its consumer tests may need updating.
+
+- [ ] **Step 10: Commit**
+
+```bash
+dart format .
+flutter analyze
+git add -A
+git commit -m "Apply cylinder configurations to dives with a conservative merge (#804)"
+```
+
+---
+
+### Task 16: Configurations card on the rebreather detail page
+
+**Files:**
+- Create: `lib/features/cylinder_configs/presentation/widgets/unit_configurations_card.dart`
+- Modify: `lib/features/equipment/presentation/pages/equipment_detail_page.dart`
+- Test: `test/features/cylinder_configs/presentation/unit_configurations_card_test.dart`
+
+**Interfaces:**
+- Consumes: `cylinderConfigsForEquipmentProvider` (Task 13).
+- Produces: nothing consumed downstream. This closes the issue's "configurations for each CCR" phrasing by making them reachable from the unit.
+
+- [ ] **Step 1: Read the sibling card**
+
+Run: `cat lib/features/equipment/presentation/widgets/service_clocks_card.dart`
+
+Match its card chrome, empty state, and provider-watching style.
+
+- [ ] **Step 2: Write the failing test**
+
+Create `test/features/cylinder_configs/presentation/unit_configurations_card_test.dart`:
+
+```dart
+  testWidgets('lists the unit\'s configurations with cylinder counts', ...);
+  testWidgets('shows an empty state with an add action when there are none',
+      ...);
+  testWidgets('the card is absent for non-rebreather equipment', ...);
+```
+
+- [ ] **Step 3: Run tests to verify they fail**
+
+Run: `flutter test test/features/cylinder_configs/presentation/unit_configurations_card_test.dart`
+Expected: FAIL — the widget does not exist.
+
+- [ ] **Step 4: Build the card and mount it**
+
+The card lists each config with its name and cylinder count, tapping through to the edit page, plus an add action that pre-fills the owning unit. Render it in `equipment_detail_page.dart` only when the item's type is `EquipmentType.rebreather`.
+
+- [ ] **Step 5: Run tests to verify they pass**
+
+Run: `flutter test test/features/cylinder_configs/presentation/unit_configurations_card_test.dart`
+Expected: all PASS.
+
+- [ ] **Step 6: Full verification**
+
+```bash
+dart format .
+flutter analyze
+flutter test
+```
+
+Expected: analyze clean, all tests pass. Report actual output; do not claim success without it.
+
+If the suite is slow or flaky, note that `test/features/media/` and the backup tests have known pre-existing flakiness under full-suite runs. Re-run any failure in isolation before treating it as caused by this work.
+
+- [ ] **Step 7: Manual smoke check**
+
+Run: `flutter run -d macos`
+
+1. Create a rebreather with attributes; confirm the Configurations card appears.
+2. Add a config: diluent, O2 supply, two bailouts with distinct mixes.
+3. Open a dive with no cylinders, apply the config, confirm four cylinders with correct roles and gases.
+4. Apply the same config again, confirm nothing is added.
+5. On a downloaded CCR dive that already has a diluent, apply the config and confirm the existing gas mix is unchanged and the summary reads "kept 1".
+6. Delete the rebreather; confirm the config survives under "Gas plans".
+
+- [ ] **Step 8: Commit**
+
+```bash
+dart format .
+git add -A
+git commit -m "Show cylinder configurations on the rebreather detail page (#804)"
+```
+
+---
+
+## Verification checklist
+
+Before opening a PR:
+
+- [ ] `dart format .` produces no changes
+- [ ] `flutter analyze` is clean, unpiped, with no infos
+- [ ] `flutter test` passes in full
+- [ ] All 11 ARB files contain every new key, and `flutter gen-l10n` produces no diff
+- [ ] `grep -n "currentSchemaVersion = " lib/core/database/database.dart` still shows a value above current `origin/main`
+- [ ] Manual smoke check from Task 16 Step 7 completed on macOS
+- [ ] PR description contains no Claude Code attribution line and no session URL

From cadc8ec0a388d1dde750c29332fab609ea1a73a3 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 17:25:15 -0400
Subject: [PATCH 03/20] Add rebreather equipment type (#804)

Adds EquipmentType.rebreather between tank and weights. Two exhaustive icon
switches (dive edit page, equipment picker sheet) gain a rebreather arm using
Icons.recycling: the vendored MdiIcons subset carries only six glyphs and has
no rebreather among them, and a closed circuit recycling its breathing loop is
the accurate metaphor.
---
 lib/core/constants/enums.dart                               | 1 +
 .../dive_log/presentation/pages/dive_edit_page.dart         | 5 +++++
 .../widgets/pickers/equipment_picker_sheet.dart             | 5 +++++
 .../equipment/domain/equipment_attribute_catalog_test.dart  | 6 ++++++
 4 files changed, 17 insertions(+)

diff --git a/lib/core/constants/enums.dart b/lib/core/constants/enums.dart
index a707fc0095..c0ec3a4276 100644
--- a/lib/core/constants/enums.dart
+++ b/lib/core/constants/enums.dart
@@ -11,6 +11,7 @@ enum EquipmentType {
   computer('Dive Computer'),
   transmitter('Transmitter'),
   tank('Tank'),
+  rebreather('Rebreather'),
   weights('Weights'),
   light('Light'),
   camera('Camera'),
diff --git a/lib/features/dive_log/presentation/pages/dive_edit_page.dart b/lib/features/dive_log/presentation/pages/dive_edit_page.dart
index 78a043bac2..8bf89101eb 100644
--- a/lib/features/dive_log/presentation/pages/dive_edit_page.dart
+++ b/lib/features/dive_log/presentation/pages/dive_edit_page.dart
@@ -2959,6 +2959,11 @@ class _DiveEditPageState extends ConsumerState<DiveEditPage> {
         return Icons.face;
       case EquipmentType.tank:
         return MdiIcons.divingScubaTank;
+      // A closed circuit recycles the breathing loop; the vendored MdiIcons
+      // subset has no rebreather glyph, and the tank glyph already means
+      // "tank".
+      case EquipmentType.rebreather:
+        return Icons.recycling;
       case EquipmentType.transmitter:
         return Icons.sensors;
       case EquipmentType.weights:
diff --git a/lib/features/dive_log/presentation/widgets/pickers/equipment_picker_sheet.dart b/lib/features/dive_log/presentation/widgets/pickers/equipment_picker_sheet.dart
index 7bab38da8b..b363adb8d9 100644
--- a/lib/features/dive_log/presentation/widgets/pickers/equipment_picker_sheet.dart
+++ b/lib/features/dive_log/presentation/widgets/pickers/equipment_picker_sheet.dart
@@ -142,6 +142,11 @@ class EquipmentPickerSheet extends ConsumerWidget {
         return Icons.face;
       case EquipmentType.tank:
         return MdiIcons.divingScubaTank;
+      // A closed circuit recycles the breathing loop; the vendored MdiIcons
+      // subset has no rebreather glyph, and the tank glyph already means
+      // "tank".
+      case EquipmentType.rebreather:
+        return Icons.recycling;
       case EquipmentType.transmitter:
         return Icons.sensors;
       case EquipmentType.weights:
diff --git a/test/features/equipment/domain/equipment_attribute_catalog_test.dart b/test/features/equipment/domain/equipment_attribute_catalog_test.dart
index 472351066a..abcc767233 100644
--- a/test/features/equipment/domain/equipment_attribute_catalog_test.dart
+++ b/test/features/equipment/domain/equipment_attribute_catalog_test.dart
@@ -122,4 +122,10 @@ void main() {
     expect(isValidThicknessDesignation('thin'), isFalse);
     expect(isValidThicknessDesignation('abc'), isFalse);
   });
+
+  test('rebreather is a distinct equipment type with a stable name', () {
+    expect(EquipmentType.values, contains(EquipmentType.rebreather));
+    expect(EquipmentType.rebreather.name, 'rebreather');
+    expect(EquipmentType.rebreather.displayName, 'Rebreather');
+  });
 }

From 1473fdcffcf459d846712e45a2673ab98209d332 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 17:26:13 -0400
Subject: [PATCH 04/20] Add rebreather attribute catalog entry (#804)

Eight curated attributes: unit type (eCCR/mCCR/hCCR and the three SCR
variants), mount configuration, scrubber type and rated duration, O2 cell
count, onboard diluent and O2 cylinder volumes, and depth rating. The depth
rating key is shared verbatim with the camera entry rather than duplicated.
Scrubber duration is deliberately dimensionless: hours need no conversion.
---
 .../equipment_attribute_catalog.dart          | 48 +++++++++++++++++
 .../equipment_attribute_catalog_test.dart     | 51 +++++++++++++++++++
 2 files changed, 99 insertions(+)

diff --git a/lib/features/equipment/domain/constants/equipment_attribute_catalog.dart b/lib/features/equipment/domain/constants/equipment_attribute_catalog.dart
index 20534ffaff..e80375a8bf 100644
--- a/lib/features/equipment/domain/constants/equipment_attribute_catalog.dart
+++ b/lib/features/equipment/domain/constants/equipment_attribute_catalog.dart
@@ -134,6 +134,54 @@ abstract final class EquipmentAttributeCatalog {
       ),
       EquipmentAttributeDef(key: 'last_hydro_test', kind: AttributeKind.date),
     ],
+    EquipmentType.rebreather: [
+      EquipmentAttributeDef(
+        key: 'unit_type',
+        kind: AttributeKind.choice,
+        choiceKeys: [
+          'eccr',
+          'mccr',
+          'hccr',
+          'scr_cmf',
+          'scr_pascr',
+          'scr_escr',
+        ],
+      ),
+      EquipmentAttributeDef(
+        key: 'mount_configuration',
+        kind: AttributeKind.choice,
+        choiceKeys: ['back', 'chest', 'sidemount'],
+      ),
+      EquipmentAttributeDef(
+        key: 'scrubber_type',
+        kind: AttributeKind.choice,
+        choiceKeys: ['axial', 'radial'],
+      ),
+      // Rated scrubber duration in hours. Dimensionless: hours are hours in
+      // every market, so there is nothing for UnitFormatter to convert.
+      EquipmentAttributeDef(
+        key: 'scrubber_duration_h',
+        kind: AttributeKind.number,
+      ),
+      EquipmentAttributeDef(key: 'o2_cell_count', kind: AttributeKind.number),
+      EquipmentAttributeDef(
+        key: 'diluent_cylinder_l',
+        kind: AttributeKind.number,
+        dimension: AttributeDimension.volumeL,
+      ),
+      EquipmentAttributeDef(
+        key: 'o2_cylinder_l',
+        kind: AttributeKind.number,
+        dimension: AttributeDimension.volumeL,
+      ),
+      // Shared verbatim with the camera entry: same concept, same dimension,
+      // one label key.
+      EquipmentAttributeDef(
+        key: 'depth_rating_m',
+        kind: AttributeKind.number,
+        dimension: AttributeDimension.depthM,
+      ),
+    ],
     EquipmentType.regulator: [
       EquipmentAttributeDef(
         key: 'connection',
diff --git a/test/features/equipment/domain/equipment_attribute_catalog_test.dart b/test/features/equipment/domain/equipment_attribute_catalog_test.dart
index abcc767233..1c2884846a 100644
--- a/test/features/equipment/domain/equipment_attribute_catalog_test.dart
+++ b/test/features/equipment/domain/equipment_attribute_catalog_test.dart
@@ -128,4 +128,55 @@ void main() {
     expect(EquipmentType.rebreather.name, 'rebreather');
     expect(EquipmentType.rebreather.displayName, 'Rebreather');
   });
+
+  group('rebreather attributes', () {
+    test('exposes the curated rebreather keys plus the universal ones', () {
+      final keys = EquipmentAttributeCatalog.attributesFor(
+        EquipmentType.rebreather,
+      ).map((d) => d.key).toList();
+
+      expect(keys, [
+        'unit_type',
+        'mount_configuration',
+        'scrubber_type',
+        'scrubber_duration_h',
+        'o2_cell_count',
+        'diluent_cylinder_l',
+        'o2_cylinder_l',
+        'depth_rating_m',
+        'buoyancy_kg',
+        'dry_weight_kg',
+      ]);
+    });
+
+    test('unit_type covers both CCR and SCR variants', () {
+      final def = EquipmentAttributeCatalog.defFor('unit_type');
+      expect(def, isNotNull);
+      expect(def!.kind, AttributeKind.choice);
+      expect(def.choiceKeys, [
+        'eccr',
+        'mccr',
+        'hccr',
+        'scr_cmf',
+        'scr_pascr',
+        'scr_escr',
+      ]);
+    });
+
+    test('onboard cylinder attributes carry the volume dimension', () {
+      for (final key in ['diluent_cylinder_l', 'o2_cylinder_l']) {
+        final def = EquipmentAttributeCatalog.defFor(key);
+        expect(def, isNotNull, reason: key);
+        expect(def!.kind, AttributeKind.number, reason: key);
+        expect(def.dimension, AttributeDimension.volumeL, reason: key);
+      }
+    });
+
+    test('scrubber duration is dimensionless hours, not a unit-converted '
+        'quantity', () {
+      final def = EquipmentAttributeCatalog.defFor('scrubber_duration_h');
+      expect(def!.kind, AttributeKind.number);
+      expect(def.dimension, AttributeDimension.none);
+    });
+  });
 }

From 053f6a7cd70d5e922466b03dc38cdd529815fc35 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 17:29:55 -0400
Subject: [PATCH 05/20] Localize rebreather equipment attributes (#804)

Adds 18 keys across all 11 locales: seven attribute labels and eleven choice
options. The depth rating label is reused from the camera entry rather than
duplicated. CCR, SCR, eCCR, mCCR and hCCR stay verbatim in every locale as
international abbreviations; only the surrounding words are translated.
---
 .../utils/equipment_attribute_l10n.dart       |  19 +++
 lib/l10n/arb/app_ar.arb                       |  18 +++
 lib/l10n/arb/app_de.arb                       |  18 +++
 lib/l10n/arb/app_en.arb                       |  18 +++
 lib/l10n/arb/app_es.arb                       |  18 +++
 lib/l10n/arb/app_fr.arb                       |  18 +++
 lib/l10n/arb/app_he.arb                       |  18 +++
 lib/l10n/arb/app_hu.arb                       |  18 +++
 lib/l10n/arb/app_it.arb                       |  18 +++
 lib/l10n/arb/app_localizations.dart           | 108 ++++++++++++++++++
 lib/l10n/arb/app_localizations_ar.dart        |  54 +++++++++
 lib/l10n/arb/app_localizations_de.dart        |  54 +++++++++
 lib/l10n/arb/app_localizations_en.dart        |  54 +++++++++
 lib/l10n/arb/app_localizations_es.dart        |  54 +++++++++
 lib/l10n/arb/app_localizations_fr.dart        |  54 +++++++++
 lib/l10n/arb/app_localizations_he.dart        |  54 +++++++++
 lib/l10n/arb/app_localizations_hu.dart        |  54 +++++++++
 lib/l10n/arb/app_localizations_it.dart        |  54 +++++++++
 lib/l10n/arb/app_localizations_nl.dart        |  54 +++++++++
 lib/l10n/arb/app_localizations_pt.dart        |  54 +++++++++
 lib/l10n/arb/app_localizations_zh.dart        |  54 +++++++++
 lib/l10n/arb/app_nl.arb                       |  18 +++
 lib/l10n/arb/app_pt.arb                       |  18 +++
 lib/l10n/arb/app_zh.arb                       |  18 +++
 .../equipment_attribute_catalog_test.dart     |  40 +++++++
 25 files changed, 959 insertions(+)

diff --git a/lib/features/equipment/presentation/utils/equipment_attribute_l10n.dart b/lib/features/equipment/presentation/utils/equipment_attribute_l10n.dart
index 4acf1edade..caec4e709c 100644
--- a/lib/features/equipment/presentation/utils/equipment_attribute_l10n.dart
+++ b/lib/features/equipment/presentation/utils/equipment_attribute_l10n.dart
@@ -39,6 +39,13 @@ String attributeLabel(AppLocalizations l10n, String key) => switch (key) {
   'sole_type' => l10n.attrLabel_sole_type,
   'buoyancy_kg' => l10n.attrLabel_buoyancy_kg,
   'dry_weight_kg' => l10n.attrLabel_dry_weight_kg,
+  'unit_type' => l10n.attrLabel_unit_type,
+  'mount_configuration' => l10n.attrLabel_mount_configuration,
+  'scrubber_type' => l10n.attrLabel_scrubber_type,
+  'scrubber_duration_h' => l10n.attrLabel_scrubber_duration_h,
+  'o2_cell_count' => l10n.attrLabel_o2_cell_count,
+  'diluent_cylinder_l' => l10n.attrLabel_diluent_cylinder_l,
+  'o2_cylinder_l' => l10n.attrLabel_o2_cylinder_l,
   _ => key,
 };
 
@@ -109,5 +116,17 @@ String attributeChoiceLabel(AppLocalizations l10n, String key, String option) =>
       'glove_type_dry' => l10n.attrChoice_glove_type_dry,
       'sole_type_hard' => l10n.attrChoice_sole_type_hard,
       'sole_type_soft' => l10n.attrChoice_sole_type_soft,
+      'unit_type_eccr' => l10n.attrChoice_unit_type_eccr,
+      'unit_type_mccr' => l10n.attrChoice_unit_type_mccr,
+      'unit_type_hccr' => l10n.attrChoice_unit_type_hccr,
+      'unit_type_scr_cmf' => l10n.attrChoice_unit_type_scr_cmf,
+      'unit_type_scr_pascr' => l10n.attrChoice_unit_type_scr_pascr,
+      'unit_type_scr_escr' => l10n.attrChoice_unit_type_scr_escr,
+      'mount_configuration_back' => l10n.attrChoice_mount_configuration_back,
+      'mount_configuration_chest' => l10n.attrChoice_mount_configuration_chest,
+      'mount_configuration_sidemount' =>
+        l10n.attrChoice_mount_configuration_sidemount,
+      'scrubber_type_axial' => l10n.attrChoice_scrubber_type_axial,
+      'scrubber_type_radial' => l10n.attrChoice_scrubber_type_radial,
       _ => option,
     };
diff --git a/lib/l10n/arb/app_ar.arb b/lib/l10n/arb/app_ar.arb
index b54ae95ee8..ff6b50c55f 100644
--- a/lib/l10n/arb/app_ar.arb
+++ b/lib/l10n/arb/app_ar.arb
@@ -6289,6 +6289,24 @@
   "attrLabel_sole_type": "النعل",
   "attrLabel_buoyancy_kg": "الطفو",
   "attrLabel_dry_weight_kg": "الوزن الجاف",
+  "attrLabel_unit_type": "نوع الجهاز",
+  "attrLabel_mount_configuration": "طريقة التثبيت",
+  "attrLabel_scrubber_type": "نوع الماص",
+  "attrLabel_scrubber_duration_h": "مدة الماص (ساعة)",
+  "attrLabel_o2_cell_count": "خلايا O2",
+  "attrLabel_diluent_cylinder_l": "أسطوانة المخفف",
+  "attrLabel_o2_cylinder_l": "أسطوانة O2",
+  "attrChoice_unit_type_eccr": "CCR إلكتروني (eCCR)",
+  "attrChoice_unit_type_mccr": "CCR يدوي (mCCR)",
+  "attrChoice_unit_type_hccr": "CCR هجين (hCCR)",
+  "attrChoice_unit_type_scr_cmf": "SCR - تدفق كتلي ثابت",
+  "attrChoice_unit_type_scr_pascr": "SCR - إضافة سلبية",
+  "attrChoice_unit_type_scr_escr": "SCR - تحكم إلكتروني",
+  "attrChoice_mount_configuration_back": "تثبيت خلفي",
+  "attrChoice_mount_configuration_chest": "تثبيت أمامي",
+  "attrChoice_mount_configuration_sidemount": "تثبيت جانبي",
+  "attrChoice_scrubber_type_axial": "محوري",
+  "attrChoice_scrubber_type_radial": "شعاعي",
   "attrChoice_suit_style_full": "بدلة كاملة",
   "attrChoice_suit_style_shorty": "شورتي",
   "attrChoice_suit_style_two_piece": "قطعتان",
diff --git a/lib/l10n/arb/app_de.arb b/lib/l10n/arb/app_de.arb
index aea7652b33..f79e4e027b 100644
--- a/lib/l10n/arb/app_de.arb
+++ b/lib/l10n/arb/app_de.arb
@@ -6289,6 +6289,24 @@
   "attrLabel_sole_type": "Sohle",
   "attrLabel_buoyancy_kg": "Auftrieb",
   "attrLabel_dry_weight_kg": "Trockengewicht",
+  "attrLabel_unit_type": "Gerätetyp",
+  "attrLabel_mount_configuration": "Montage",
+  "attrLabel_scrubber_type": "Absorbertyp",
+  "attrLabel_scrubber_duration_h": "Absorberstandzeit (h)",
+  "attrLabel_o2_cell_count": "O2-Zellen",
+  "attrLabel_diluent_cylinder_l": "Diluent-Flasche",
+  "attrLabel_o2_cylinder_l": "O2-Flasche",
+  "attrChoice_unit_type_eccr": "Elektronischer CCR (eCCR)",
+  "attrChoice_unit_type_mccr": "Manueller CCR (mCCR)",
+  "attrChoice_unit_type_hccr": "Hybrid-CCR (hCCR)",
+  "attrChoice_unit_type_scr_cmf": "SCR - konstanter Massenstrom",
+  "attrChoice_unit_type_scr_pascr": "SCR - passive Zugabe",
+  "attrChoice_unit_type_scr_escr": "SCR - elektronisch geregelt",
+  "attrChoice_mount_configuration_back": "Rückenmontage",
+  "attrChoice_mount_configuration_chest": "Brustmontage",
+  "attrChoice_mount_configuration_sidemount": "Seitenmontage",
+  "attrChoice_scrubber_type_axial": "Axial",
+  "attrChoice_scrubber_type_radial": "Radial",
   "attrChoice_suit_style_full": "Vollanzug",
   "attrChoice_suit_style_shorty": "Shorty",
   "attrChoice_suit_style_two_piece": "Zweiteiler",
diff --git a/lib/l10n/arb/app_en.arb b/lib/l10n/arb/app_en.arb
index 39bad41585..f8aeb2a75f 100644
--- a/lib/l10n/arb/app_en.arb
+++ b/lib/l10n/arb/app_en.arb
@@ -13745,6 +13745,24 @@
   "attrLabel_sole_type": "Sole",
   "attrLabel_buoyancy_kg": "Buoyancy",
   "attrLabel_dry_weight_kg": "Dry weight",
+  "attrLabel_unit_type": "Unit type",
+  "attrLabel_mount_configuration": "Mount",
+  "attrLabel_scrubber_type": "Scrubber type",
+  "attrLabel_scrubber_duration_h": "Scrubber duration (h)",
+  "attrLabel_o2_cell_count": "O2 cells",
+  "attrLabel_diluent_cylinder_l": "Diluent cylinder",
+  "attrLabel_o2_cylinder_l": "O2 cylinder",
+  "attrChoice_unit_type_eccr": "Electronic CCR (eCCR)",
+  "attrChoice_unit_type_mccr": "Manual CCR (mCCR)",
+  "attrChoice_unit_type_hccr": "Hybrid CCR (hCCR)",
+  "attrChoice_unit_type_scr_cmf": "SCR - constant mass flow",
+  "attrChoice_unit_type_scr_pascr": "SCR - passive addition",
+  "attrChoice_unit_type_scr_escr": "SCR - electronically controlled",
+  "attrChoice_mount_configuration_back": "Back mount",
+  "attrChoice_mount_configuration_chest": "Chest mount",
+  "attrChoice_mount_configuration_sidemount": "Sidemount",
+  "attrChoice_scrubber_type_axial": "Axial",
+  "attrChoice_scrubber_type_radial": "Radial",
   "attrChoice_suit_style_full": "Full suit",
   "attrChoice_suit_style_shorty": "Shorty",
   "attrChoice_suit_style_two_piece": "Two-piece",
diff --git a/lib/l10n/arb/app_es.arb b/lib/l10n/arb/app_es.arb
index 2a08982f6f..88a3a7b5df 100644
--- a/lib/l10n/arb/app_es.arb
+++ b/lib/l10n/arb/app_es.arb
@@ -6289,6 +6289,24 @@
   "attrLabel_sole_type": "Suela",
   "attrLabel_buoyancy_kg": "Flotabilidad",
   "attrLabel_dry_weight_kg": "Peso en seco",
+  "attrLabel_unit_type": "Tipo de equipo",
+  "attrLabel_mount_configuration": "Montaje",
+  "attrLabel_scrubber_type": "Tipo de filtro",
+  "attrLabel_scrubber_duration_h": "Duración del filtro (h)",
+  "attrLabel_o2_cell_count": "Células de O2",
+  "attrLabel_diluent_cylinder_l": "Botella de diluyente",
+  "attrLabel_o2_cylinder_l": "Botella de O2",
+  "attrChoice_unit_type_eccr": "CCR electrónico (eCCR)",
+  "attrChoice_unit_type_mccr": "CCR manual (mCCR)",
+  "attrChoice_unit_type_hccr": "CCR híbrido (hCCR)",
+  "attrChoice_unit_type_scr_cmf": "SCR - flujo másico constante",
+  "attrChoice_unit_type_scr_pascr": "SCR - adición pasiva",
+  "attrChoice_unit_type_scr_escr": "SCR - control electrónico",
+  "attrChoice_mount_configuration_back": "Montaje dorsal",
+  "attrChoice_mount_configuration_chest": "Montaje frontal",
+  "attrChoice_mount_configuration_sidemount": "Sidemount",
+  "attrChoice_scrubber_type_axial": "Axial",
+  "attrChoice_scrubber_type_radial": "Radial",
   "attrChoice_suit_style_full": "Traje completo",
   "attrChoice_suit_style_shorty": "Shorty",
   "attrChoice_suit_style_two_piece": "Dos piezas",
diff --git a/lib/l10n/arb/app_fr.arb b/lib/l10n/arb/app_fr.arb
index 041e97ddc6..cb7523d375 100644
--- a/lib/l10n/arb/app_fr.arb
+++ b/lib/l10n/arb/app_fr.arb
@@ -6289,6 +6289,24 @@
   "attrLabel_sole_type": "Semelle",
   "attrLabel_buoyancy_kg": "Flottabilité",
   "attrLabel_dry_weight_kg": "Poids à sec",
+  "attrLabel_unit_type": "Type d'appareil",
+  "attrLabel_mount_configuration": "Montage",
+  "attrLabel_scrubber_type": "Type de cartouche",
+  "attrLabel_scrubber_duration_h": "Autonomie cartouche (h)",
+  "attrLabel_o2_cell_count": "Cellules O2",
+  "attrLabel_diluent_cylinder_l": "Bouteille de diluant",
+  "attrLabel_o2_cylinder_l": "Bouteille d'O2",
+  "attrChoice_unit_type_eccr": "CCR électronique (eCCR)",
+  "attrChoice_unit_type_mccr": "CCR manuel (mCCR)",
+  "attrChoice_unit_type_hccr": "CCR hybride (hCCR)",
+  "attrChoice_unit_type_scr_cmf": "SCR - débit massique constant",
+  "attrChoice_unit_type_scr_pascr": "SCR - addition passive",
+  "attrChoice_unit_type_scr_escr": "SCR - régulé électroniquement",
+  "attrChoice_mount_configuration_back": "Montage dorsal",
+  "attrChoice_mount_configuration_chest": "Montage ventral",
+  "attrChoice_mount_configuration_sidemount": "Sidemount",
+  "attrChoice_scrubber_type_axial": "Axiale",
+  "attrChoice_scrubber_type_radial": "Radiale",
   "attrChoice_suit_style_full": "Combinaison intégrale",
   "attrChoice_suit_style_shorty": "Shorty",
   "attrChoice_suit_style_two_piece": "Deux pièces",
diff --git a/lib/l10n/arb/app_he.arb b/lib/l10n/arb/app_he.arb
index 1d0b56a9a1..ff38efa48b 100644
--- a/lib/l10n/arb/app_he.arb
+++ b/lib/l10n/arb/app_he.arb
@@ -6289,6 +6289,24 @@
   "attrLabel_sole_type": "סוליה",
   "attrLabel_buoyancy_kg": "ציפה",
   "attrLabel_dry_weight_kg": "משקל יבש",
+  "attrLabel_unit_type": "סוג היחידה",
+  "attrLabel_mount_configuration": "אופן ההרכבה",
+  "attrLabel_scrubber_type": "סוג הסופח",
+  "attrLabel_scrubber_duration_h": "משך הסופח (שעות)",
+  "attrLabel_o2_cell_count": "תאי O2",
+  "attrLabel_diluent_cylinder_l": "בלון מדלל",
+  "attrLabel_o2_cylinder_l": "בלון O2",
+  "attrChoice_unit_type_eccr": "CCR אלקטרוני (eCCR)",
+  "attrChoice_unit_type_mccr": "CCR ידני (mCCR)",
+  "attrChoice_unit_type_hccr": "CCR היברידי (hCCR)",
+  "attrChoice_unit_type_scr_cmf": "SCR - ספיקת מסה קבועה",
+  "attrChoice_unit_type_scr_pascr": "SCR - הוספה פסיבית",
+  "attrChoice_unit_type_scr_escr": "SCR - בקרה אלקטרונית",
+  "attrChoice_mount_configuration_back": "הרכבה על הגב",
+  "attrChoice_mount_configuration_chest": "הרכבה על החזה",
+  "attrChoice_mount_configuration_sidemount": "הרכבה בצד",
+  "attrChoice_scrubber_type_axial": "צירי",
+  "attrChoice_scrubber_type_radial": "רדיאלי",
   "attrChoice_suit_style_full": "חליפה מלאה",
   "attrChoice_suit_style_shorty": "שורטי",
   "attrChoice_suit_style_two_piece": "שני חלקים",
diff --git a/lib/l10n/arb/app_hu.arb b/lib/l10n/arb/app_hu.arb
index 9742fd3471..6248d3099b 100644
--- a/lib/l10n/arb/app_hu.arb
+++ b/lib/l10n/arb/app_hu.arb
@@ -6289,6 +6289,24 @@
   "attrLabel_sole_type": "Talp",
   "attrLabel_buoyancy_kg": "Felhajtóerő",
   "attrLabel_dry_weight_kg": "Száraz tömeg",
+  "attrLabel_unit_type": "Készülék típusa",
+  "attrLabel_mount_configuration": "Rögzítés",
+  "attrLabel_scrubber_type": "Abszorber típusa",
+  "attrLabel_scrubber_duration_h": "Abszorber élettartama (ó)",
+  "attrLabel_o2_cell_count": "O2-cellák",
+  "attrLabel_diluent_cylinder_l": "Diluent palack",
+  "attrLabel_o2_cylinder_l": "O2 palack",
+  "attrChoice_unit_type_eccr": "Elektronikus CCR (eCCR)",
+  "attrChoice_unit_type_mccr": "Manuális CCR (mCCR)",
+  "attrChoice_unit_type_hccr": "Hibrid CCR (hCCR)",
+  "attrChoice_unit_type_scr_cmf": "SCR - állandó tömegáram",
+  "attrChoice_unit_type_scr_pascr": "SCR - passzív adagolás",
+  "attrChoice_unit_type_scr_escr": "SCR - elektronikus szabályozás",
+  "attrChoice_mount_configuration_back": "Háti rögzítés",
+  "attrChoice_mount_configuration_chest": "Mellkasi rögzítés",
+  "attrChoice_mount_configuration_sidemount": "Oldalra szerelt",
+  "attrChoice_scrubber_type_axial": "Axiális",
+  "attrChoice_scrubber_type_radial": "Radiális",
   "attrChoice_suit_style_full": "Egész ruha",
   "attrChoice_suit_style_shorty": "Shorty",
   "attrChoice_suit_style_two_piece": "Kétrészes",
diff --git a/lib/l10n/arb/app_it.arb b/lib/l10n/arb/app_it.arb
index ebbc9c9cba..77041082ea 100644
--- a/lib/l10n/arb/app_it.arb
+++ b/lib/l10n/arb/app_it.arb
@@ -6289,6 +6289,24 @@
   "attrLabel_sole_type": "Suola",
   "attrLabel_buoyancy_kg": "Galleggiabilità",
   "attrLabel_dry_weight_kg": "Peso a secco",
+  "attrLabel_unit_type": "Tipo di unità",
+  "attrLabel_mount_configuration": "Montaggio",
+  "attrLabel_scrubber_type": "Tipo di calce",
+  "attrLabel_scrubber_duration_h": "Durata calce (h)",
+  "attrLabel_o2_cell_count": "Celle O2",
+  "attrLabel_diluent_cylinder_l": "Bombola diluente",
+  "attrLabel_o2_cylinder_l": "Bombola O2",
+  "attrChoice_unit_type_eccr": "CCR elettronico (eCCR)",
+  "attrChoice_unit_type_mccr": "CCR manuale (mCCR)",
+  "attrChoice_unit_type_hccr": "CCR ibrido (hCCR)",
+  "attrChoice_unit_type_scr_cmf": "SCR - flusso di massa costante",
+  "attrChoice_unit_type_scr_pascr": "SCR - addizione passiva",
+  "attrChoice_unit_type_scr_escr": "SCR - controllo elettronico",
+  "attrChoice_mount_configuration_back": "Montaggio dorsale",
+  "attrChoice_mount_configuration_chest": "Montaggio frontale",
+  "attrChoice_mount_configuration_sidemount": "Sidemount",
+  "attrChoice_scrubber_type_axial": "Assiale",
+  "attrChoice_scrubber_type_radial": "Radiale",
   "attrChoice_suit_style_full": "Muta intera",
   "attrChoice_suit_style_shorty": "Shorty",
   "attrChoice_suit_style_two_piece": "Due pezzi",
diff --git a/lib/l10n/arb/app_localizations.dart b/lib/l10n/arb/app_localizations.dart
index 56dd9dd2a8..08bda315e2 100644
--- a/lib/l10n/arb/app_localizations.dart
+++ b/lib/l10n/arb/app_localizations.dart
@@ -36214,6 +36214,114 @@ abstract class AppLocalizations {
   /// **'Dry weight'**
   String get attrLabel_dry_weight_kg;
 
+  /// No description provided for @attrLabel_unit_type.
+  ///
+  /// In en, this message translates to:
+  /// **'Unit type'**
+  String get attrLabel_unit_type;
+
+  /// No description provided for @attrLabel_mount_configuration.
+  ///
+  /// In en, this message translates to:
+  /// **'Mount'**
+  String get attrLabel_mount_configuration;
+
+  /// No description provided for @attrLabel_scrubber_type.
+  ///
+  /// In en, this message translates to:
+  /// **'Scrubber type'**
+  String get attrLabel_scrubber_type;
+
+  /// No description provided for @attrLabel_scrubber_duration_h.
+  ///
+  /// In en, this message translates to:
+  /// **'Scrubber duration (h)'**
+  String get attrLabel_scrubber_duration_h;
+
+  /// No description provided for @attrLabel_o2_cell_count.
+  ///
+  /// In en, this message translates to:
+  /// **'O2 cells'**
+  String get attrLabel_o2_cell_count;
+
+  /// No description provided for @attrLabel_diluent_cylinder_l.
+  ///
+  /// In en, this message translates to:
+  /// **'Diluent cylinder'**
+  String get attrLabel_diluent_cylinder_l;
+
+  /// No description provided for @attrLabel_o2_cylinder_l.
+  ///
+  /// In en, this message translates to:
+  /// **'O2 cylinder'**
+  String get attrLabel_o2_cylinder_l;
+
+  /// No description provided for @attrChoice_unit_type_eccr.
+  ///
+  /// In en, this message translates to:
+  /// **'Electronic CCR (eCCR)'**
+  String get attrChoice_unit_type_eccr;
+
+  /// No description provided for @attrChoice_unit_type_mccr.
+  ///
+  /// In en, this message translates to:
+  /// **'Manual CCR (mCCR)'**
+  String get attrChoice_unit_type_mccr;
+
+  /// No description provided for @attrChoice_unit_type_hccr.
+  ///
+  /// In en, this message translates to:
+  /// **'Hybrid CCR (hCCR)'**
+  String get attrChoice_unit_type_hccr;
+
+  /// No description provided for @attrChoice_unit_type_scr_cmf.
+  ///
+  /// In en, this message translates to:
+  /// **'SCR - constant mass flow'**
+  String get attrChoice_unit_type_scr_cmf;
+
+  /// No description provided for @attrChoice_unit_type_scr_pascr.
+  ///
+  /// In en, this message translates to:
+  /// **'SCR - passive addition'**
+  String get attrChoice_unit_type_scr_pascr;
+
+  /// No description provided for @attrChoice_unit_type_scr_escr.
+  ///
+  /// In en, this message translates to:
+  /// **'SCR - electronically controlled'**
+  String get attrChoice_unit_type_scr_escr;
+
+  /// No description provided for @attrChoice_mount_configuration_back.
+  ///
+  /// In en, this message translates to:
+  /// **'Back mount'**
+  String get attrChoice_mount_configuration_back;
+
+  /// No description provided for @attrChoice_mount_configuration_chest.
+  ///
+  /// In en, this message translates to:
+  /// **'Chest mount'**
+  String get attrChoice_mount_configuration_chest;
+
+  /// No description provided for @attrChoice_mount_configuration_sidemount.
+  ///
+  /// In en, this message translates to:
+  /// **'Sidemount'**
+  String get attrChoice_mount_configuration_sidemount;
+
+  /// No description provided for @attrChoice_scrubber_type_axial.
+  ///
+  /// In en, this message translates to:
+  /// **'Axial'**
+  String get attrChoice_scrubber_type_axial;
+
+  /// No description provided for @attrChoice_scrubber_type_radial.
+  ///
+  /// In en, this message translates to:
+  /// **'Radial'**
+  String get attrChoice_scrubber_type_radial;
+
   /// No description provided for @attrChoice_suit_style_full.
   ///
   /// In en, this message translates to:
diff --git a/lib/l10n/arb/app_localizations_ar.dart b/lib/l10n/arb/app_localizations_ar.dart
index 8cec8c6430..2ae502d297 100644
--- a/lib/l10n/arb/app_localizations_ar.dart
+++ b/lib/l10n/arb/app_localizations_ar.dart
@@ -21287,6 +21287,60 @@ class AppLocalizationsAr extends AppLocalizations {
   @override
   String get attrLabel_dry_weight_kg => 'الوزن الجاف';
 
+  @override
+  String get attrLabel_unit_type => 'نوع الجهاز';
+
+  @override
+  String get attrLabel_mount_configuration => 'طريقة التثبيت';
+
+  @override
+  String get attrLabel_scrubber_type => 'نوع الماص';
+
+  @override
+  String get attrLabel_scrubber_duration_h => 'مدة الماص (ساعة)';
+
+  @override
+  String get attrLabel_o2_cell_count => 'خلايا O2';
+
+  @override
+  String get attrLabel_diluent_cylinder_l => 'أسطوانة المخفف';
+
+  @override
+  String get attrLabel_o2_cylinder_l => 'أسطوانة O2';
+
+  @override
+  String get attrChoice_unit_type_eccr => 'CCR إلكتروني (eCCR)';
+
+  @override
+  String get attrChoice_unit_type_mccr => 'CCR يدوي (mCCR)';
+
+  @override
+  String get attrChoice_unit_type_hccr => 'CCR هجين (hCCR)';
+
+  @override
+  String get attrChoice_unit_type_scr_cmf => 'SCR - تدفق كتلي ثابت';
+
+  @override
+  String get attrChoice_unit_type_scr_pascr => 'SCR - إضافة سلبية';
+
+  @override
+  String get attrChoice_unit_type_scr_escr => 'SCR - تحكم إلكتروني';
+
+  @override
+  String get attrChoice_mount_configuration_back => 'تثبيت خلفي';
+
+  @override
+  String get attrChoice_mount_configuration_chest => 'تثبيت أمامي';
+
+  @override
+  String get attrChoice_mount_configuration_sidemount => 'تثبيت جانبي';
+
+  @override
+  String get attrChoice_scrubber_type_axial => 'محوري';
+
+  @override
+  String get attrChoice_scrubber_type_radial => 'شعاعي';
+
   @override
   String get attrChoice_suit_style_full => 'بدلة كاملة';
 
diff --git a/lib/l10n/arb/app_localizations_de.dart b/lib/l10n/arb/app_localizations_de.dart
index 318af70674..a51f4c89c3 100644
--- a/lib/l10n/arb/app_localizations_de.dart
+++ b/lib/l10n/arb/app_localizations_de.dart
@@ -21641,6 +21641,60 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get attrLabel_dry_weight_kg => 'Trockengewicht';
 
+  @override
+  String get attrLabel_unit_type => 'Gerätetyp';
+
+  @override
+  String get attrLabel_mount_configuration => 'Montage';
+
+  @override
+  String get attrLabel_scrubber_type => 'Absorbertyp';
+
+  @override
+  String get attrLabel_scrubber_duration_h => 'Absorberstandzeit (h)';
+
+  @override
+  String get attrLabel_o2_cell_count => 'O2-Zellen';
+
+  @override
+  String get attrLabel_diluent_cylinder_l => 'Diluent-Flasche';
+
+  @override
+  String get attrLabel_o2_cylinder_l => 'O2-Flasche';
+
+  @override
+  String get attrChoice_unit_type_eccr => 'Elektronischer CCR (eCCR)';
+
+  @override
+  String get attrChoice_unit_type_mccr => 'Manueller CCR (mCCR)';
+
+  @override
+  String get attrChoice_unit_type_hccr => 'Hybrid-CCR (hCCR)';
+
+  @override
+  String get attrChoice_unit_type_scr_cmf => 'SCR - konstanter Massenstrom';
+
+  @override
+  String get attrChoice_unit_type_scr_pascr => 'SCR - passive Zugabe';
+
+  @override
+  String get attrChoice_unit_type_scr_escr => 'SCR - elektronisch geregelt';
+
+  @override
+  String get attrChoice_mount_configuration_back => 'Rückenmontage';
+
+  @override
+  String get attrChoice_mount_configuration_chest => 'Brustmontage';
+
+  @override
+  String get attrChoice_mount_configuration_sidemount => 'Seitenmontage';
+
+  @override
+  String get attrChoice_scrubber_type_axial => 'Axial';
+
+  @override
+  String get attrChoice_scrubber_type_radial => 'Radial';
+
   @override
   String get attrChoice_suit_style_full => 'Vollanzug';
 
diff --git a/lib/l10n/arb/app_localizations_en.dart b/lib/l10n/arb/app_localizations_en.dart
index bbe8acd472..04971acaf4 100644
--- a/lib/l10n/arb/app_localizations_en.dart
+++ b/lib/l10n/arb/app_localizations_en.dart
@@ -21314,6 +21314,60 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get attrLabel_dry_weight_kg => 'Dry weight';
 
+  @override
+  String get attrLabel_unit_type => 'Unit type';
+
+  @override
+  String get attrLabel_mount_configuration => 'Mount';
+
+  @override
+  String get attrLabel_scrubber_type => 'Scrubber type';
+
+  @override
+  String get attrLabel_scrubber_duration_h => 'Scrubber duration (h)';
+
+  @override
+  String get attrLabel_o2_cell_count => 'O2 cells';
+
+  @override
+  String get attrLabel_diluent_cylinder_l => 'Diluent cylinder';
+
+  @override
+  String get attrLabel_o2_cylinder_l => 'O2 cylinder';
+
+  @override
+  String get attrChoice_unit_type_eccr => 'Electronic CCR (eCCR)';
+
+  @override
+  String get attrChoice_unit_type_mccr => 'Manual CCR (mCCR)';
+
+  @override
+  String get attrChoice_unit_type_hccr => 'Hybrid CCR (hCCR)';
+
+  @override
+  String get attrChoice_unit_type_scr_cmf => 'SCR - constant mass flow';
+
+  @override
+  String get attrChoice_unit_type_scr_pascr => 'SCR - passive addition';
+
+  @override
+  String get attrChoice_unit_type_scr_escr => 'SCR - electronically controlled';
+
+  @override
+  String get attrChoice_mount_configuration_back => 'Back mount';
+
+  @override
+  String get attrChoice_mount_configuration_chest => 'Chest mount';
+
+  @override
+  String get attrChoice_mount_configuration_sidemount => 'Sidemount';
+
+  @override
+  String get attrChoice_scrubber_type_axial => 'Axial';
+
+  @override
+  String get attrChoice_scrubber_type_radial => 'Radial';
+
   @override
   String get attrChoice_suit_style_full => 'Full suit';
 
diff --git a/lib/l10n/arb/app_localizations_es.dart b/lib/l10n/arb/app_localizations_es.dart
index b367e179ee..ce26981096 100644
--- a/lib/l10n/arb/app_localizations_es.dart
+++ b/lib/l10n/arb/app_localizations_es.dart
@@ -21694,6 +21694,60 @@ class AppLocalizationsEs extends AppLocalizations {
   @override
   String get attrLabel_dry_weight_kg => 'Peso en seco';
 
+  @override
+  String get attrLabel_unit_type => 'Tipo de equipo';
+
+  @override
+  String get attrLabel_mount_configuration => 'Montaje';
+
+  @override
+  String get attrLabel_scrubber_type => 'Tipo de filtro';
+
+  @override
+  String get attrLabel_scrubber_duration_h => 'Duración del filtro (h)';
+
+  @override
+  String get attrLabel_o2_cell_count => 'Células de O2';
+
+  @override
+  String get attrLabel_diluent_cylinder_l => 'Botella de diluyente';
+
+  @override
+  String get attrLabel_o2_cylinder_l => 'Botella de O2';
+
+  @override
+  String get attrChoice_unit_type_eccr => 'CCR electrónico (eCCR)';
+
+  @override
+  String get attrChoice_unit_type_mccr => 'CCR manual (mCCR)';
+
+  @override
+  String get attrChoice_unit_type_hccr => 'CCR híbrido (hCCR)';
+
+  @override
+  String get attrChoice_unit_type_scr_cmf => 'SCR - flujo másico constante';
+
+  @override
+  String get attrChoice_unit_type_scr_pascr => 'SCR - adición pasiva';
+
+  @override
+  String get attrChoice_unit_type_scr_escr => 'SCR - control electrónico';
+
+  @override
+  String get attrChoice_mount_configuration_back => 'Montaje dorsal';
+
+  @override
+  String get attrChoice_mount_configuration_chest => 'Montaje frontal';
+
+  @override
+  String get attrChoice_mount_configuration_sidemount => 'Sidemount';
+
+  @override
+  String get attrChoice_scrubber_type_axial => 'Axial';
+
+  @override
+  String get attrChoice_scrubber_type_radial => 'Radial';
+
   @override
   String get attrChoice_suit_style_full => 'Traje completo';
 
diff --git a/lib/l10n/arb/app_localizations_fr.dart b/lib/l10n/arb/app_localizations_fr.dart
index ed90567f4b..f2542ab4e9 100644
--- a/lib/l10n/arb/app_localizations_fr.dart
+++ b/lib/l10n/arb/app_localizations_fr.dart
@@ -21751,6 +21751,60 @@ class AppLocalizationsFr extends AppLocalizations {
   @override
   String get attrLabel_dry_weight_kg => 'Poids à sec';
 
+  @override
+  String get attrLabel_unit_type => 'Type d\'appareil';
+
+  @override
+  String get attrLabel_mount_configuration => 'Montage';
+
+  @override
+  String get attrLabel_scrubber_type => 'Type de cartouche';
+
+  @override
+  String get attrLabel_scrubber_duration_h => 'Autonomie cartouche (h)';
+
+  @override
+  String get attrLabel_o2_cell_count => 'Cellules O2';
+
+  @override
+  String get attrLabel_diluent_cylinder_l => 'Bouteille de diluant';
+
+  @override
+  String get attrLabel_o2_cylinder_l => 'Bouteille d\'O2';
+
+  @override
+  String get attrChoice_unit_type_eccr => 'CCR électronique (eCCR)';
+
+  @override
+  String get attrChoice_unit_type_mccr => 'CCR manuel (mCCR)';
+
+  @override
+  String get attrChoice_unit_type_hccr => 'CCR hybride (hCCR)';
+
+  @override
+  String get attrChoice_unit_type_scr_cmf => 'SCR - débit massique constant';
+
+  @override
+  String get attrChoice_unit_type_scr_pascr => 'SCR - addition passive';
+
+  @override
+  String get attrChoice_unit_type_scr_escr => 'SCR - régulé électroniquement';
+
+  @override
+  String get attrChoice_mount_configuration_back => 'Montage dorsal';
+
+  @override
+  String get attrChoice_mount_configuration_chest => 'Montage ventral';
+
+  @override
+  String get attrChoice_mount_configuration_sidemount => 'Sidemount';
+
+  @override
+  String get attrChoice_scrubber_type_axial => 'Axiale';
+
+  @override
+  String get attrChoice_scrubber_type_radial => 'Radiale';
+
   @override
   String get attrChoice_suit_style_full => 'Combinaison intégrale';
 
diff --git a/lib/l10n/arb/app_localizations_he.dart b/lib/l10n/arb/app_localizations_he.dart
index 255cb1000a..6f68ddae03 100644
--- a/lib/l10n/arb/app_localizations_he.dart
+++ b/lib/l10n/arb/app_localizations_he.dart
@@ -21136,6 +21136,60 @@ class AppLocalizationsHe extends AppLocalizations {
   @override
   String get attrLabel_dry_weight_kg => 'משקל יבש';
 
+  @override
+  String get attrLabel_unit_type => 'סוג היחידה';
+
+  @override
+  String get attrLabel_mount_configuration => 'אופן ההרכבה';
+
+  @override
+  String get attrLabel_scrubber_type => 'סוג הסופח';
+
+  @override
+  String get attrLabel_scrubber_duration_h => 'משך הסופח (שעות)';
+
+  @override
+  String get attrLabel_o2_cell_count => 'תאי O2';
+
+  @override
+  String get attrLabel_diluent_cylinder_l => 'בלון מדלל';
+
+  @override
+  String get attrLabel_o2_cylinder_l => 'בלון O2';
+
+  @override
+  String get attrChoice_unit_type_eccr => 'CCR אלקטרוני (eCCR)';
+
+  @override
+  String get attrChoice_unit_type_mccr => 'CCR ידני (mCCR)';
+
+  @override
+  String get attrChoice_unit_type_hccr => 'CCR היברידי (hCCR)';
+
+  @override
+  String get attrChoice_unit_type_scr_cmf => 'SCR - ספיקת מסה קבועה';
+
+  @override
+  String get attrChoice_unit_type_scr_pascr => 'SCR - הוספה פסיבית';
+
+  @override
+  String get attrChoice_unit_type_scr_escr => 'SCR - בקרה אלקטרונית';
+
+  @override
+  String get attrChoice_mount_configuration_back => 'הרכבה על הגב';
+
+  @override
+  String get attrChoice_mount_configuration_chest => 'הרכבה על החזה';
+
+  @override
+  String get attrChoice_mount_configuration_sidemount => 'הרכבה בצד';
+
+  @override
+  String get attrChoice_scrubber_type_axial => 'צירי';
+
+  @override
+  String get attrChoice_scrubber_type_radial => 'רדיאלי';
+
   @override
   String get attrChoice_suit_style_full => 'חליפה מלאה';
 
diff --git a/lib/l10n/arb/app_localizations_hu.dart b/lib/l10n/arb/app_localizations_hu.dart
index dae2278920..7a78e2a973 100644
--- a/lib/l10n/arb/app_localizations_hu.dart
+++ b/lib/l10n/arb/app_localizations_hu.dart
@@ -21610,6 +21610,60 @@ class AppLocalizationsHu extends AppLocalizations {
   @override
   String get attrLabel_dry_weight_kg => 'Száraz tömeg';
 
+  @override
+  String get attrLabel_unit_type => 'Készülék típusa';
+
+  @override
+  String get attrLabel_mount_configuration => 'Rögzítés';
+
+  @override
+  String get attrLabel_scrubber_type => 'Abszorber típusa';
+
+  @override
+  String get attrLabel_scrubber_duration_h => 'Abszorber élettartama (ó)';
+
+  @override
+  String get attrLabel_o2_cell_count => 'O2-cellák';
+
+  @override
+  String get attrLabel_diluent_cylinder_l => 'Diluent palack';
+
+  @override
+  String get attrLabel_o2_cylinder_l => 'O2 palack';
+
+  @override
+  String get attrChoice_unit_type_eccr => 'Elektronikus CCR (eCCR)';
+
+  @override
+  String get attrChoice_unit_type_mccr => 'Manuális CCR (mCCR)';
+
+  @override
+  String get attrChoice_unit_type_hccr => 'Hibrid CCR (hCCR)';
+
+  @override
+  String get attrChoice_unit_type_scr_cmf => 'SCR - állandó tömegáram';
+
+  @override
+  String get attrChoice_unit_type_scr_pascr => 'SCR - passzív adagolás';
+
+  @override
+  String get attrChoice_unit_type_scr_escr => 'SCR - elektronikus szabályozás';
+
+  @override
+  String get attrChoice_mount_configuration_back => 'Háti rögzítés';
+
+  @override
+  String get attrChoice_mount_configuration_chest => 'Mellkasi rögzítés';
+
+  @override
+  String get attrChoice_mount_configuration_sidemount => 'Oldalra szerelt';
+
+  @override
+  String get attrChoice_scrubber_type_axial => 'Axiális';
+
+  @override
+  String get attrChoice_scrubber_type_radial => 'Radiális';
+
   @override
   String get attrChoice_suit_style_full => 'Egész ruha';
 
diff --git a/lib/l10n/arb/app_localizations_it.dart b/lib/l10n/arb/app_localizations_it.dart
index 6f8d6b6b99..b70ae368e6 100644
--- a/lib/l10n/arb/app_localizations_it.dart
+++ b/lib/l10n/arb/app_localizations_it.dart
@@ -21677,6 +21677,60 @@ class AppLocalizationsIt extends AppLocalizations {
   @override
   String get attrLabel_dry_weight_kg => 'Peso a secco';
 
+  @override
+  String get attrLabel_unit_type => 'Tipo di unità';
+
+  @override
+  String get attrLabel_mount_configuration => 'Montaggio';
+
+  @override
+  String get attrLabel_scrubber_type => 'Tipo di calce';
+
+  @override
+  String get attrLabel_scrubber_duration_h => 'Durata calce (h)';
+
+  @override
+  String get attrLabel_o2_cell_count => 'Celle O2';
+
+  @override
+  String get attrLabel_diluent_cylinder_l => 'Bombola diluente';
+
+  @override
+  String get attrLabel_o2_cylinder_l => 'Bombola O2';
+
+  @override
+  String get attrChoice_unit_type_eccr => 'CCR elettronico (eCCR)';
+
+  @override
+  String get attrChoice_unit_type_mccr => 'CCR manuale (mCCR)';
+
+  @override
+  String get attrChoice_unit_type_hccr => 'CCR ibrido (hCCR)';
+
+  @override
+  String get attrChoice_unit_type_scr_cmf => 'SCR - flusso di massa costante';
+
+  @override
+  String get attrChoice_unit_type_scr_pascr => 'SCR - addizione passiva';
+
+  @override
+  String get attrChoice_unit_type_scr_escr => 'SCR - controllo elettronico';
+
+  @override
+  String get attrChoice_mount_configuration_back => 'Montaggio dorsale';
+
+  @override
+  String get attrChoice_mount_configuration_chest => 'Montaggio frontale';
+
+  @override
+  String get attrChoice_mount_configuration_sidemount => 'Sidemount';
+
+  @override
+  String get attrChoice_scrubber_type_axial => 'Assiale';
+
+  @override
+  String get attrChoice_scrubber_type_radial => 'Radiale';
+
   @override
   String get attrChoice_suit_style_full => 'Muta intera';
 
diff --git a/lib/l10n/arb/app_localizations_nl.dart b/lib/l10n/arb/app_localizations_nl.dart
index df4a9f6d4b..361e1e90cb 100644
--- a/lib/l10n/arb/app_localizations_nl.dart
+++ b/lib/l10n/arb/app_localizations_nl.dart
@@ -21510,6 +21510,60 @@ class AppLocalizationsNl extends AppLocalizations {
   @override
   String get attrLabel_dry_weight_kg => 'Drooggewicht';
 
+  @override
+  String get attrLabel_unit_type => 'Type unit';
+
+  @override
+  String get attrLabel_mount_configuration => 'Montage';
+
+  @override
+  String get attrLabel_scrubber_type => 'Type scrubber';
+
+  @override
+  String get attrLabel_scrubber_duration_h => 'Scrubberduur (u)';
+
+  @override
+  String get attrLabel_o2_cell_count => 'O2-cellen';
+
+  @override
+  String get attrLabel_diluent_cylinder_l => 'Diluentfles';
+
+  @override
+  String get attrLabel_o2_cylinder_l => 'O2-fles';
+
+  @override
+  String get attrChoice_unit_type_eccr => 'Elektronische CCR (eCCR)';
+
+  @override
+  String get attrChoice_unit_type_mccr => 'Handmatige CCR (mCCR)';
+
+  @override
+  String get attrChoice_unit_type_hccr => 'Hybride CCR (hCCR)';
+
+  @override
+  String get attrChoice_unit_type_scr_cmf => 'SCR - constante massastroom';
+
+  @override
+  String get attrChoice_unit_type_scr_pascr => 'SCR - passieve toevoeging';
+
+  @override
+  String get attrChoice_unit_type_scr_escr => 'SCR - elektronisch geregeld';
+
+  @override
+  String get attrChoice_mount_configuration_back => 'Rugmontage';
+
+  @override
+  String get attrChoice_mount_configuration_chest => 'Borstmontage';
+
+  @override
+  String get attrChoice_mount_configuration_sidemount => 'Sidemount';
+
+  @override
+  String get attrChoice_scrubber_type_axial => 'Axiaal';
+
+  @override
+  String get attrChoice_scrubber_type_radial => 'Radiaal';
+
   @override
   String get attrChoice_suit_style_full => 'Volledig pak';
 
diff --git a/lib/l10n/arb/app_localizations_pt.dart b/lib/l10n/arb/app_localizations_pt.dart
index bfbfb84b0c..d034180357 100644
--- a/lib/l10n/arb/app_localizations_pt.dart
+++ b/lib/l10n/arb/app_localizations_pt.dart
@@ -21680,6 +21680,60 @@ class AppLocalizationsPt extends AppLocalizations {
   @override
   String get attrLabel_dry_weight_kg => 'Peso seco';
 
+  @override
+  String get attrLabel_unit_type => 'Tipo de unidade';
+
+  @override
+  String get attrLabel_mount_configuration => 'Montagem';
+
+  @override
+  String get attrLabel_scrubber_type => 'Tipo de cal';
+
+  @override
+  String get attrLabel_scrubber_duration_h => 'Duração da cal (h)';
+
+  @override
+  String get attrLabel_o2_cell_count => 'Células de O2';
+
+  @override
+  String get attrLabel_diluent_cylinder_l => 'Cilindro de diluente';
+
+  @override
+  String get attrLabel_o2_cylinder_l => 'Cilindro de O2';
+
+  @override
+  String get attrChoice_unit_type_eccr => 'CCR eletrónico (eCCR)';
+
+  @override
+  String get attrChoice_unit_type_mccr => 'CCR manual (mCCR)';
+
+  @override
+  String get attrChoice_unit_type_hccr => 'CCR híbrido (hCCR)';
+
+  @override
+  String get attrChoice_unit_type_scr_cmf => 'SCR - fluxo mássico constante';
+
+  @override
+  String get attrChoice_unit_type_scr_pascr => 'SCR - adição passiva';
+
+  @override
+  String get attrChoice_unit_type_scr_escr => 'SCR - controlo eletrónico';
+
+  @override
+  String get attrChoice_mount_configuration_back => 'Montagem dorsal';
+
+  @override
+  String get attrChoice_mount_configuration_chest => 'Montagem frontal';
+
+  @override
+  String get attrChoice_mount_configuration_sidemount => 'Sidemount';
+
+  @override
+  String get attrChoice_scrubber_type_axial => 'Axial';
+
+  @override
+  String get attrChoice_scrubber_type_radial => 'Radial';
+
   @override
   String get attrChoice_suit_style_full => 'Roupa inteira';
 
diff --git a/lib/l10n/arb/app_localizations_zh.dart b/lib/l10n/arb/app_localizations_zh.dart
index 9557e9c2ce..adb5cc278f 100644
--- a/lib/l10n/arb/app_localizations_zh.dart
+++ b/lib/l10n/arb/app_localizations_zh.dart
@@ -20585,6 +20585,60 @@ class AppLocalizationsZh extends AppLocalizations {
   @override
   String get attrLabel_dry_weight_kg => '干重';
 
+  @override
+  String get attrLabel_unit_type => '设备类型';
+
+  @override
+  String get attrLabel_mount_configuration => '安装方式';
+
+  @override
+  String get attrLabel_scrubber_type => '药罐类型';
+
+  @override
+  String get attrLabel_scrubber_duration_h => '药罐时长（小时）';
+
+  @override
+  String get attrLabel_o2_cell_count => '氧电池';
+
+  @override
+  String get attrLabel_diluent_cylinder_l => '稀释气瓶';
+
+  @override
+  String get attrLabel_o2_cylinder_l => 'O2 气瓶';
+
+  @override
+  String get attrChoice_unit_type_eccr => '电子式 CCR (eCCR)';
+
+  @override
+  String get attrChoice_unit_type_mccr => '手动式 CCR (mCCR)';
+
+  @override
+  String get attrChoice_unit_type_hccr => '混合式 CCR (hCCR)';
+
+  @override
+  String get attrChoice_unit_type_scr_cmf => 'SCR - 恒定质量流量';
+
+  @override
+  String get attrChoice_unit_type_scr_pascr => 'SCR - 被动补气';
+
+  @override
+  String get attrChoice_unit_type_scr_escr => 'SCR - 电子控制';
+
+  @override
+  String get attrChoice_mount_configuration_back => '背挂式';
+
+  @override
+  String get attrChoice_mount_configuration_chest => '胸挂式';
+
+  @override
+  String get attrChoice_mount_configuration_sidemount => '侧挂式';
+
+  @override
+  String get attrChoice_scrubber_type_axial => '轴向';
+
+  @override
+  String get attrChoice_scrubber_type_radial => '径向';
+
   @override
   String get attrChoice_suit_style_full => '全身湿衣';
 
diff --git a/lib/l10n/arb/app_nl.arb b/lib/l10n/arb/app_nl.arb
index 57a888ee2c..0962d8a271 100644
--- a/lib/l10n/arb/app_nl.arb
+++ b/lib/l10n/arb/app_nl.arb
@@ -6289,6 +6289,24 @@
   "attrLabel_sole_type": "Zool",
   "attrLabel_buoyancy_kg": "Drijfvermogen",
   "attrLabel_dry_weight_kg": "Drooggewicht",
+  "attrLabel_unit_type": "Type unit",
+  "attrLabel_mount_configuration": "Montage",
+  "attrLabel_scrubber_type": "Type scrubber",
+  "attrLabel_scrubber_duration_h": "Scrubberduur (u)",
+  "attrLabel_o2_cell_count": "O2-cellen",
+  "attrLabel_diluent_cylinder_l": "Diluentfles",
+  "attrLabel_o2_cylinder_l": "O2-fles",
+  "attrChoice_unit_type_eccr": "Elektronische CCR (eCCR)",
+  "attrChoice_unit_type_mccr": "Handmatige CCR (mCCR)",
+  "attrChoice_unit_type_hccr": "Hybride CCR (hCCR)",
+  "attrChoice_unit_type_scr_cmf": "SCR - constante massastroom",
+  "attrChoice_unit_type_scr_pascr": "SCR - passieve toevoeging",
+  "attrChoice_unit_type_scr_escr": "SCR - elektronisch geregeld",
+  "attrChoice_mount_configuration_back": "Rugmontage",
+  "attrChoice_mount_configuration_chest": "Borstmontage",
+  "attrChoice_mount_configuration_sidemount": "Sidemount",
+  "attrChoice_scrubber_type_axial": "Axiaal",
+  "attrChoice_scrubber_type_radial": "Radiaal",
   "attrChoice_suit_style_full": "Volledig pak",
   "attrChoice_suit_style_shorty": "Shorty",
   "attrChoice_suit_style_two_piece": "Tweedelig",
diff --git a/lib/l10n/arb/app_pt.arb b/lib/l10n/arb/app_pt.arb
index ac50183c2a..91afe9a717 100644
--- a/lib/l10n/arb/app_pt.arb
+++ b/lib/l10n/arb/app_pt.arb
@@ -6289,6 +6289,24 @@
   "attrLabel_sole_type": "Sola",
   "attrLabel_buoyancy_kg": "Flutuabilidade",
   "attrLabel_dry_weight_kg": "Peso seco",
+  "attrLabel_unit_type": "Tipo de unidade",
+  "attrLabel_mount_configuration": "Montagem",
+  "attrLabel_scrubber_type": "Tipo de cal",
+  "attrLabel_scrubber_duration_h": "Duração da cal (h)",
+  "attrLabel_o2_cell_count": "Células de O2",
+  "attrLabel_diluent_cylinder_l": "Cilindro de diluente",
+  "attrLabel_o2_cylinder_l": "Cilindro de O2",
+  "attrChoice_unit_type_eccr": "CCR eletrónico (eCCR)",
+  "attrChoice_unit_type_mccr": "CCR manual (mCCR)",
+  "attrChoice_unit_type_hccr": "CCR híbrido (hCCR)",
+  "attrChoice_unit_type_scr_cmf": "SCR - fluxo mássico constante",
+  "attrChoice_unit_type_scr_pascr": "SCR - adição passiva",
+  "attrChoice_unit_type_scr_escr": "SCR - controlo eletrónico",
+  "attrChoice_mount_configuration_back": "Montagem dorsal",
+  "attrChoice_mount_configuration_chest": "Montagem frontal",
+  "attrChoice_mount_configuration_sidemount": "Sidemount",
+  "attrChoice_scrubber_type_axial": "Axial",
+  "attrChoice_scrubber_type_radial": "Radial",
   "attrChoice_suit_style_full": "Roupa inteira",
   "attrChoice_suit_style_shorty": "Shorty",
   "attrChoice_suit_style_two_piece": "Duas peças",
diff --git a/lib/l10n/arb/app_zh.arb b/lib/l10n/arb/app_zh.arb
index b8dc0d98bc..51d39d354f 100644
--- a/lib/l10n/arb/app_zh.arb
+++ b/lib/l10n/arb/app_zh.arb
@@ -6289,6 +6289,24 @@
   "attrLabel_sole_type": "鞋底",
   "attrLabel_buoyancy_kg": "浮力",
   "attrLabel_dry_weight_kg": "干重",
+  "attrLabel_unit_type": "设备类型",
+  "attrLabel_mount_configuration": "安装方式",
+  "attrLabel_scrubber_type": "药罐类型",
+  "attrLabel_scrubber_duration_h": "药罐时长（小时）",
+  "attrLabel_o2_cell_count": "氧电池",
+  "attrLabel_diluent_cylinder_l": "稀释气瓶",
+  "attrLabel_o2_cylinder_l": "O2 气瓶",
+  "attrChoice_unit_type_eccr": "电子式 CCR (eCCR)",
+  "attrChoice_unit_type_mccr": "手动式 CCR (mCCR)",
+  "attrChoice_unit_type_hccr": "混合式 CCR (hCCR)",
+  "attrChoice_unit_type_scr_cmf": "SCR - 恒定质量流量",
+  "attrChoice_unit_type_scr_pascr": "SCR - 被动补气",
+  "attrChoice_unit_type_scr_escr": "SCR - 电子控制",
+  "attrChoice_mount_configuration_back": "背挂式",
+  "attrChoice_mount_configuration_chest": "胸挂式",
+  "attrChoice_mount_configuration_sidemount": "侧挂式",
+  "attrChoice_scrubber_type_axial": "轴向",
+  "attrChoice_scrubber_type_radial": "径向",
   "attrChoice_suit_style_full": "全身湿衣",
   "attrChoice_suit_style_shorty": "短款湿衣",
   "attrChoice_suit_style_two_piece": "两件式",
diff --git a/test/features/equipment/domain/equipment_attribute_catalog_test.dart b/test/features/equipment/domain/equipment_attribute_catalog_test.dart
index 1c2884846a..41656335ab 100644
--- a/test/features/equipment/domain/equipment_attribute_catalog_test.dart
+++ b/test/features/equipment/domain/equipment_attribute_catalog_test.dart
@@ -1,6 +1,9 @@
+import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:submersion/core/constants/enums.dart';
 import 'package:submersion/features/equipment/domain/constants/equipment_attribute_catalog.dart';
+import 'package:submersion/features/equipment/presentation/utils/equipment_attribute_l10n.dart';
+import 'package:submersion/l10n/arb/app_localizations.dart';
 
 void main() {
   test('every equipment type resolves to a definition list', () {
@@ -178,5 +181,42 @@ void main() {
       expect(def!.kind, AttributeKind.number);
       expect(def.dimension, AttributeDimension.none);
     });
+
+    testWidgets('every rebreather attribute and choice resolves to a label', (
+      tester,
+    ) async {
+      late AppLocalizations l10n;
+      await tester.pumpWidget(
+        MaterialApp(
+          locale: const Locale('en'),
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: Builder(
+            builder: (context) {
+              l10n = AppLocalizations.of(context);
+              return const SizedBox.shrink();
+            },
+          ),
+        ),
+      );
+
+      final defs = EquipmentAttributeCatalog.attributesFor(
+        EquipmentType.rebreather,
+      );
+      for (final def in defs) {
+        expect(
+          attributeLabel(l10n, def.key),
+          isNot(def.key),
+          reason: 'missing attrLabel_${def.key}',
+        );
+        for (final option in def.choiceKeys) {
+          expect(
+            attributeChoiceLabel(l10n, def.key, option),
+            isNot(option),
+            reason: 'missing attrChoice_${def.key}_$option',
+          );
+        }
+      }
+    });
   });
 }

From a3105df42b9f6e52f683650edb111fb3ab79a311 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 17:31:12 -0400
Subject: [PATCH 06/20] Add rebreather attribute persistence test (#804)

Round-trips a rebreather through createEquipment and back, asserting curated
attribute values and the deterministic attr_<id>_<key> id form. Passes without
production changes: the equipment_attributes table is type-agnostic, which is
what makes adding an equipment type a catalog change rather than a migration.
---
 .../equipment_attribute_repository_test.dart  | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/test/features/equipment/data/equipment_attribute_repository_test.dart b/test/features/equipment/data/equipment_attribute_repository_test.dart
index 5cb0da50e6..708906a2e7 100644
--- a/test/features/equipment/data/equipment_attribute_repository_test.dart
+++ b/test/features/equipment/data/equipment_attribute_repository_test.dart
@@ -127,4 +127,49 @@ void main() {
     final all = await repository.getAllEquipment();
     expect(all.single.thickness, '3');
   });
+
+  test('a rebreather persists and reloads its curated attributes', () async {
+    final created = await repository.createEquipment(
+      EquipmentItem(
+        id: '',
+        name: 'JJ-CCR',
+        type: EquipmentType.rebreather,
+        attributes: [
+          EquipmentAttribute.curated(
+            equipmentId: '',
+            key: 'unit_type',
+            valueText: 'eccr',
+          ),
+          EquipmentAttribute.curated(
+            equipmentId: '',
+            key: 'scrubber_duration_h',
+            valueNum: 3.0,
+          ),
+          EquipmentAttribute.curated(
+            equipmentId: '',
+            key: 'o2_cell_count',
+            valueNum: 3,
+          ),
+          EquipmentAttribute.curated(
+            equipmentId: '',
+            key: 'diluent_cylinder_l',
+            valueNum: 3.0,
+          ),
+        ],
+      ),
+    );
+
+    final loaded = await repository.getEquipmentById(created.id);
+    expect(loaded, isNotNull);
+    expect(loaded!.type, EquipmentType.rebreather);
+    expect(loaded.attrText('unit_type'), 'eccr');
+    expect(loaded.attrNum('scrubber_duration_h'), 3.0);
+    expect(loaded.attrNum('o2_cell_count'), 3);
+    expect(loaded.attrNum('diluent_cylinder_l'), 3.0);
+
+    // Curated ids are deterministic so independent devices converge.
+    final unitType = loaded.attributes.firstWhere((a) => a.key == 'unit_type');
+    expect(unitType.id, 'attr_${created.id}_unit_type');
+    expect(unitType.isCustom, isFalse);
+  });
 }

From f59c968737fc58d80b922a11582d572a72bd9545 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 17:35:03 -0400
Subject: [PATCH 07/20] Allow built-in service kinds to declare hour intervals
 (#804)

kSeedBuiltInServiceKindsSql hardcoded NULL for default_interval_hours because
no built-in had ever needed one. Adds a positional hours column to the inline
SELECT so a kind can declare one. Pure refactor: a characterization test pins
all nine existing kinds, including that every one keeps a null hours interval.
---
 lib/core/database/database.dart               | 20 +++++-----
 .../database/service_ledger_schema_test.dart  | 37 +++++++++++++++++++
 2 files changed, 47 insertions(+), 10 deletions(-)

diff --git a/lib/core/database/database.dart b/lib/core/database/database.dart
index 603dcd63a1..e056b386f5 100644
--- a/lib/core/database/database.dart
+++ b/lib/core/database/database.dart
@@ -2116,26 +2116,26 @@ const String kSeedBuiltInServiceKindsSql = '''
     (id, diver_id, name, applicable_types, default_interval_days,
      default_interval_dives, default_interval_hours, auto_attach,
      is_built_in, created_at, updated_at)
-  SELECT t.id, NULL, t.name, t.types, t.days, t.dives, NULL, t.auto, 1,
+  SELECT t.id, NULL, t.name, t.types, t.days, t.dives, t.hours, t.auto, 1,
          n.now_ms, n.now_ms
   FROM (
     SELECT 'hydro' AS id, 'Hydrostatic test' AS name, '["tank"]' AS types,
-           1825 AS days, NULL AS dives, 1 AS auto
+           1825 AS days, NULL AS dives, NULL AS hours, 1 AS auto
     UNION ALL SELECT 'vip', 'Visual inspection (VIP)', '["tank"]',
-           365, NULL, 1
-    UNION ALL SELECT 'o2-clean', 'O2 clean', '["tank"]', 365, NULL, 0
+           365, NULL, NULL, 1
+    UNION ALL SELECT 'o2-clean', 'O2 clean', '["tank"]', 365, NULL, NULL, 0
     UNION ALL SELECT 'regulator-service', 'Regulator service',
-           '["regulator"]', 365, 100, 1
+           '["regulator"]', 365, 100, NULL, 1
     UNION ALL SELECT 'computer-battery', 'Computer battery', '["computer"]',
-           730, NULL, 1
+           730, NULL, NULL, 1
     UNION ALL SELECT 'transmitter-battery', 'Transmitter battery',
-           '["transmitter"]', 365, NULL, 1
+           '["transmitter"]', 365, NULL, NULL, 1
     UNION ALL SELECT 'bcd-inspection', 'BCD/wing inspection', '["bcd"]',
-           365, NULL, 1
+           365, NULL, NULL, 1
     UNION ALL SELECT 'drysuit-seals', 'Drysuit seals', '["drysuit"]',
-           730, NULL, 0
+           730, NULL, NULL, 0
     UNION ALL SELECT 'general-service', 'General service', '[]',
-           NULL, NULL, 0
+           NULL, NULL, NULL, 0
   ) t
   CROSS JOIN (SELECT CAST(strftime('%s','now') AS INTEGER) * 1000 AS now_ms) n
 ''';
diff --git a/test/core/database/service_ledger_schema_test.dart b/test/core/database/service_ledger_schema_test.dart
index 12f507d0b5..8092acb4d7 100644
--- a/test/core/database/service_ledger_schema_test.dart
+++ b/test/core/database/service_ledger_schema_test.dart
@@ -25,6 +25,43 @@ void main() {
     expect(reg.defaultIntervalDives, 100);
   });
 
+  test('pre-existing built-in kinds keep null hour intervals', () async {
+    // Characterization: pins the current seed so adding an hours column to
+    // kSeedBuiltInServiceKindsSql cannot silently shift a positional value.
+    final kinds = await db.select(db.serviceKinds).get();
+    final byId = {for (final k in kinds) k.id: k};
+
+    expect(
+      byId.keys,
+      containsAll(<String>[
+        'hydro',
+        'vip',
+        'o2-clean',
+        'regulator-service',
+        'computer-battery',
+        'transmitter-battery',
+        'bcd-inspection',
+        'drysuit-seals',
+        'general-service',
+      ]),
+    );
+
+    for (final id in byId.keys) {
+      expect(
+        byId[id]!.defaultIntervalHours,
+        isNull,
+        reason: '$id must not gain an hours interval',
+      );
+    }
+
+    expect(byId['vip']!.defaultIntervalDays, 365);
+    expect(byId['o2-clean']!.autoAttach, isFalse);
+    expect(byId['drysuit-seals']!.defaultIntervalDays, 730);
+    expect(byId['general-service']!.defaultIntervalDays, isNull);
+    expect(byId['general-service']!.defaultIntervalDives, isNull);
+    expect(byId['general-service']!.applicableTypes, '[]');
+  });
+
   test(
     'service_schedules round-trips and cascades on equipment delete',
     () async {

From 2ffcf793f9d1d3b3ed3b461c39665faeb9877553 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 17:38:04 -0400
Subject: [PATCH 08/20] Seed rebreather service kinds for scrubber, cells, and
 annual (#804)

Three built-ins with applicable_types ["rebreather"]: scrubber-repack on a
3.0 hour clock, o2-cell-replacement and rebreather-annual on 365 days.
Scrubber repack is the first built-in with an hours-only interval, because a
scrubber is consumed by loop time rather than the calendar.

ServiceDueEngine needs no changes: it already computes hours-since-anchor from
logged dive duration. No migration either, since the seed runs from onCreate
and the v122 beforeOpen backstop and is INSERT OR IGNORE.

Three count tripwires updated from 9 to 12 (schema, repository, and provider
tests).
---
 lib/core/database/database.dart               | 10 +++
 .../database/service_ledger_schema_test.dart  | 90 +++++++++++++++----
 .../data/service_kind_repository_test.dart    | 12 ++-
 .../service_clock_providers_test.dart         |  2 +-
 4 files changed, 95 insertions(+), 19 deletions(-)

diff --git a/lib/core/database/database.dart b/lib/core/database/database.dart
index e056b386f5..af603e41ef 100644
--- a/lib/core/database/database.dart
+++ b/lib/core/database/database.dart
@@ -2134,6 +2134,16 @@ const String kSeedBuiltInServiceKindsSql = '''
            365, NULL, NULL, 1
     UNION ALL SELECT 'drysuit-seals', 'Drysuit seals', '["drysuit"]',
            730, NULL, NULL, 0
+    -- A scrubber is consumed by loop time, not by the calendar, so this is
+    -- the only built-in with an hours-only clock. 3.0 h is conservative
+    -- across the 2-6 h range real units are rated for; the diver overrides
+    -- it per unit via ServiceSchedule.intervalHours.
+    UNION ALL SELECT 'scrubber-repack', 'Scrubber repack', '["rebreather"]',
+           NULL, NULL, 3.0, 1
+    UNION ALL SELECT 'o2-cell-replacement', 'O2 cell replacement',
+           '["rebreather"]', 365, NULL, NULL, 1
+    UNION ALL SELECT 'rebreather-annual', 'Rebreather annual service',
+           '["rebreather"]', 365, NULL, NULL, 1
     UNION ALL SELECT 'general-service', 'General service', '[]',
            NULL, NULL, NULL, 0
   ) t
diff --git a/test/core/database/service_ledger_schema_test.dart b/test/core/database/service_ledger_schema_test.dart
index 8092acb4d7..f4c7ee0e8b 100644
--- a/test/core/database/service_ledger_schema_test.dart
+++ b/test/core/database/service_ledger_schema_test.dart
@@ -16,7 +16,7 @@ void main() {
 
   test('built-in kinds are seeded on fresh install', () async {
     final kinds = await db.select(db.serviceKinds).get();
-    expect(kinds.length, 9);
+    expect(kinds.length, 12);
     expect(kinds.every((k) => k.isBuiltIn), isTrue);
     final hydro = kinds.firstWhere((k) => k.id == 'hydro');
     expect(hydro.defaultIntervalDays, 1825);
@@ -28,25 +28,24 @@ void main() {
   test('pre-existing built-in kinds keep null hour intervals', () async {
     // Characterization: pins the current seed so adding an hours column to
     // kSeedBuiltInServiceKindsSql cannot silently shift a positional value.
+    const preExisting = <String>[
+      'hydro',
+      'vip',
+      'o2-clean',
+      'regulator-service',
+      'computer-battery',
+      'transmitter-battery',
+      'bcd-inspection',
+      'drysuit-seals',
+      'general-service',
+    ];
+
     final kinds = await db.select(db.serviceKinds).get();
     final byId = {for (final k in kinds) k.id: k};
 
-    expect(
-      byId.keys,
-      containsAll(<String>[
-        'hydro',
-        'vip',
-        'o2-clean',
-        'regulator-service',
-        'computer-battery',
-        'transmitter-battery',
-        'bcd-inspection',
-        'drysuit-seals',
-        'general-service',
-      ]),
-    );
+    expect(byId.keys, containsAll(preExisting));
 
-    for (final id in byId.keys) {
+    for (final id in preExisting) {
       expect(
         byId[id]!.defaultIntervalHours,
         isNull,
@@ -62,6 +61,65 @@ void main() {
     expect(byId['general-service']!.applicableTypes, '[]');
   });
 
+  test('rebreather built-in kinds seed with the expected clocks', () async {
+    final kinds = await db.select(db.serviceKinds).get();
+    final byId = {
+      for (final k in kinds)
+        if (const [
+          'scrubber-repack',
+          'o2-cell-replacement',
+          'rebreather-annual',
+        ].contains(k.id))
+          k.id: k,
+    };
+
+    expect(byId.length, 3);
+
+    final scrubber = byId['scrubber-repack']!;
+    expect(scrubber.defaultIntervalHours, 3.0);
+    expect(scrubber.defaultIntervalDays, isNull);
+    expect(scrubber.defaultIntervalDives, isNull);
+    expect(scrubber.autoAttach, isTrue);
+
+    final cells = byId['o2-cell-replacement']!;
+    expect(cells.defaultIntervalDays, 365);
+    expect(cells.defaultIntervalHours, isNull);
+
+    expect(byId['rebreather-annual']!.defaultIntervalDays, 365);
+
+    for (final kind in byId.values) {
+      expect(kind.applicableTypes, '["rebreather"]', reason: kind.id);
+      expect(kind.isBuiltIn, isTrue, reason: kind.id);
+    }
+  });
+
+  test('re-running the built-in seed is a no-op', () async {
+    await db.customStatement(kSeedBuiltInServiceKindsSql);
+    await db.customStatement(kSeedBuiltInServiceKindsSql);
+
+    final kinds = await db.select(db.serviceKinds).get();
+    final scrubbers = kinds.where((k) => k.id == 'scrubber-repack');
+    expect(scrubbers.length, 1);
+  });
+
+  test(
+    'a database missing a rebreather kind regains it from the seed',
+    () async {
+      // The seed already runs from onCreate and the v122 beforeOpen backstop,
+      // so an upgraded database picks the new kinds up without a migration.
+      await db.customStatement(
+        "DELETE FROM service_kinds WHERE id = 'scrubber-repack'",
+      );
+      var kinds = await db.select(db.serviceKinds).get();
+      expect(kinds.where((k) => k.id == 'scrubber-repack'), isEmpty);
+
+      await db.customStatement(kSeedBuiltInServiceKindsSql);
+
+      kinds = await db.select(db.serviceKinds).get();
+      expect(kinds.where((k) => k.id == 'scrubber-repack'), hasLength(1));
+    },
+  );
+
   test(
     'service_schedules round-trips and cascades on equipment delete',
     () async {
diff --git a/test/features/equipment/data/service_kind_repository_test.dart b/test/features/equipment/data/service_kind_repository_test.dart
index 54deeef3e2..7953aaea4a 100644
--- a/test/features/equipment/data/service_kind_repository_test.dart
+++ b/test/features/equipment/data/service_kind_repository_test.dart
@@ -17,13 +17,21 @@ void main() {
     await tearDownTestDatabase();
   });
 
-  test('getAllKinds returns the 9 built-ins', () async {
+  test('getAllKinds returns the 12 built-ins', () async {
     final kinds = await repo.getAllKinds();
-    expect(kinds.length, 9);
+    expect(kinds.length, 12);
     expect(kinds.every((k) => k.isBuiltIn), isTrue);
     final hydro = kinds.firstWhere((k) => k.id == 'hydro');
     expect(hydro.applicableTypes, [EquipmentType.tank]);
     expect(hydro.defaultIntervalDays, 1825);
+
+    // applicable_types round-trips through the repository for the rebreather
+    // kinds too, so they surface on a rebreather's clock picker.
+    final scrubber = kinds.firstWhere((k) => k.id == 'scrubber-repack');
+    expect(scrubber.applicableTypes, [EquipmentType.rebreather]);
+    expect(scrubber.defaultIntervalHours, 3.0);
+    expect(scrubber.appliesTo(EquipmentType.rebreather), isTrue);
+    expect(scrubber.appliesTo(EquipmentType.tank), isFalse);
   });
 
   test('custom kind CRUD; built-ins are protected', () async {
diff --git a/test/features/equipment/presentation/providers/service_clock_providers_test.dart b/test/features/equipment/presentation/providers/service_clock_providers_test.dart
index 2ca6f7352b..5293c15a92 100644
--- a/test/features/equipment/presentation/providers/service_clock_providers_test.dart
+++ b/test/features/equipment/presentation/providers/service_clock_providers_test.dart
@@ -165,7 +165,7 @@ void main() {
     addTearDown(container.dispose);
 
     final kinds = await container.read(serviceKindsProvider.future);
-    expect(kinds.where((k) => k.isBuiltIn).length, 9);
+    expect(kinds.where((k) => k.isBuiltIn).length, 12);
   });
 
   test('tripServiceAlertsProvider gates on trip end date', () async {

From 73c0c45e0c70f69f7ee8d711b698370e365edc14 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 17:40:31 -0400
Subject: [PATCH 09/20] Caption hours-based service clocks with their data
 source (#804)

ServiceDueEngine accrues hours-based clocks by summing logged dive duration,
which approximates rebreather loop time but excludes pre-breathe and surface
loop time. The scrubber clock is the first built-in where that distinction
reaches a diver, so the card now states what the number counts instead of
leaving it to be inferred.

Renders only when a clock has an hours trigger; date-only clocks are
unchanged.
---
 .../widgets/service_clocks_card.dart          |  23 +++-
 lib/l10n/arb/app_ar.arb                       |   1 +
 lib/l10n/arb/app_de.arb                       |   1 +
 lib/l10n/arb/app_en.arb                       |   1 +
 lib/l10n/arb/app_es.arb                       |   1 +
 lib/l10n/arb/app_fr.arb                       |   1 +
 lib/l10n/arb/app_he.arb                       |   1 +
 lib/l10n/arb/app_hu.arb                       |   1 +
 lib/l10n/arb/app_it.arb                       |   1 +
 lib/l10n/arb/app_localizations.dart           |   6 +
 lib/l10n/arb/app_localizations_ar.dart        |   3 +
 lib/l10n/arb/app_localizations_de.dart        |   4 +
 lib/l10n/arb/app_localizations_en.dart        |   4 +
 lib/l10n/arb/app_localizations_es.dart        |   4 +
 lib/l10n/arb/app_localizations_fr.dart        |   4 +
 lib/l10n/arb/app_localizations_he.dart        |   3 +
 lib/l10n/arb/app_localizations_hu.dart        |   4 +
 lib/l10n/arb/app_localizations_it.dart        |   4 +
 lib/l10n/arb/app_localizations_nl.dart        |   4 +
 lib/l10n/arb/app_localizations_pt.dart        |   4 +
 lib/l10n/arb/app_localizations_zh.dart        |   3 +
 lib/l10n/arb/app_nl.arb                       |   1 +
 lib/l10n/arb/app_pt.arb                       |   1 +
 lib/l10n/arb/app_zh.arb                       |   1 +
 .../service_clocks_hours_caption_test.dart    | 118 ++++++++++++++++++
 25 files changed, 198 insertions(+), 1 deletion(-)
 create mode 100644 test/features/equipment/presentation/widgets/service_clocks_hours_caption_test.dart

diff --git a/lib/features/equipment/presentation/widgets/service_clocks_card.dart b/lib/features/equipment/presentation/widgets/service_clocks_card.dart
index d405e1b89e..92f254d87f 100644
--- a/lib/features/equipment/presentation/widgets/service_clocks_card.dart
+++ b/lib/features/equipment/presentation/widgets/service_clocks_card.dart
@@ -158,7 +158,28 @@ class ServiceClocksCard extends ConsumerWidget {
                           color: _dotColor(context, status.severity),
                         ),
                         title: Text(status.kind.name),
-                        subtitle: Text(_triggerText(context, status)),
+                        subtitle: Column(
+                          crossAxisAlignment: CrossAxisAlignment.start,
+                          mainAxisSize: MainAxisSize.min,
+                          children: [
+                            Text(_triggerText(context, status)),
+                            // An hours clock accrues from logged dive
+                            // duration, which approximates but is not
+                            // identical to rebreather loop time. Say so
+                            // rather than leaving a diver to infer it from a
+                            // scrubber budget.
+                            if (status.hoursRemaining != null)
+                              Text(
+                                l10n.equipment_serviceClocks_hoursSource,
+                                style: Theme.of(context).textTheme.bodySmall
+                                    ?.copyWith(
+                                      color: Theme.of(
+                                        context,
+                                      ).colorScheme.onSurfaceVariant,
+                                    ),
+                              ),
+                          ],
+                        ),
                         trailing: PopupMenuButton<String>(
                           onSelected: (action) =>
                               _onAction(context, ref, action, status),
diff --git a/lib/l10n/arb/app_ar.arb b/lib/l10n/arb/app_ar.arb
index ff6b50c55f..ef7fd62153 100644
--- a/lib/l10n/arb/app_ar.arb
+++ b/lib/l10n/arb/app_ar.arb
@@ -3218,6 +3218,7 @@
   "equipment_serviceClocks_overdueSince": "متأخر منذ {date}",
   "equipment_serviceClocks_overdue": "متأخر",
   "equipment_serviceClocks_divesLeft": "متبقٍ {remaining} من {total} غوصة",
+  "equipment_serviceClocks_hoursSource": "محسوب من زمن الغوص المسجل",
   "equipment_serviceClocks_hoursLeft": "متبقٍ {remaining} من {total} ساعة",
   "equipment_serviceClocks_manageKinds": "إدارة أنواع الصيانة",
   "equipment_serviceClocks_appliesToClock": "ينطبق على العداد",
diff --git a/lib/l10n/arb/app_de.arb b/lib/l10n/arb/app_de.arb
index f79e4e027b..b5bfe68e06 100644
--- a/lib/l10n/arb/app_de.arb
+++ b/lib/l10n/arb/app_de.arb
@@ -3218,6 +3218,7 @@
   "equipment_serviceClocks_overdueSince": "Überfällig seit {date}",
   "equipment_serviceClocks_overdue": "Überfällig",
   "equipment_serviceClocks_divesLeft": "{remaining} von {total} Tauchgängen übrig",
+  "equipment_serviceClocks_hoursSource": "Aus der protokollierten Tauchzeit berechnet",
   "equipment_serviceClocks_hoursLeft": "{remaining} von {total} Stunden übrig",
   "equipment_serviceClocks_manageKinds": "Wartungsarten verwalten",
   "equipment_serviceClocks_appliesToClock": "Zugehöriges Intervall",
diff --git a/lib/l10n/arb/app_en.arb b/lib/l10n/arb/app_en.arb
index f8aeb2a75f..230e137db9 100644
--- a/lib/l10n/arb/app_en.arb
+++ b/lib/l10n/arb/app_en.arb
@@ -5708,6 +5708,7 @@
       }
     }
   },
+  "equipment_serviceClocks_hoursSource": "Counted from logged dive time",
   "equipment_serviceClocks_hoursLeft": "{remaining} of {total} hours left",
   "@equipment_serviceClocks_hoursLeft": {
     "placeholders": {
diff --git a/lib/l10n/arb/app_es.arb b/lib/l10n/arb/app_es.arb
index 88a3a7b5df..772028c15c 100644
--- a/lib/l10n/arb/app_es.arb
+++ b/lib/l10n/arb/app_es.arb
@@ -3218,6 +3218,7 @@
   "equipment_serviceClocks_overdueSince": "Vencido desde el {date}",
   "equipment_serviceClocks_overdue": "Vencido",
   "equipment_serviceClocks_divesLeft": "Quedan {remaining} de {total} inmersiones",
+  "equipment_serviceClocks_hoursSource": "Calculado a partir del tiempo de buceo registrado",
   "equipment_serviceClocks_hoursLeft": "Quedan {remaining} de {total} horas",
   "equipment_serviceClocks_manageKinds": "Gestionar tipos de mantenimiento",
   "equipment_serviceClocks_appliesToClock": "Se aplica al intervalo",
diff --git a/lib/l10n/arb/app_fr.arb b/lib/l10n/arb/app_fr.arb
index cb7523d375..3cbce94eb9 100644
--- a/lib/l10n/arb/app_fr.arb
+++ b/lib/l10n/arb/app_fr.arb
@@ -3146,6 +3146,7 @@
   "equipment_serviceClocks_overdueSince": "En retard depuis le {date}",
   "equipment_serviceClocks_overdue": "En retard",
   "equipment_serviceClocks_divesLeft": "{remaining} plongées restantes sur {total}",
+  "equipment_serviceClocks_hoursSource": "Calculé à partir du temps de plongée enregistré",
   "equipment_serviceClocks_hoursLeft": "{remaining} heures restantes sur {total}",
   "equipment_serviceClocks_manageKinds": "Gérer les types d'entretien",
   "equipment_serviceClocks_appliesToClock": "S'applique au compteur",
diff --git a/lib/l10n/arb/app_he.arb b/lib/l10n/arb/app_he.arb
index ff38efa48b..eee8faa066 100644
--- a/lib/l10n/arb/app_he.arb
+++ b/lib/l10n/arb/app_he.arb
@@ -3146,6 +3146,7 @@
   "equipment_serviceClocks_overdueSince": "באיחור מאז {date}",
   "equipment_serviceClocks_overdue": "באיחור",
   "equipment_serviceClocks_divesLeft": "נותרו {remaining} מתוך {total} צלילות",
+  "equipment_serviceClocks_hoursSource": "מחושב מזמן הצלילה המתועד",
   "equipment_serviceClocks_hoursLeft": "נותרו {remaining} מתוך {total} שעות",
   "equipment_serviceClocks_manageKinds": "ניהול סוגי טיפול",
   "equipment_serviceClocks_appliesToClock": "חל על שעון",
diff --git a/lib/l10n/arb/app_hu.arb b/lib/l10n/arb/app_hu.arb
index 6248d3099b..ff5c01dbca 100644
--- a/lib/l10n/arb/app_hu.arb
+++ b/lib/l10n/arb/app_hu.arb
@@ -3146,6 +3146,7 @@
   "equipment_serviceClocks_overdueSince": "{date} óta esedékes",
   "equipment_serviceClocks_overdue": "Lejárt",
   "equipment_serviceClocks_divesLeft": "{remaining} / {total} merülés van hátra",
+  "equipment_serviceClocks_hoursSource": "A naplózott merülési idő alapján számolva",
   "equipment_serviceClocks_hoursLeft": "{remaining} / {total} óra van hátra",
   "equipment_serviceClocks_manageKinds": "Szerviztípusok kezelése",
   "equipment_serviceClocks_appliesToClock": "Kapcsolódó intervallum",
diff --git a/lib/l10n/arb/app_it.arb b/lib/l10n/arb/app_it.arb
index 77041082ea..08019e0616 100644
--- a/lib/l10n/arb/app_it.arb
+++ b/lib/l10n/arb/app_it.arb
@@ -3146,6 +3146,7 @@
   "equipment_serviceClocks_overdueSince": "In ritardo dal {date}",
   "equipment_serviceClocks_overdue": "In ritardo",
   "equipment_serviceClocks_divesLeft": "{remaining} immersioni rimanenti su {total}",
+  "equipment_serviceClocks_hoursSource": "Calcolato dal tempo di immersione registrato",
   "equipment_serviceClocks_hoursLeft": "{remaining} ore rimanenti su {total}",
   "equipment_serviceClocks_manageKinds": "Gestisci tipi di manutenzione",
   "equipment_serviceClocks_appliesToClock": "Si applica alla scadenza",
diff --git a/lib/l10n/arb/app_localizations.dart b/lib/l10n/arb/app_localizations.dart
index 08bda315e2..68ea895cba 100644
--- a/lib/l10n/arb/app_localizations.dart
+++ b/lib/l10n/arb/app_localizations.dart
@@ -17427,6 +17427,12 @@ abstract class AppLocalizations {
   /// **'{remaining} of {total} dives left'**
   String equipment_serviceClocks_divesLeft(int remaining, int total);
 
+  /// No description provided for @equipment_serviceClocks_hoursSource.
+  ///
+  /// In en, this message translates to:
+  /// **'Counted from logged dive time'**
+  String get equipment_serviceClocks_hoursSource;
+
   /// No description provided for @equipment_serviceClocks_hoursLeft.
   ///
   /// In en, this message translates to:
diff --git a/lib/l10n/arb/app_localizations_ar.dart b/lib/l10n/arb/app_localizations_ar.dart
index 2ae502d297..ef16274db3 100644
--- a/lib/l10n/arb/app_localizations_ar.dart
+++ b/lib/l10n/arb/app_localizations_ar.dart
@@ -10014,6 +10014,9 @@ class AppLocalizationsAr extends AppLocalizations {
     return 'متبقٍ $remaining من $total غوصة';
   }
 
+  @override
+  String get equipment_serviceClocks_hoursSource => 'محسوب من زمن الغوص المسجل';
+
   @override
   String equipment_serviceClocks_hoursLeft(String remaining, String total) {
     return 'متبقٍ $remaining من $total ساعة';
diff --git a/lib/l10n/arb/app_localizations_de.dart b/lib/l10n/arb/app_localizations_de.dart
index a51f4c89c3..c53263f998 100644
--- a/lib/l10n/arb/app_localizations_de.dart
+++ b/lib/l10n/arb/app_localizations_de.dart
@@ -10188,6 +10188,10 @@ class AppLocalizationsDe extends AppLocalizations {
     return '$remaining von $total Tauchgängen übrig';
   }
 
+  @override
+  String get equipment_serviceClocks_hoursSource =>
+      'Aus der protokollierten Tauchzeit berechnet';
+
   @override
   String equipment_serviceClocks_hoursLeft(String remaining, String total) {
     return '$remaining von $total Stunden übrig';
diff --git a/lib/l10n/arb/app_localizations_en.dart b/lib/l10n/arb/app_localizations_en.dart
index 04971acaf4..f8682cb0c0 100644
--- a/lib/l10n/arb/app_localizations_en.dart
+++ b/lib/l10n/arb/app_localizations_en.dart
@@ -10035,6 +10035,10 @@ class AppLocalizationsEn extends AppLocalizations {
     return '$remaining of $total dives left';
   }
 
+  @override
+  String get equipment_serviceClocks_hoursSource =>
+      'Counted from logged dive time';
+
   @override
   String equipment_serviceClocks_hoursLeft(String remaining, String total) {
     return '$remaining of $total hours left';
diff --git a/lib/l10n/arb/app_localizations_es.dart b/lib/l10n/arb/app_localizations_es.dart
index ce26981096..7c9259c045 100644
--- a/lib/l10n/arb/app_localizations_es.dart
+++ b/lib/l10n/arb/app_localizations_es.dart
@@ -10186,6 +10186,10 @@ class AppLocalizationsEs extends AppLocalizations {
     return 'Quedan $remaining de $total inmersiones';
   }
 
+  @override
+  String get equipment_serviceClocks_hoursSource =>
+      'Calculado a partir del tiempo de buceo registrado';
+
   @override
   String equipment_serviceClocks_hoursLeft(String remaining, String total) {
     return 'Quedan $remaining de $total horas';
diff --git a/lib/l10n/arb/app_localizations_fr.dart b/lib/l10n/arb/app_localizations_fr.dart
index f2542ab4e9..cc418dbf8d 100644
--- a/lib/l10n/arb/app_localizations_fr.dart
+++ b/lib/l10n/arb/app_localizations_fr.dart
@@ -10218,6 +10218,10 @@ class AppLocalizationsFr extends AppLocalizations {
     return '$remaining plongées restantes sur $total';
   }
 
+  @override
+  String get equipment_serviceClocks_hoursSource =>
+      'Calculé à partir du temps de plongée enregistré';
+
   @override
   String equipment_serviceClocks_hoursLeft(String remaining, String total) {
     return '$remaining heures restantes sur $total';
diff --git a/lib/l10n/arb/app_localizations_he.dart b/lib/l10n/arb/app_localizations_he.dart
index 6f68ddae03..f5ab040d6b 100644
--- a/lib/l10n/arb/app_localizations_he.dart
+++ b/lib/l10n/arb/app_localizations_he.dart
@@ -9956,6 +9956,9 @@ class AppLocalizationsHe extends AppLocalizations {
     return 'נותרו $remaining מתוך $total צלילות';
   }
 
+  @override
+  String get equipment_serviceClocks_hoursSource => 'מחושב מזמן הצלילה המתועד';
+
   @override
   String equipment_serviceClocks_hoursLeft(String remaining, String total) {
     return 'נותרו $remaining מתוך $total שעות';
diff --git a/lib/l10n/arb/app_localizations_hu.dart b/lib/l10n/arb/app_localizations_hu.dart
index 7a78e2a973..5b62d9d19a 100644
--- a/lib/l10n/arb/app_localizations_hu.dart
+++ b/lib/l10n/arb/app_localizations_hu.dart
@@ -10167,6 +10167,10 @@ class AppLocalizationsHu extends AppLocalizations {
     return '$remaining / $total merülés van hátra';
   }
 
+  @override
+  String get equipment_serviceClocks_hoursSource =>
+      'A naplózott merülési idő alapján számolva';
+
   @override
   String equipment_serviceClocks_hoursLeft(String remaining, String total) {
     return '$remaining / $total óra van hátra';
diff --git a/lib/l10n/arb/app_localizations_it.dart b/lib/l10n/arb/app_localizations_it.dart
index b70ae368e6..03b8b7f4b4 100644
--- a/lib/l10n/arb/app_localizations_it.dart
+++ b/lib/l10n/arb/app_localizations_it.dart
@@ -10184,6 +10184,10 @@ class AppLocalizationsIt extends AppLocalizations {
     return '$remaining immersioni rimanenti su $total';
   }
 
+  @override
+  String get equipment_serviceClocks_hoursSource =>
+      'Calcolato dal tempo di immersione registrato';
+
   @override
   String equipment_serviceClocks_hoursLeft(String remaining, String total) {
     return '$remaining ore rimanenti su $total';
diff --git a/lib/l10n/arb/app_localizations_nl.dart b/lib/l10n/arb/app_localizations_nl.dart
index 361e1e90cb..e43972b9e4 100644
--- a/lib/l10n/arb/app_localizations_nl.dart
+++ b/lib/l10n/arb/app_localizations_nl.dart
@@ -10114,6 +10114,10 @@ class AppLocalizationsNl extends AppLocalizations {
     return '$remaining van $total duiken resterend';
   }
 
+  @override
+  String get equipment_serviceClocks_hoursSource =>
+      'Berekend op basis van geregistreerde duiktijd';
+
   @override
   String equipment_serviceClocks_hoursLeft(String remaining, String total) {
     return '$remaining van $total uur resterend';
diff --git a/lib/l10n/arb/app_localizations_pt.dart b/lib/l10n/arb/app_localizations_pt.dart
index d034180357..691ee1a786 100644
--- a/lib/l10n/arb/app_localizations_pt.dart
+++ b/lib/l10n/arb/app_localizations_pt.dart
@@ -10185,6 +10185,10 @@ class AppLocalizationsPt extends AppLocalizations {
     return 'Restam $remaining de $total mergulhos';
   }
 
+  @override
+  String get equipment_serviceClocks_hoursSource =>
+      'Calculado a partir do tempo de mergulho registado';
+
   @override
   String equipment_serviceClocks_hoursLeft(String remaining, String total) {
     return 'Restam $remaining de $total horas';
diff --git a/lib/l10n/arb/app_localizations_zh.dart b/lib/l10n/arb/app_localizations_zh.dart
index adb5cc278f..c792d41217 100644
--- a/lib/l10n/arb/app_localizations_zh.dart
+++ b/lib/l10n/arb/app_localizations_zh.dart
@@ -9747,6 +9747,9 @@ class AppLocalizationsZh extends AppLocalizations {
     return '剩余 $remaining/$total 次潜水';
   }
 
+  @override
+  String get equipment_serviceClocks_hoursSource => '根据已记录的潜水时间计算';
+
   @override
   String equipment_serviceClocks_hoursLeft(String remaining, String total) {
     return '剩余 $remaining/$total 小时';
diff --git a/lib/l10n/arb/app_nl.arb b/lib/l10n/arb/app_nl.arb
index 0962d8a271..860ad48515 100644
--- a/lib/l10n/arb/app_nl.arb
+++ b/lib/l10n/arb/app_nl.arb
@@ -3218,6 +3218,7 @@
   "equipment_serviceClocks_overdueSince": "Achterstallig sinds {date}",
   "equipment_serviceClocks_overdue": "Te laat",
   "equipment_serviceClocks_divesLeft": "{remaining} van {total} duiken resterend",
+  "equipment_serviceClocks_hoursSource": "Berekend op basis van geregistreerde duiktijd",
   "equipment_serviceClocks_hoursLeft": "{remaining} van {total} uur resterend",
   "equipment_serviceClocks_manageKinds": "Servicetypen beheren",
   "equipment_serviceClocks_appliesToClock": "Gekoppeld aan interval",
diff --git a/lib/l10n/arb/app_pt.arb b/lib/l10n/arb/app_pt.arb
index 91afe9a717..6d7bbf152f 100644
--- a/lib/l10n/arb/app_pt.arb
+++ b/lib/l10n/arb/app_pt.arb
@@ -3218,6 +3218,7 @@
   "equipment_serviceClocks_overdueSince": "Atrasado desde {date}",
   "equipment_serviceClocks_overdue": "Atrasado",
   "equipment_serviceClocks_divesLeft": "Restam {remaining} de {total} mergulhos",
+  "equipment_serviceClocks_hoursSource": "Calculado a partir do tempo de mergulho registado",
   "equipment_serviceClocks_hoursLeft": "Restam {remaining} de {total} horas",
   "equipment_serviceClocks_manageKinds": "Gerenciar tipos de manutenção",
   "equipment_serviceClocks_appliesToClock": "Aplica-se ao prazo",
diff --git a/lib/l10n/arb/app_zh.arb b/lib/l10n/arb/app_zh.arb
index 51d39d354f..6e1e991fb4 100644
--- a/lib/l10n/arb/app_zh.arb
+++ b/lib/l10n/arb/app_zh.arb
@@ -3360,6 +3360,7 @@
   "equipment_serviceClocks_overdueSince": "自 {date} 起逾期",
   "equipment_serviceClocks_overdue": "已逾期",
   "equipment_serviceClocks_divesLeft": "剩余 {remaining}/{total} 次潜水",
+  "equipment_serviceClocks_hoursSource": "根据已记录的潜水时间计算",
   "equipment_serviceClocks_hoursLeft": "剩余 {remaining}/{total} 小时",
   "equipment_serviceClocks_manageKinds": "管理维护类型",
   "equipment_serviceClocks_appliesToClock": "适用的倒计时",
diff --git a/test/features/equipment/presentation/widgets/service_clocks_hours_caption_test.dart b/test/features/equipment/presentation/widgets/service_clocks_hours_caption_test.dart
new file mode 100644
index 0000000000..8c86162dab
--- /dev/null
+++ b/test/features/equipment/presentation/widgets/service_clocks_hours_caption_test.dart
@@ -0,0 +1,118 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/core/providers/provider.dart';
+import 'package:submersion/features/equipment/domain/entities/service_clock_status.dart';
+import 'package:submersion/features/equipment/domain/entities/service_kind.dart';
+import 'package:submersion/features/equipment/domain/entities/service_schedule.dart';
+import 'package:submersion/features/equipment/presentation/providers/equipment_providers.dart';
+import 'package:submersion/features/equipment/presentation/widgets/service_clocks_card.dart';
+import 'package:submersion/l10n/arb/app_localizations.dart';
+
+/// ServiceDueEngine derives hours-based clocks by summing logged dive
+/// duration, which approximates rebreather loop time but excludes pre-breathe
+/// and surface loop time. A diver trusting a scrubber clock has to be told
+/// what it counts.
+void main() {
+  final t0 = DateTime(2025, 1, 1);
+  final now = DateTime(2026, 8, 5);
+
+  final scrubber = ServiceKind(
+    id: 'scrubber-repack',
+    name: 'Scrubber repack',
+    applicableTypes: const [EquipmentType.rebreather],
+    defaultIntervalHours: 3.0,
+    autoAttach: true,
+    isBuiltIn: true,
+    createdAt: t0,
+    updatedAt: t0,
+  );
+  final annual = ServiceKind(
+    id: 'rebreather-annual',
+    name: 'Rebreather annual service',
+    applicableTypes: const [EquipmentType.rebreather],
+    defaultIntervalDays: 365,
+    autoAttach: true,
+    isBuiltIn: true,
+    createdAt: t0,
+    updatedAt: t0,
+  );
+
+  ServiceSchedule sched(String kindId, {double? hours}) => ServiceSchedule(
+    id: 's-$kindId',
+    equipmentId: 'rb1',
+    serviceKindId: kindId,
+    intervalHours: hours,
+    createdAt: t0,
+    updatedAt: t0,
+  );
+
+  Widget buildCard({required bool includeHoursClock}) {
+    final statuses = <ServiceClockStatus>[
+      ServiceClockStatus(
+        schedule: sched('rebreather-annual'),
+        kind: annual,
+        anchor: t0,
+        dueDate: DateTime(2026, 12, 1),
+        severity: ServiceClockSeverity.ok,
+        now: now,
+      ),
+      if (includeHoursClock)
+        ServiceClockStatus(
+          schedule: sched('scrubber-repack', hours: 3.0),
+          kind: scrubber,
+          anchor: t0,
+          hoursSinceAnchor: 1.2,
+          hoursRemaining: 1.8,
+          severity: ServiceClockSeverity.ok,
+          now: now,
+        ),
+    ];
+
+    return ProviderScope(
+      overrides: [
+        serviceClockStatusesProvider(
+          'rb1',
+        ).overrideWith((ref) async => statuses),
+        serviceSchedulesForEquipmentProvider('rb1').overrideWith(
+          (ref) async => [
+            sched('rebreather-annual'),
+            if (includeHoursClock) sched('scrubber-repack', hours: 3.0),
+          ],
+        ),
+        serviceKindsProvider.overrideWith((ref) async => [scrubber, annual]),
+      ],
+      child: const MaterialApp(
+        locale: Locale('en'),
+        localizationsDelegates: AppLocalizations.localizationsDelegates,
+        supportedLocales: AppLocalizations.supportedLocales,
+        home: Scaffold(
+          body: SingleChildScrollView(
+            child: ServiceClocksCard(
+              equipmentId: 'rb1',
+              equipmentType: EquipmentType.rebreather,
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+
+  testWidgets('an hours-based clock captions where its hours come from', (
+    tester,
+  ) async {
+    await tester.pumpWidget(buildCard(includeHoursClock: true));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Scrubber repack'), findsOneWidget);
+    expect(find.text('Counted from logged dive time'), findsOneWidget);
+  });
+
+  testWidgets('a date-only clock shows no hours caption', (tester) async {
+    await tester.pumpWidget(buildCard(includeHoursClock: false));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Rebreather annual service'), findsOneWidget);
+    expect(find.text('Counted from logged dive time'), findsNothing);
+  });
+}

From e3434887e143e11e6bdebc1a27b6fe3da9165ea6 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 17:47:40 -0400
Subject: [PATCH 10/20] Add cylinder configuration domain entities (#804)

CylinderConfig is a named cylinder list, optionally owned by a rebreather via
a nullable equipmentId; null means a generic gas plan. CylinderConfigItem
snapshots the cylinder spec rather than referencing a tank preset, so editing
a preset later cannot rewrite what a saved configuration means.

Gas fractions are non-nullable and default to air, mirroring dive_tanks.
Timestamps are excluded from props so provider rebuilds stay stable.
---
 .../domain/entities/cylinder_config.dart      |  79 +++++++++++++
 .../domain/entities/cylinder_config_item.dart | 109 ++++++++++++++++++
 .../domain/entities/cylinder_config_test.dart | 102 ++++++++++++++++
 3 files changed, 290 insertions(+)
 create mode 100644 lib/features/cylinder_configs/domain/entities/cylinder_config.dart
 create mode 100644 lib/features/cylinder_configs/domain/entities/cylinder_config_item.dart
 create mode 100644 test/features/cylinder_configs/domain/entities/cylinder_config_test.dart

diff --git a/lib/features/cylinder_configs/domain/entities/cylinder_config.dart b/lib/features/cylinder_configs/domain/entities/cylinder_config.dart
new file mode 100644
index 0000000000..f6fb43406e
--- /dev/null
+++ b/lib/features/cylinder_configs/domain/entities/cylinder_config.dart
@@ -0,0 +1,79 @@
+import 'package:equatable/equatable.dart';
+
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+
+/// A named, reusable set of cylinders.
+///
+/// When [equipmentId] is set the config reads as "a configuration for this
+/// rebreather"; when null it is a generic gas plan any dive can use. The
+/// distinction is presentation only -- the two share one shape, which is why
+/// a technical open-circuit diver entering doubles plus two deco stages gets
+/// the same relief from re-entry tedium as a CCR diver.
+///
+/// Deleting the owning unit sets equipment_id null rather than cascading,
+/// demoting the config instead of destroying a painstakingly entered bailout
+/// plan.
+class CylinderConfig extends Equatable {
+  final String id;
+  final String? diverId;
+  final String? equipmentId;
+  final String name;
+  final String description;
+  final int sortOrder;
+  final List<CylinderConfigItem> items;
+  final DateTime createdAt;
+  final DateTime updatedAt;
+
+  const CylinderConfig({
+    required this.id,
+    this.diverId,
+    this.equipmentId,
+    required this.name,
+    this.description = '',
+    this.sortOrder = 0,
+    this.items = const [],
+    required this.createdAt,
+    required this.updatedAt,
+  });
+
+  bool get isOwnedByUnit => equipmentId != null;
+
+  int get cylinderCount => items.length;
+
+  CylinderConfig copyWith({
+    String? id,
+    String? diverId,
+    bool clearDiverId = false,
+    String? equipmentId,
+    bool clearEquipmentId = false,
+    String? name,
+    String? description,
+    int? sortOrder,
+    List<CylinderConfigItem>? items,
+    DateTime? createdAt,
+    DateTime? updatedAt,
+  }) => CylinderConfig(
+    id: id ?? this.id,
+    diverId: clearDiverId ? null : (diverId ?? this.diverId),
+    equipmentId: clearEquipmentId ? null : (equipmentId ?? this.equipmentId),
+    name: name ?? this.name,
+    description: description ?? this.description,
+    sortOrder: sortOrder ?? this.sortOrder,
+    items: items ?? this.items,
+    createdAt: createdAt ?? this.createdAt,
+    updatedAt: updatedAt ?? this.updatedAt,
+  );
+
+  /// Timestamps are excluded: they churn on every write and would defeat
+  /// Riverpod's equality-based rebuild suppression. Mirrors EquipmentSet.
+  @override
+  List<Object?> get props => [
+    id,
+    diverId,
+    equipmentId,
+    name,
+    description,
+    sortOrder,
+    items,
+  ];
+}
diff --git a/lib/features/cylinder_configs/domain/entities/cylinder_config_item.dart b/lib/features/cylinder_configs/domain/entities/cylinder_config_item.dart
new file mode 100644
index 0000000000..9bfa0c6797
--- /dev/null
+++ b/lib/features/cylinder_configs/domain/entities/cylinder_config_item.dart
@@ -0,0 +1,109 @@
+import 'package:equatable/equatable.dart';
+
+import 'package:submersion/core/constants/enums.dart';
+
+/// One cylinder in a reusable configuration.
+///
+/// The cylinder spec is a SNAPSHOT, not a reference. A tank preset may
+/// populate volume/pressure/material at edit time, but the config then owns
+/// those values and there is deliberately no foreign key back to
+/// tank_presets. A configuration records what the diver actually dives, so a
+/// later edit to a preset must not rewrite the meaning of a saved config.
+class CylinderConfigItem extends Equatable {
+  final String id;
+  final String configId;
+  final int sortOrder;
+
+  /// Free-text label such as "Bailout 1" or "AL80 EAN50". Maps to
+  /// dive_tanks.tank_name when the configuration is applied.
+  final String? label;
+
+  final TankRole tankRole;
+  final double? volumeL;
+  final double? workingPressureBar;
+  final TankMaterial? tankMaterial;
+
+  /// Gas fractions are never null: a cylinder always holds something, and
+  /// air is the sensible floor. This mirrors dive_tanks, where o2_percent
+  /// and he_percent carry non-null defaults.
+  final double o2Percent;
+  final double hePercent;
+
+  final double? defaultStartPressureBar;
+  final DateTime createdAt;
+  final DateTime updatedAt;
+
+  const CylinderConfigItem({
+    required this.id,
+    required this.configId,
+    this.sortOrder = 0,
+    this.label,
+    required this.tankRole,
+    this.volumeL,
+    this.workingPressureBar,
+    this.tankMaterial,
+    this.o2Percent = 21,
+    this.hePercent = 0,
+    this.defaultStartPressureBar,
+    required this.createdAt,
+    required this.updatedAt,
+  });
+
+  CylinderConfigItem copyWith({
+    String? id,
+    String? configId,
+    int? sortOrder,
+    String? label,
+    bool clearLabel = false,
+    TankRole? tankRole,
+    double? volumeL,
+    bool clearVolumeL = false,
+    double? workingPressureBar,
+    bool clearWorkingPressureBar = false,
+    TankMaterial? tankMaterial,
+    bool clearTankMaterial = false,
+    double? o2Percent,
+    double? hePercent,
+    double? defaultStartPressureBar,
+    bool clearDefaultStartPressureBar = false,
+    DateTime? createdAt,
+    DateTime? updatedAt,
+  }) => CylinderConfigItem(
+    id: id ?? this.id,
+    configId: configId ?? this.configId,
+    sortOrder: sortOrder ?? this.sortOrder,
+    label: clearLabel ? null : (label ?? this.label),
+    tankRole: tankRole ?? this.tankRole,
+    volumeL: clearVolumeL ? null : (volumeL ?? this.volumeL),
+    workingPressureBar: clearWorkingPressureBar
+        ? null
+        : (workingPressureBar ?? this.workingPressureBar),
+    tankMaterial: clearTankMaterial
+        ? null
+        : (tankMaterial ?? this.tankMaterial),
+    o2Percent: o2Percent ?? this.o2Percent,
+    hePercent: hePercent ?? this.hePercent,
+    defaultStartPressureBar: clearDefaultStartPressureBar
+        ? null
+        : (defaultStartPressureBar ?? this.defaultStartPressureBar),
+    createdAt: createdAt ?? this.createdAt,
+    updatedAt: updatedAt ?? this.updatedAt,
+  );
+
+  /// Timestamps are excluded: they churn on every write and would defeat
+  /// Riverpod's equality-based rebuild suppression. Mirrors EquipmentSet.
+  @override
+  List<Object?> get props => [
+    id,
+    configId,
+    sortOrder,
+    label,
+    tankRole,
+    volumeL,
+    workingPressureBar,
+    tankMaterial,
+    o2Percent,
+    hePercent,
+    defaultStartPressureBar,
+  ];
+}
diff --git a/test/features/cylinder_configs/domain/entities/cylinder_config_test.dart b/test/features/cylinder_configs/domain/entities/cylinder_config_test.dart
new file mode 100644
index 0000000000..968b340c06
--- /dev/null
+++ b/test/features/cylinder_configs/domain/entities/cylinder_config_test.dart
@@ -0,0 +1,102 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+
+void main() {
+  final now = DateTime.utc(2026, 8, 5);
+
+  CylinderConfigItem item({
+    String id = 'i1',
+    TankRole role = TankRole.bailout,
+    double o2 = 21,
+  }) => CylinderConfigItem(
+    id: id,
+    configId: 'c1',
+    tankRole: role,
+    o2Percent: o2,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  test('a config with an equipmentId is owned by a unit', () {
+    final owned = CylinderConfig(
+      id: 'c1',
+      name: 'JJ trimix',
+      equipmentId: 'rb-1',
+      createdAt: now,
+      updatedAt: now,
+    );
+    expect(owned.isOwnedByUnit, isTrue);
+
+    final generic = owned.copyWith(clearEquipmentId: true);
+    expect(generic.isOwnedByUnit, isFalse);
+    expect(generic.name, 'JJ trimix');
+  });
+
+  test('items default to air and back gas is not assumed', () {
+    final i = item();
+    expect(i.o2Percent, 21);
+    expect(i.hePercent, 0);
+    expect(i.tankRole, TankRole.bailout);
+    expect(i.volumeL, isNull);
+    expect(i.tankMaterial, isNull);
+    expect(i.defaultStartPressureBar, isNull);
+    expect(i.label, isNull);
+  });
+
+  test('equality is by value, so provider rebuilds are stable', () {
+    expect(item(), equals(item()));
+    expect(item(o2: 32), isNot(equals(item())));
+  });
+
+  test('timestamps are excluded from equality', () {
+    final a = item();
+    final b = a.copyWith(updatedAt: now.add(const Duration(days: 1)));
+    expect(a, equals(b));
+  });
+
+  test('copyWith replaces the item list wholesale', () {
+    final config = CylinderConfig(
+      id: 'c1',
+      name: 'Doubles + 50',
+      createdAt: now,
+      updatedAt: now,
+      items: [item(id: 'a')],
+    );
+    final updated = config.copyWith(
+      items: [
+        item(id: 'a'),
+        item(id: 'b'),
+      ],
+    );
+    expect(config.items.length, 1);
+    expect(updated.items.length, 2);
+  });
+
+  test('clear flags null out optional item fields', () {
+    final full = item().copyWith(
+      volumeL: 11.1,
+      workingPressureBar: 207,
+      tankMaterial: TankMaterial.aluminum,
+      defaultStartPressureBar: 200,
+      label: 'Bailout 1',
+    );
+    expect(full.volumeL, 11.1);
+
+    final cleared = full.copyWith(
+      clearVolumeL: true,
+      clearWorkingPressureBar: true,
+      clearTankMaterial: true,
+      clearDefaultStartPressureBar: true,
+      clearLabel: true,
+    );
+    expect(cleared.volumeL, isNull);
+    expect(cleared.workingPressureBar, isNull);
+    expect(cleared.tankMaterial, isNull);
+    expect(cleared.defaultStartPressureBar, isNull);
+    expect(cleared.label, isNull);
+    // Gas is not clearable: it always has a concrete value.
+    expect(cleared.o2Percent, 21);
+  });
+}

From 7c66c6373c6b7b16a75ba525430e7f2caf0533c2 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 17:49:49 -0400
Subject: [PATCH 11/20] Add cylinder configuration merge algorithm (#804)

CylinderConfigApplier is pure -- no database, no DateTime.now() -- mirroring
ServiceDueEngine so the merge rules are exhaustively testable without a
fixture. It matches config items to existing dive_tanks rows by role, taking
the first unclaimed tank each time, because roles are not unique: a CCR diver
routinely carries two bailouts.

FillTank has no gas fields. dive_tanks defaults o2_percent to 21 and
he_percent to 0, so a tank reading air is indistinguishable from one nobody
filled in; with no null to test against there is no honest way to detect
'unset'. Omitting the fields makes overwriting a downloaded mix unexpressible
rather than merely discouraged.
---
 .../services/cylinder_config_applier.dart     | 159 +++++++++++
 .../cylinder_config_applier_test.dart         | 247 ++++++++++++++++++
 2 files changed, 406 insertions(+)
 create mode 100644 lib/features/cylinder_configs/domain/services/cylinder_config_applier.dart
 create mode 100644 test/features/cylinder_configs/domain/services/cylinder_config_applier_test.dart

diff --git a/lib/features/cylinder_configs/domain/services/cylinder_config_applier.dart b/lib/features/cylinder_configs/domain/services/cylinder_config_applier.dart
new file mode 100644
index 0000000000..219b0016bf
--- /dev/null
+++ b/lib/features/cylinder_configs/domain/services/cylinder_config_applier.dart
@@ -0,0 +1,159 @@
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+
+/// The applier's read-only view of an existing dive_tanks row.
+class ExistingTank {
+  final String id;
+  final TankRole tankRole;
+  final double? volumeL;
+  final double? workingPressureBar;
+  final TankMaterial? tankMaterial;
+  final double? startPressureBar;
+  final String? tankName;
+  final int tankOrder;
+
+  const ExistingTank({
+    required this.id,
+    required this.tankRole,
+    this.volumeL,
+    this.workingPressureBar,
+    this.tankMaterial,
+    this.startPressureBar,
+    this.tankName,
+    this.tankOrder = 0,
+  });
+}
+
+sealed class CylinderConfigOp {
+  const CylinderConfigOp();
+}
+
+/// Create a new dive_tanks row from [item] at [tankOrder].
+class InsertTank extends CylinderConfigOp {
+  final CylinderConfigItem item;
+  final int tankOrder;
+
+  const InsertTank({required this.item, required this.tankOrder});
+}
+
+/// Fill columns that are NULL on an existing dive_tanks row. Every field here
+/// is nullable and null means "leave this column alone".
+///
+/// There are deliberately no o2Percent or hePercent fields. dive_tanks
+/// defaults them to 21.0 and 0.0, so a tank reading air is indistinguishable
+/// from a tank nobody filled in -- there is no null to test against, and
+/// therefore no honest way to detect "unset". Omitting the fields makes
+/// overwriting a gas mix unexpressible rather than merely discouraged.
+/// Absent gas on a dive is a nuisance; wrong gas is a safety-relevant
+/// falsehood in a logbook divers plan future dives from.
+class FillTank extends CylinderConfigOp {
+  final String tankId;
+  final double? volumeL;
+  final double? workingPressureBar;
+  final TankMaterial? tankMaterial;
+  final double? startPressureBar;
+  final String? tankName;
+
+  const FillTank({
+    required this.tankId,
+    this.volumeL,
+    this.workingPressureBar,
+    this.tankMaterial,
+    this.startPressureBar,
+    this.tankName,
+  });
+
+  bool get isEmpty =>
+      volumeL == null &&
+      workingPressureBar == null &&
+      tankMaterial == null &&
+      startPressureBar == null &&
+      tankName == null;
+}
+
+/// The result of planning an apply: the operations to persist, plus the
+/// counts a caller reports back to the diver.
+class CylinderConfigPlan {
+  final List<CylinderConfigOp> ops;
+  final int insertedCount;
+  final int keptCount;
+
+  const CylinderConfigPlan({
+    required this.ops,
+    required this.insertedCount,
+    required this.keptCount,
+  });
+
+  bool get isNoOp => insertedCount == 0 && keptCount == 0;
+}
+
+/// Merges a cylinder configuration into a dive's existing cylinders.
+///
+/// Pure: no database, no DateTime.now(). Callers persist the returned ops.
+/// Mirrors ServiceDueEngine, so the merge rules can be tested exhaustively
+/// without a database fixture.
+class CylinderConfigApplier {
+  const CylinderConfigApplier();
+
+  CylinderConfigPlan plan({
+    required List<ExistingTank> existing,
+    required List<CylinderConfigItem> items,
+  }) {
+    final ordered = [...items]
+      ..sort((a, b) => a.sortOrder.compareTo(b.sortOrder));
+
+    final claimed = <String>{};
+    final ops = <CylinderConfigOp>[];
+    var inserted = 0;
+    var kept = 0;
+
+    var nextOrder = existing.isEmpty
+        ? 0
+        : existing.map((t) => t.tankOrder).reduce((a, b) => a > b ? a : b) + 1;
+
+    for (final item in ordered) {
+      // First unclaimed existing tank with the same role. Roles are not
+      // unique -- a CCR diver routinely carries two bailout cylinders -- so
+      // claiming greedily in order is what makes "config has 2 bailouts,
+      // dive already has 1" resolve to keep-one-add-one rather than
+      // duplicating or clobbering.
+      ExistingTank? match;
+      for (final tank in existing) {
+        if (tank.tankRole == item.tankRole && !claimed.contains(tank.id)) {
+          match = tank;
+          break;
+        }
+      }
+
+      if (match == null) {
+        ops.add(InsertTank(item: item, tankOrder: nextOrder));
+        nextOrder++;
+        inserted++;
+        continue;
+      }
+
+      claimed.add(match.id);
+      kept++;
+
+      final fill = FillTank(
+        tankId: match.id,
+        volumeL: match.volumeL == null ? item.volumeL : null,
+        workingPressureBar: match.workingPressureBar == null
+            ? item.workingPressureBar
+            : null,
+        tankMaterial: match.tankMaterial == null ? item.tankMaterial : null,
+        startPressureBar: match.startPressureBar == null
+            ? item.defaultStartPressureBar
+            : null,
+        tankName: match.tankName == null ? item.label : null,
+      );
+      if (!fill.isEmpty) ops.add(fill);
+    }
+
+    return CylinderConfigPlan(
+      ops: ops,
+      insertedCount: inserted,
+      keptCount: kept,
+    );
+  }
+}
diff --git a/test/features/cylinder_configs/domain/services/cylinder_config_applier_test.dart b/test/features/cylinder_configs/domain/services/cylinder_config_applier_test.dart
new file mode 100644
index 0000000000..efbf32dfb4
--- /dev/null
+++ b/test/features/cylinder_configs/domain/services/cylinder_config_applier_test.dart
@@ -0,0 +1,247 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+import 'package:submersion/features/cylinder_configs/domain/services/cylinder_config_applier.dart';
+
+void main() {
+  final now = DateTime.utc(2026, 8, 5);
+  const applier = CylinderConfigApplier();
+
+  CylinderConfigItem cfg({
+    required String id,
+    required TankRole role,
+    int order = 0,
+    double o2 = 21,
+    double he = 0,
+    double? volume,
+    double? pressure,
+    TankMaterial? material,
+    double? startPressure,
+    String? label,
+  }) => CylinderConfigItem(
+    id: id,
+    configId: 'c1',
+    sortOrder: order,
+    tankRole: role,
+    o2Percent: o2,
+    hePercent: he,
+    volumeL: volume,
+    workingPressureBar: pressure,
+    tankMaterial: material,
+    defaultStartPressureBar: startPressure,
+    label: label,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  ExistingTank tank({
+    required String id,
+    required TankRole role,
+    double? volume,
+    double? pressure,
+    TankMaterial? material,
+    double? startPressure,
+    String? name,
+    int order = 0,
+  }) => ExistingTank(
+    id: id,
+    tankRole: role,
+    volumeL: volume,
+    workingPressureBar: pressure,
+    tankMaterial: material,
+    startPressureBar: startPressure,
+    tankName: name,
+    tankOrder: order,
+  );
+
+  test('an empty dive gets every cylinder inserted, in sort order', () {
+    final plan = applier.plan(
+      existing: const [],
+      items: [
+        cfg(id: 'b', role: TankRole.oxygenSupply, order: 1),
+        cfg(id: 'a', role: TankRole.diluent, order: 0),
+        cfg(id: 'c', role: TankRole.bailout, order: 2),
+      ],
+    );
+
+    expect(plan.insertedCount, 3);
+    expect(plan.keptCount, 0);
+    expect(plan.ops.whereType<FillTank>(), isEmpty);
+
+    final inserts = plan.ops.whereType<InsertTank>().toList();
+    expect(inserts.map((o) => o.item.tankRole), [
+      TankRole.diluent,
+      TankRole.oxygenSupply,
+      TankRole.bailout,
+    ]);
+    expect(inserts.map((o) => o.tankOrder), [0, 1, 2]);
+  });
+
+  test('inserted tank order continues after the existing maximum', () {
+    final plan = applier.plan(
+      existing: [tank(id: 't1', role: TankRole.diluent, order: 7)],
+      items: [
+        cfg(id: 'a', role: TankRole.diluent, order: 0),
+        cfg(id: 'b', role: TankRole.bailout, order: 1),
+      ],
+    );
+
+    final inserts = plan.ops.whereType<InsertTank>().toList();
+    expect(inserts, hasLength(1));
+    expect(inserts.single.tankOrder, 8);
+  });
+
+  test('a downloaded gas mix is never overwritten', () {
+    // The config carries a spec value so the claim is observable as a
+    // FillTank; the point is that the trimix in the config reaches the
+    // dive's air-filled diluent through no field of that op.
+    final plan = applier.plan(
+      existing: [tank(id: 't1', role: TankRole.diluent)],
+      items: [
+        cfg(id: 'a', role: TankRole.diluent, o2: 18, he: 45, pressure: 232),
+      ],
+    );
+
+    expect(plan.insertedCount, 0);
+    expect(plan.keptCount, 1);
+
+    final fill = plan.ops.whereType<FillTank>().single;
+    expect(fill.tankId, 't1');
+    expect(fill.workingPressureBar, 232, reason: 'null column is filled');
+
+    // FillTank has no gas fields at all, so overwriting a mix is not
+    // expressible rather than merely discouraged. This is a compile-time
+    // guarantee; the runtime check below just pins the op's shape.
+    expect(fill.volumeL, isNull);
+    expect(fill.tankName, isNull);
+  });
+
+  test('only null columns are filled on a claimed tank', () {
+    final plan = applier.plan(
+      existing: [
+        tank(
+          id: 't1',
+          role: TankRole.bailout,
+          volume: 11.1,
+          name: 'Downloaded',
+        ),
+      ],
+      items: [
+        cfg(
+          id: 'a',
+          role: TankRole.bailout,
+          volume: 5.7,
+          pressure: 207,
+          material: TankMaterial.aluminum,
+          startPressure: 200,
+          label: 'Bailout 1',
+        ),
+      ],
+    );
+
+    final fill = plan.ops.whereType<FillTank>().single;
+    expect(fill.volumeL, isNull, reason: 'already 11.1, must not be touched');
+    expect(fill.tankName, isNull, reason: 'already named');
+    expect(fill.workingPressureBar, 207);
+    expect(fill.tankMaterial, TankMaterial.aluminum);
+    expect(fill.startPressureBar, 200);
+  });
+
+  test('duplicate roles claim one existing tank each, then insert', () {
+    final plan = applier.plan(
+      existing: [tank(id: 't1', role: TankRole.bailout, order: 0)],
+      items: [
+        cfg(id: 'a', role: TankRole.bailout, order: 0, pressure: 207),
+        cfg(id: 'b', role: TankRole.bailout, order: 1, pressure: 232),
+      ],
+    );
+
+    expect(plan.keptCount, 1);
+    expect(plan.insertedCount, 1);
+    expect(plan.ops.whereType<FillTank>().single.tankId, 't1');
+    expect(
+      plan.ops.whereType<InsertTank>().single.item.workingPressureBar,
+      232,
+    );
+  });
+
+  test('two existing tanks of one role are both claimed before inserting', () {
+    // Distinct pressures make each claim observable and pin the pairing:
+    // item a -> t1, item b -> t2, in sort order.
+    final plan = applier.plan(
+      existing: [
+        tank(id: 't1', role: TankRole.bailout, order: 0),
+        tank(id: 't2', role: TankRole.bailout, order: 1),
+      ],
+      items: [
+        cfg(id: 'a', role: TankRole.bailout, order: 0, pressure: 207),
+        cfg(id: 'b', role: TankRole.bailout, order: 1, pressure: 232),
+      ],
+    );
+
+    expect(plan.keptCount, 2);
+    expect(plan.insertedCount, 0);
+
+    final fills = plan.ops.whereType<FillTank>().toList();
+    expect(fills.map((o) => o.tankId), ['t1', 't2']);
+    expect(fills.map((o) => o.workingPressureBar), [207, 232]);
+  });
+
+  test('extra existing tanks the config does not mention are left alone', () {
+    final plan = applier.plan(
+      existing: [
+        tank(id: 't1', role: TankRole.diluent),
+        tank(id: 't2', role: TankRole.stage),
+      ],
+      items: [cfg(id: 'a', role: TankRole.diluent, pressure: 232)],
+    );
+
+    expect(plan.keptCount, 1);
+    expect(plan.insertedCount, 0);
+    // Only the diluent is touched; the stage bottle produces no op at all.
+    expect(plan.ops.whereType<FillTank>().map((o) => o.tankId), ['t1']);
+  });
+
+  test('a claimed tank needing no fill produces no FillTank op', () {
+    final plan = applier.plan(
+      existing: [
+        tank(
+          id: 't1',
+          role: TankRole.diluent,
+          volume: 3,
+          pressure: 232,
+          material: TankMaterial.steel,
+          startPressure: 200,
+          name: 'Dil',
+        ),
+      ],
+      items: [cfg(id: 'a', role: TankRole.diluent, volume: 3, pressure: 232)],
+    );
+
+    expect(plan.keptCount, 1);
+    expect(plan.ops, isEmpty);
+  });
+
+  test('an empty config is a no-op', () {
+    final plan = applier.plan(
+      existing: [tank(id: 't1', role: TankRole.diluent)],
+      items: const [],
+    );
+    expect(plan.ops, isEmpty);
+    expect(plan.insertedCount, 0);
+    expect(plan.keptCount, 0);
+  });
+
+  test('planning is pure: the input lists are not mutated', () {
+    final items = [
+      cfg(id: 'b', role: TankRole.bailout, order: 1),
+      cfg(id: 'a', role: TankRole.diluent, order: 0),
+    ];
+    final existing = [tank(id: 't1', role: TankRole.diluent)];
+
+    applier.plan(existing: existing, items: items);
+
+    expect(items.map((i) => i.id), ['b', 'a'], reason: 'caller order intact');
+    expect(existing, hasLength(1));
+  });
+}

From 6661c1f47af9f4a42459ed4036a959aad14ffcf3 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 17:54:48 -0400
Subject: [PATCH 12/20] Add cylinder configuration tables at schema v139 (#804)

Two synced tables: cylinder_configs (nullable equipment_id, ON DELETE SET NULL
so deleting a rebreather demotes its configs to generic gas plans rather than
destroying them) and cylinder_config_items (ON DELETE CASCADE).

_assertCylinderConfigSchema is CREATE TABLE IF NOT EXISTS and runs from both
the onUpgrade v139 block and the beforeOpen backstop, so a database stranded
by a parallel-branch version collision self-heals.

v138 is left reserved for the divelogs.de branch. Migration test asserts
greaterThanOrEqualTo(139) plus contains(139) rather than an exact-latest
tripwire, and enables PRAGMA foreign_keys so the FK behaviours are actually
exercised.
---
 lib/core/database/database.dart               | 125 +++++++++++-
 .../migration_v139_cylinder_configs_test.dart | 184 ++++++++++++++++++
 2 files changed, 308 insertions(+), 1 deletion(-)
 create mode 100644 test/core/database/migration_v139_cylinder_configs_test.dart

diff --git a/lib/core/database/database.dart b/lib/core/database/database.dart
index af603e41ef..adc77913fd 100644
--- a/lib/core/database/database.dart
+++ b/lib/core/database/database.dart
@@ -2150,6 +2150,60 @@ const String kSeedBuiltInServiceKindsSql = '''
   CROSS JOIN (SELECT CAST(strftime('%s','now') AS INTEGER) * 1000 AS now_ms) n
 ''';
 
+/// A named, reusable set of cylinders. equipment_id set means "a config for
+/// this rebreather"; null means a generic gas plan usable on any dive.
+/// ON DELETE SET NULL demotes a config when its unit is deleted rather than
+/// destroying a painstakingly entered bailout plan.
+class CylinderConfigs extends Table {
+  TextColumn get id => text()();
+  TextColumn get diverId => text().nullable().references(Divers, #id)();
+  TextColumn get equipmentId => text().nullable().references(
+    Equipment,
+    #id,
+    onDelete: KeyAction.setNull,
+  )();
+  TextColumn get name => text()();
+  TextColumn get description => text().withDefault(const Constant(''))();
+  IntColumn get sortOrder => integer().withDefault(const Constant(0))();
+  IntColumn get createdAt => integer()();
+  IntColumn get updatedAt => integer()();
+
+  /// Hybrid Logical Clock for cross-device conflict resolution
+  /// (nullable: rows written before HLC rollout fall back to updatedAt).
+  TextColumn get hlc => text().nullable()();
+
+  @override
+  Set<Column> get primaryKey => {id};
+}
+
+/// One cylinder in a configuration. The spec columns are a SNAPSHOT: a tank
+/// preset may populate them at edit time, but there is deliberately no FK to
+/// tank_presets. A config records what the diver actually dives, so a later
+/// edit to a preset must not rewrite the meaning of a saved config.
+class CylinderConfigItems extends Table {
+  TextColumn get id => text()();
+  TextColumn get configId =>
+      text().references(CylinderConfigs, #id, onDelete: KeyAction.cascade)();
+  IntColumn get sortOrder => integer().withDefault(const Constant(0))();
+  TextColumn get label => text().nullable()();
+  TextColumn get tankRole => text()(); // TankRole.name
+  RealColumn get volumeL => real().nullable()();
+  RealColumn get workingPressureBar => real().nullable()();
+  TextColumn get tankMaterial => text().nullable()(); // TankMaterial.name
+  RealColumn get o2Percent => real().withDefault(const Constant(21.0))();
+  RealColumn get hePercent => real().withDefault(const Constant(0.0))();
+  RealColumn get defaultStartPressureBar => real().nullable()();
+  IntColumn get createdAt => integer()();
+  IntColumn get updatedAt => integer()();
+
+  /// Hybrid Logical Clock for cross-device conflict resolution
+  /// (nullable: rows written before HLC rollout fall back to updatedAt).
+  TextColumn get hlc => text().nullable()();
+
+  @override
+  Set<Column> get primaryKey => {id};
+}
+
 /// Custom tank presets (user-defined tank configurations)
 class TankPresets extends Table {
   TextColumn get id => text()();
@@ -2862,6 +2916,8 @@ String legacyDataSourceId(String diveId) => '$kLegacyDataSourceIdPrefix$diveId';
     ConnectedAccounts,
     ServiceKinds,
     ServiceSchedules,
+    CylinderConfigs,
+    CylinderConfigItems,
   ],
 )
 class AppDatabase extends _$AppDatabase {
@@ -2871,7 +2927,7 @@ class AppDatabase extends _$AppDatabase {
 
   /// The current schema version as a static constant so that pre-open checks
   /// (e.g. version-mismatch guard) can reference it without an instance.
-  static const int currentSchemaVersion = 137;
+  static const int currentSchemaVersion = 139;
 
   /// Every schema version that has a migration block in onUpgrade.
   /// Used to calculate progress step counts. When adding a new migration,
@@ -3040,6 +3096,10 @@ class AppDatabase extends _$AppDatabase {
     // v137: dives.weather_code, plus a one-time clear of the English weather
     // prose this app generated itself so it can be re-rendered localized.
     137,
+    // v138 is reserved by the divelogs.de branch (connected_accounts.diver_id).
+    // v139: cylinder_configs + cylinder_config_items (reusable diluent and
+    // bailout setups).
+    139,
   ];
 
   /// Idempotent DDL for the v106 connector-suggestion columns (Lightroom
@@ -3404,6 +3464,60 @@ class AppDatabase extends _$AppDatabase {
     );
   }
 
+  /// v139: cylinder configuration tables. CREATE TABLE IF NOT EXISTS, so this
+  /// is safe to call from both onUpgrade and the beforeOpen backstop
+  /// (parallel-branch version-collision self-heal).
+  ///
+  /// o2_percent / he_percent carry the same non-null defaults as dive_tanks
+  /// so a configuration cylinder is never in an "unset gas" state.
+  Future<void> _assertCylinderConfigSchema() async {
+    await customStatement('''
+      CREATE TABLE IF NOT EXISTS cylinder_configs (
+        id TEXT NOT NULL PRIMARY KEY,
+        diver_id TEXT REFERENCES divers (id),
+        equipment_id TEXT REFERENCES equipment (id) ON DELETE SET NULL,
+        name TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        sort_order INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        hlc TEXT
+      )
+    ''');
+    await customStatement('''
+      CREATE TABLE IF NOT EXISTS cylinder_config_items (
+        id TEXT NOT NULL PRIMARY KEY,
+        config_id TEXT NOT NULL
+          REFERENCES cylinder_configs (id) ON DELETE CASCADE,
+        sort_order INTEGER NOT NULL DEFAULT 0,
+        label TEXT,
+        tank_role TEXT NOT NULL,
+        volume_l REAL,
+        working_pressure_bar REAL,
+        tank_material TEXT,
+        o2_percent REAL NOT NULL DEFAULT 21.0,
+        he_percent REAL NOT NULL DEFAULT 0.0,
+        default_start_pressure_bar REAL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        hlc TEXT
+      )
+    ''');
+    await customStatement(
+      'CREATE INDEX IF NOT EXISTS idx_cylinder_configs_equipment '
+      'ON cylinder_configs (equipment_id)',
+    );
+    await customStatement(
+      'CREATE INDEX IF NOT EXISTS idx_cylinder_config_items_config '
+      'ON cylinder_config_items (config_id)',
+    );
+  }
+
+  /// Test hook: re-assert the v139 tables on demand so tests can prove the
+  /// stranded-database self-heal path is idempotent.
+  Future<void> assertCylinderConfigSchemaForTest() =>
+      _assertCylinderConfigSchema();
+
   /// v127: pre-dive checklist tables. Migrator.createTable is IF NOT EXISTS,
   /// so this is safe to call from both onUpgrade and the beforeOpen backstop
   /// (parallel-branch version-collision self-heal).
@@ -7171,6 +7285,10 @@ class AppDatabase extends _$AppDatabase {
           await _clearGeneratedWeatherDescriptions();
         }
         if (from < 137) await reportProgress();
+        if (from < 139) {
+          await _assertCylinderConfigSchema();
+          await reportProgress();
+        }
       },
       beforeOpen: (details) async {
         // Enable foreign keys
@@ -7279,6 +7397,11 @@ class AppDatabase extends _$AppDatabase {
         // v135 backstop: re-assert color accent toggle columns.
         await _assertAccentColorSettingsColumns();
 
+        // v139 backstop: re-assert the cylinder configuration tables. A
+        // database stranded at any lower version by a parallel-branch
+        // version collision self-heals here.
+        await _assertCylinderConfigSchema();
+
         // Built-in dive types are reference data: identical on every device and
         // undeletable through DiveTypeRepository. Nothing else restores them --
         // the seed runs only in onCreate and the one-shot v93 step -- yet a
diff --git a/test/core/database/migration_v139_cylinder_configs_test.dart b/test/core/database/migration_v139_cylinder_configs_test.dart
new file mode 100644
index 0000000000..fa5832fd4b
--- /dev/null
+++ b/test/core/database/migration_v139_cylinder_configs_test.dart
@@ -0,0 +1,184 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/database/database.dart';
+
+import '../../helpers/test_database.dart';
+
+void main() {
+  late AppDatabase db;
+
+  setUp(() {
+    db = createTestDatabase();
+  });
+
+  tearDown(() async {
+    await db.close();
+  });
+
+  test('v139 is in the migration ladder', () {
+    // greaterThanOrEqualTo, not ==: a higher version merging first must not
+    // turn this into a false failure. See the schema-version ladder
+    // convention.
+    expect(AppDatabase.currentSchemaVersion, greaterThanOrEqualTo(139));
+    expect(AppDatabase.migrationVersions, contains(139));
+  });
+
+  test('a fresh database has both cylinder config tables', () async {
+    final configCols = await db
+        .customSelect("PRAGMA table_info('cylinder_configs')")
+        .get();
+    expect(
+      configCols.map((c) => c.read<String>('name')).toSet(),
+      containsAll([
+        'id',
+        'diver_id',
+        'equipment_id',
+        'name',
+        'description',
+        'sort_order',
+        'created_at',
+        'updated_at',
+        'hlc',
+      ]),
+    );
+
+    final itemCols = await db
+        .customSelect("PRAGMA table_info('cylinder_config_items')")
+        .get();
+    expect(
+      itemCols.map((c) => c.read<String>('name')).toSet(),
+      containsAll([
+        'id',
+        'config_id',
+        'sort_order',
+        'label',
+        'tank_role',
+        'volume_l',
+        'working_pressure_bar',
+        'tank_material',
+        'o2_percent',
+        'he_percent',
+        'default_start_pressure_bar',
+        'created_at',
+        'updated_at',
+        'hlc',
+      ]),
+    );
+  });
+
+  test(
+    'deleting the owning equipment demotes the config, not deletes it',
+    () async {
+      // Drift's in-memory default leaves foreign keys OFF, which would make
+      // this assertion pass whether or not ON DELETE SET NULL is wired.
+      await db.customStatement('PRAGMA foreign_keys = ON');
+
+      final now = DateTime.now().millisecondsSinceEpoch;
+      await db.customStatement(
+        "INSERT INTO equipment (id, name, type, created_at, updated_at) "
+        "VALUES ('rb-1', 'JJ', 'rebreather', $now, $now)",
+      );
+      await db.customStatement(
+        "INSERT INTO cylinder_configs "
+        "(id, equipment_id, name, description, sort_order, "
+        " created_at, updated_at) "
+        "VALUES ('c1', 'rb-1', 'Trimix', '', 0, $now, $now)",
+      );
+
+      await db.customStatement("DELETE FROM equipment WHERE id = 'rb-1'");
+
+      final rows = await db
+          .customSelect(
+            "SELECT id, equipment_id FROM cylinder_configs WHERE id = 'c1'",
+          )
+          .get();
+      expect(rows, hasLength(1), reason: 'config must survive unit deletion');
+      expect(rows.single.read<String?>('equipment_id'), isNull);
+    },
+  );
+
+  test('deleting a config cascades to its items', () async {
+    await db.customStatement('PRAGMA foreign_keys = ON');
+
+    final now = DateTime.now().millisecondsSinceEpoch;
+    await db.customStatement(
+      "INSERT INTO cylinder_configs "
+      "(id, name, description, sort_order, created_at, updated_at) "
+      "VALUES ('c1', 'Doubles', '', 0, $now, $now)",
+    );
+    await db.customStatement(
+      "INSERT INTO cylinder_config_items "
+      "(id, config_id, sort_order, tank_role, o2_percent, he_percent, "
+      " created_at, updated_at) "
+      "VALUES ('i1', 'c1', 0, 'backGas', 21, 0, $now, $now)",
+    );
+
+    await db.customStatement("DELETE FROM cylinder_configs WHERE id = 'c1'");
+
+    final items = await db
+        .customSelect('SELECT id FROM cylinder_config_items')
+        .get();
+    expect(items, isEmpty);
+  });
+
+  test('gas columns carry non-null defaults matching dive_tanks', () async {
+    final now = DateTime.now().millisecondsSinceEpoch;
+    await db.customStatement(
+      "INSERT INTO cylinder_configs "
+      "(id, name, description, sort_order, created_at, updated_at) "
+      "VALUES ('c1', 'Air', '', 0, $now, $now)",
+    );
+    await db.customStatement(
+      "INSERT INTO cylinder_config_items "
+      "(id, config_id, sort_order, tank_role, created_at, updated_at) "
+      "VALUES ('i1', 'c1', 0, 'backGas', $now, $now)",
+    );
+
+    final row = await db
+        .customSelect(
+          'SELECT o2_percent, he_percent FROM cylinder_config_items',
+        )
+        .getSingle();
+    expect(row.read<double>('o2_percent'), 21.0);
+    expect(row.read<double>('he_percent'), 0.0);
+  });
+
+  test(
+    'a database stranded below v139 self-heals via the schema assert',
+    () async {
+      await db.customStatement('DROP TABLE IF EXISTS cylinder_config_items');
+      await db.customStatement('DROP TABLE IF EXISTS cylinder_configs');
+
+      await db.assertCylinderConfigSchemaForTest();
+
+      final tables = await db
+          .customSelect(
+            "SELECT name FROM sqlite_master WHERE type='table' "
+            "AND name LIKE 'cylinder_config%'",
+          )
+          .get();
+      expect(tables.map((t) => t.read<String>('name')).toSet(), {
+        'cylinder_configs',
+        'cylinder_config_items',
+      });
+
+      // Idempotent: running it again over healed tables is a no-op.
+      await db.assertCylinderConfigSchemaForTest();
+    },
+  );
+
+  test('fresh install has the cylinder config indexes', () async {
+    final idx = await db
+        .customSelect(
+          "SELECT name FROM sqlite_master WHERE type='index' "
+          "AND name LIKE 'idx_cylinder_config%'",
+        )
+        .get();
+    expect(
+      idx.map((r) => r.read<String>('name')),
+      containsAll([
+        'idx_cylinder_configs_equipment',
+        'idx_cylinder_config_items_config',
+      ]),
+    );
+  });
+}

From da486cc39c2dfff3c59cfe49119d9528fa78d14b Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 18:06:57 -0400
Subject: [PATCH 13/20] Add cylinder configuration repository (#804)

Modelled on EquipmentSetRepository: writes register sync intent through
SyncRepository and notify the event bus. saveItems writes the desired end
state, renumbering sortOrder from list position so the reorderable editor can
move entries instead of maintaining indices.

Every child delete writes a deletion-log tombstone, on both the saveItems
diff path and deleteConfig. The database cascades children when a config is
deleted, but a peer that has not seen the delete would push them straight back
without a tombstone.

Unknown persisted role and material strings degrade to a default rather than
throwing, so a row written by a newer version cannot break an older one.
Tests run with PRAGMA foreign_keys ON, which caught a missing divers row.
---
 .../cylinder_config_repository.dart           | 297 ++++++++++++++++++
 .../data/cylinder_config_repository_test.dart | 257 +++++++++++++++
 2 files changed, 554 insertions(+)
 create mode 100644 lib/features/cylinder_configs/data/repositories/cylinder_config_repository.dart
 create mode 100644 test/features/cylinder_configs/data/cylinder_config_repository_test.dart

diff --git a/lib/features/cylinder_configs/data/repositories/cylinder_config_repository.dart b/lib/features/cylinder_configs/data/repositories/cylinder_config_repository.dart
new file mode 100644
index 0000000000..a3ecb8fae5
--- /dev/null
+++ b/lib/features/cylinder_configs/data/repositories/cylinder_config_repository.dart
@@ -0,0 +1,297 @@
+import 'package:drift/drift.dart';
+import 'package:uuid/uuid.dart';
+
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/core/data/repositories/sync_repository.dart';
+import 'package:submersion/core/database/database.dart';
+import 'package:submersion/core/services/database_service.dart';
+import 'package:submersion/core/services/sync/sync_event_bus.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config.dart'
+    as domain;
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart'
+    as domain;
+
+/// Persistence for reusable cylinder configurations.
+///
+/// Modelled on EquipmentSetRepository: writes register sync intent through
+/// SyncRepository and notify the event bus, and child deletes always write a
+/// deletion-log tombstone (a child removed without one resurrects on the next
+/// sync pull).
+class CylinderConfigRepository {
+  AppDatabase get _db => DatabaseService.instance.database;
+  final SyncRepository _syncRepository = SyncRepository();
+  final _uuid = const Uuid();
+
+  static const String _configEntity = 'cylinderConfigs';
+  static const String _itemEntity = 'cylinderConfigItems';
+
+  /// Unknown persisted values degrade to a sensible default rather than
+  /// throwing: a row written by a newer version must not break an older one.
+  TankRole _roleFrom(String value) => TankRole.values.firstWhere(
+    (r) => r.name == value,
+    orElse: () => TankRole.backGas,
+  );
+
+  TankMaterial? _materialFrom(String? value) {
+    if (value == null) return null;
+    for (final material in TankMaterial.values) {
+      if (material.name == value) return material;
+    }
+    return null;
+  }
+
+  domain.CylinderConfig _mapConfig(
+    CylinderConfig row,
+    List<domain.CylinderConfigItem> items,
+  ) => domain.CylinderConfig(
+    id: row.id,
+    diverId: row.diverId,
+    equipmentId: row.equipmentId,
+    name: row.name,
+    description: row.description,
+    sortOrder: row.sortOrder,
+    items: items,
+    createdAt: DateTime.fromMillisecondsSinceEpoch(row.createdAt),
+    updatedAt: DateTime.fromMillisecondsSinceEpoch(row.updatedAt),
+  );
+
+  domain.CylinderConfigItem _mapItem(CylinderConfigItem row) =>
+      domain.CylinderConfigItem(
+        id: row.id,
+        configId: row.configId,
+        sortOrder: row.sortOrder,
+        label: row.label,
+        tankRole: _roleFrom(row.tankRole),
+        volumeL: row.volumeL,
+        workingPressureBar: row.workingPressureBar,
+        tankMaterial: _materialFrom(row.tankMaterial),
+        o2Percent: row.o2Percent,
+        hePercent: row.hePercent,
+        defaultStartPressureBar: row.defaultStartPressureBar,
+        createdAt: DateTime.fromMillisecondsSinceEpoch(row.createdAt),
+        updatedAt: DateTime.fromMillisecondsSinceEpoch(row.updatedAt),
+      );
+
+  Future<List<domain.CylinderConfigItem>> _itemsFor(String configId) async {
+    final rows =
+        await (_db.select(_db.cylinderConfigItems)
+              ..where((t) => t.configId.equals(configId))
+              ..orderBy([(t) => OrderingTerm.asc(t.sortOrder)]))
+            .get();
+    return rows.map(_mapItem).toList();
+  }
+
+  Future<List<domain.CylinderConfig>> getAllConfigs({
+    String? diverId,
+    bool includeItems = false,
+  }) async {
+    final query = _db.select(_db.cylinderConfigs)
+      ..orderBy([
+        (t) => OrderingTerm.asc(t.sortOrder),
+        (t) => OrderingTerm.asc(t.name),
+      ]);
+    if (diverId != null) {
+      query.where((t) => t.diverId.equals(diverId));
+    }
+
+    final rows = await query.get();
+    final configs = <domain.CylinderConfig>[];
+    for (final row in rows) {
+      configs.add(
+        _mapConfig(row, includeItems ? await _itemsFor(row.id) : const []),
+      );
+    }
+    return configs;
+  }
+
+  Future<List<domain.CylinderConfig>> getConfigsForEquipment(
+    String equipmentId,
+  ) async {
+    final rows =
+        await (_db.select(_db.cylinderConfigs)
+              ..where((t) => t.equipmentId.equals(equipmentId))
+              ..orderBy([
+                (t) => OrderingTerm.asc(t.sortOrder),
+                (t) => OrderingTerm.asc(t.name),
+              ]))
+            .get();
+    final configs = <domain.CylinderConfig>[];
+    for (final row in rows) {
+      configs.add(_mapConfig(row, await _itemsFor(row.id)));
+    }
+    return configs;
+  }
+
+  Future<domain.CylinderConfig?> getConfigById(
+    String id, {
+    bool includeItems = true,
+  }) async {
+    final row = await (_db.select(
+      _db.cylinderConfigs,
+    )..where((t) => t.id.equals(id))).getSingleOrNull();
+    if (row == null) return null;
+    return _mapConfig(row, includeItems ? await _itemsFor(id) : const []);
+  }
+
+  Future<String> createConfig({
+    String? diverId,
+    String? equipmentId,
+    required String name,
+    String description = '',
+    int sortOrder = 0,
+  }) async {
+    final id = _uuid.v4();
+    final now = DateTime.now().millisecondsSinceEpoch;
+
+    await _db
+        .into(_db.cylinderConfigs)
+        .insert(
+          CylinderConfigsCompanion.insert(
+            id: id,
+            diverId: Value(diverId),
+            equipmentId: Value(equipmentId),
+            name: name,
+            description: Value(description),
+            sortOrder: Value(sortOrder),
+            createdAt: now,
+            updatedAt: now,
+          ),
+        );
+
+    await _syncRepository.markRecordPending(
+      entityType: _configEntity,
+      recordId: id,
+      localUpdatedAt: now,
+    );
+    SyncEventBus.notifyLocalChange();
+    return id;
+  }
+
+  Future<void> updateConfig(domain.CylinderConfig config) async {
+    final now = DateTime.now().millisecondsSinceEpoch;
+
+    await (_db.update(
+      _db.cylinderConfigs,
+    )..where((t) => t.id.equals(config.id))).write(
+      CylinderConfigsCompanion(
+        diverId: Value(config.diverId),
+        equipmentId: Value(config.equipmentId),
+        name: Value(config.name),
+        description: Value(config.description),
+        sortOrder: Value(config.sortOrder),
+        updatedAt: Value(now),
+      ),
+    );
+
+    await _syncRepository.markRecordPending(
+      entityType: _configEntity,
+      recordId: config.id,
+      localUpdatedAt: now,
+    );
+    SyncEventBus.notifyLocalChange();
+  }
+
+  /// Deletes a config and its items. The database cascades the children, but
+  /// each one still needs its own tombstone: a peer that has not seen the
+  /// delete would otherwise push the child straight back.
+  Future<void> deleteConfig(String id) async {
+    final itemIds = (await (_db.select(
+      _db.cylinderConfigItems,
+    )..where((t) => t.configId.equals(id))).get()).map((r) => r.id).toList();
+
+    await _db.transaction(() async {
+      await (_db.delete(
+        _db.cylinderConfigs,
+      )..where((t) => t.id.equals(id))).go();
+
+      for (final itemId in itemIds) {
+        await _syncRepository.logDeletion(
+          entityType: _itemEntity,
+          recordId: itemId,
+        );
+      }
+      await _syncRepository.logDeletion(
+        entityType: _configEntity,
+        recordId: id,
+      );
+    });
+
+    SyncEventBus.notifyLocalChange();
+  }
+
+  /// Writes the desired end state of [configId]'s cylinders: inserts and
+  /// updates rows present in [desired], deletes (with a tombstone) any row no
+  /// longer listed. sortOrder is renumbered from list position so the caller
+  /// can reorder by moving list entries without maintaining indices.
+  Future<void> saveItems(
+    String configId,
+    List<domain.CylinderConfigItem> desired,
+  ) async {
+    final now = DateTime.now().millisecondsSinceEpoch;
+
+    final existingRows = await (_db.select(
+      _db.cylinderConfigItems,
+    )..where((t) => t.configId.equals(configId))).get();
+    final existingById = {for (final row in existingRows) row.id: row};
+
+    final normalized = <domain.CylinderConfigItem>[];
+    for (var index = 0; index < desired.length; index++) {
+      final item = desired[index];
+      normalized.add(
+        item.copyWith(
+          id: item.id.isNotEmpty ? item.id : _uuid.v4(),
+          configId: configId,
+          sortOrder: index,
+        ),
+      );
+    }
+    final desiredIds = normalized.map((i) => i.id).toSet();
+    final pendingIds = <String>[];
+
+    await _db.transaction(() async {
+      for (final row in existingRows) {
+        if (desiredIds.contains(row.id)) continue;
+        await (_db.delete(
+          _db.cylinderConfigItems,
+        )..where((t) => t.id.equals(row.id))).go();
+        await _syncRepository.logDeletion(
+          entityType: _itemEntity,
+          recordId: row.id,
+        );
+      }
+
+      for (final item in normalized) {
+        final existing = existingById[item.id];
+        await _db
+            .into(_db.cylinderConfigItems)
+            .insertOnConflictUpdate(
+              CylinderConfigItemsCompanion(
+                id: Value(item.id),
+                configId: Value(configId),
+                sortOrder: Value(item.sortOrder),
+                label: Value(item.label),
+                tankRole: Value(item.tankRole.name),
+                volumeL: Value(item.volumeL),
+                workingPressureBar: Value(item.workingPressureBar),
+                tankMaterial: Value(item.tankMaterial?.name),
+                o2Percent: Value(item.o2Percent),
+                hePercent: Value(item.hePercent),
+                defaultStartPressureBar: Value(item.defaultStartPressureBar),
+                createdAt: Value(existing?.createdAt ?? now),
+                updatedAt: Value(now),
+              ),
+            );
+        pendingIds.add(item.id);
+      }
+    });
+
+    for (final id in pendingIds) {
+      await _syncRepository.markRecordPending(
+        entityType: _itemEntity,
+        recordId: id,
+        localUpdatedAt: now,
+      );
+    }
+    SyncEventBus.notifyLocalChange();
+  }
+}
diff --git a/test/features/cylinder_configs/data/cylinder_config_repository_test.dart b/test/features/cylinder_configs/data/cylinder_config_repository_test.dart
new file mode 100644
index 0000000000..2668bc4b0a
--- /dev/null
+++ b/test/features/cylinder_configs/data/cylinder_config_repository_test.dart
@@ -0,0 +1,257 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/core/database/database.dart';
+import 'package:submersion/features/cylinder_configs/data/repositories/cylinder_config_repository.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart'
+    as domain;
+
+import '../../../helpers/test_database.dart';
+
+void main() {
+  late AppDatabase db;
+  late CylinderConfigRepository repository;
+  final now = DateTime.utc(2026, 8, 5);
+
+  setUp(() async {
+    db = await setUpTestDatabase();
+    // Drift's in-memory default leaves foreign keys OFF; without this the
+    // demote-on-unit-delete test would pass whether or not the FK is wired.
+    await db.customStatement('PRAGMA foreign_keys = ON');
+    repository = CylinderConfigRepository();
+  });
+
+  tearDown(tearDownTestDatabase);
+
+  Future<void> seedUnit(String id, String name) async {
+    final ts = now.millisecondsSinceEpoch;
+    await db.customStatement(
+      "INSERT INTO equipment (id, name, type, created_at, updated_at) "
+      "VALUES ('$id', '$name', 'rebreather', $ts, $ts)",
+    );
+  }
+
+  Future<void> seedDiver(String id) async {
+    final ts = now.millisecondsSinceEpoch;
+    await db.customStatement(
+      "INSERT INTO divers (id, name, created_at, updated_at) "
+      "VALUES ('$id', 'Test diver', $ts, $ts)",
+    );
+  }
+
+  domain.CylinderConfigItem item({
+    required String id,
+    required String configId,
+    TankRole role = TankRole.bailout,
+    int order = 0,
+    double o2 = 21,
+    double he = 0,
+    double? volume,
+    double? pressure,
+    TankMaterial? material,
+    String? label,
+  }) => domain.CylinderConfigItem(
+    id: id,
+    configId: configId,
+    sortOrder: order,
+    tankRole: role,
+    o2Percent: o2,
+    hePercent: he,
+    volumeL: volume,
+    workingPressureBar: pressure,
+    tankMaterial: material,
+    label: label,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  test('creates a config and reads it back', () async {
+    await seedDiver('d1');
+    final id = await repository.createConfig(
+      diverId: 'd1',
+      name: 'JJ trimix',
+      description: 'Bottom 18/45',
+    );
+
+    final loaded = await repository.getConfigById(id);
+    expect(loaded, isNotNull);
+    expect(loaded!.name, 'JJ trimix');
+    expect(loaded.description, 'Bottom 18/45');
+    expect(loaded.diverId, 'd1');
+    expect(loaded.equipmentId, isNull);
+    expect(loaded.isOwnedByUnit, isFalse);
+    expect(loaded.items, isEmpty);
+  });
+
+  test("getConfigsForEquipment returns only that unit's configs", () async {
+    await seedUnit('rb-1', 'JJ');
+    await seedUnit('rb-2', 'rEvo');
+
+    await repository.createConfig(equipmentId: 'rb-1', name: 'A');
+    await repository.createConfig(equipmentId: 'rb-1', name: 'B');
+    await repository.createConfig(equipmentId: 'rb-2', name: 'C');
+    await repository.createConfig(name: 'Generic');
+
+    final forUnit = await repository.getConfigsForEquipment('rb-1');
+    expect(forUnit.map((c) => c.name).toSet(), {'A', 'B'});
+  });
+
+  test(
+    'getAllConfigs with includeItems hydrates items in sort order',
+    () async {
+      final id = await repository.createConfig(name: 'Doubles + 50');
+      // saveItems renumbers sortOrder from LIST POSITION, so the caller orders
+      // by moving entries rather than maintaining indices. The deliberately
+      // wrong `order:` values below are ignored.
+      await repository.saveItems(id, [
+        item(id: 'i1', configId: id, role: TankRole.backGas, order: 99),
+        item(id: 'i2', configId: id, role: TankRole.deco, order: 99, o2: 50),
+      ]);
+
+      final configs = await repository.getAllConfigs(includeItems: true);
+      final config = configs.single;
+      expect(config.items.map((i) => i.tankRole), [
+        TankRole.backGas,
+        TankRole.deco,
+      ]);
+      expect(config.items.map((i) => i.sortOrder), [0, 1]);
+      expect(config.items.last.o2Percent, 50);
+      expect(config.cylinderCount, 2);
+    },
+  );
+
+  test('item spec fields round-trip, including the material enum', () async {
+    final id = await repository.createConfig(name: 'Bailout');
+    await repository.saveItems(id, [
+      item(
+        id: 'i1',
+        configId: id,
+        role: TankRole.bailout,
+        volume: 11.1,
+        pressure: 207,
+        material: TankMaterial.aluminum,
+        label: 'Bailout 1',
+        o2: 32,
+        he: 0,
+      ),
+    ]);
+
+    final loaded = await repository.getConfigById(id);
+    final only = loaded!.items.single;
+    expect(only.volumeL, 11.1);
+    expect(only.workingPressureBar, 207);
+    expect(only.tankMaterial, TankMaterial.aluminum);
+    expect(only.label, 'Bailout 1');
+    expect(only.o2Percent, 32);
+    expect(only.tankRole, TankRole.bailout);
+  });
+
+  test('saveItems replaces the item set and renumbers sort_order', () async {
+    final id = await repository.createConfig(name: 'Config');
+    await repository.saveItems(id, [
+      item(id: 'i1', configId: id, order: 0),
+      item(id: 'i2', configId: id, order: 1),
+      item(id: 'i3', configId: id, order: 2),
+    ]);
+
+    // Drop the middle item; survivors renumber from list position, not from
+    // whatever sortOrder the caller happened to pass.
+    await repository.saveItems(id, [
+      item(id: 'i3', configId: id, order: 99),
+      item(id: 'i1', configId: id, order: 99),
+    ]);
+
+    final config = await repository.getConfigById(id);
+    expect(config!.items.map((i) => i.id), ['i3', 'i1']);
+    expect(config.items.map((i) => i.sortOrder), [0, 1]);
+  });
+
+  test('saveItems writes deletion-log tombstones for removed items', () async {
+    final id = await repository.createConfig(name: 'Config');
+    await repository.saveItems(id, [
+      item(id: 'i1', configId: id, order: 0),
+      item(id: 'i2', configId: id, order: 1),
+    ]);
+
+    await repository.saveItems(id, [item(id: 'i1', configId: id, order: 0)]);
+
+    final tombstones = await db
+        .customSelect(
+          "SELECT record_id FROM deletion_log "
+          "WHERE entity_type = 'cylinderConfigItems'",
+        )
+        .get();
+    expect(
+      tombstones.map((r) => r.read<String>('record_id')),
+      contains('i2'),
+      reason: 'without a tombstone the row resurrects on the next sync pull',
+    );
+  });
+
+  test('deleteConfig removes its items and tombstones both levels', () async {
+    final id = await repository.createConfig(name: 'Config');
+    await repository.saveItems(id, [item(id: 'i1', configId: id)]);
+
+    await repository.deleteConfig(id);
+
+    expect(await repository.getConfigById(id), isNull);
+    final rows = await db
+        .customSelect('SELECT id FROM cylinder_config_items')
+        .get();
+    expect(rows, isEmpty);
+
+    final tombstones = await db
+        .customSelect('SELECT entity_type, record_id FROM deletion_log')
+        .get();
+    final pairs = tombstones
+        .map(
+          (r) =>
+              '${r.read<String>('entity_type')}:${r.read<String>('record_id')}',
+        )
+        .toSet();
+    expect(pairs, contains('cylinderConfigs:$id'));
+    expect(pairs, contains('cylinderConfigItems:i1'));
+  });
+
+  test('a config for a deleted unit survives as a generic gas plan', () async {
+    await seedUnit('rb-1', 'JJ');
+    final id = await repository.createConfig(
+      equipmentId: 'rb-1',
+      name: 'Trimix',
+    );
+
+    await db.customStatement("DELETE FROM equipment WHERE id = 'rb-1'");
+
+    final loaded = await repository.getConfigById(id);
+    expect(loaded, isNotNull);
+    expect(loaded!.equipmentId, isNull);
+    expect(loaded.isOwnedByUnit, isFalse);
+    expect(loaded.name, 'Trimix');
+  });
+
+  test('updateConfig persists renames and unit reassignment', () async {
+    await seedUnit('rb-1', 'JJ');
+    final id = await repository.createConfig(name: 'Old name');
+    final loaded = await repository.getConfigById(id);
+
+    await repository.updateConfig(
+      loaded!.copyWith(name: 'New name', equipmentId: 'rb-1'),
+    );
+
+    final again = await repository.getConfigById(id);
+    expect(again!.name, 'New name');
+    expect(again.equipmentId, 'rb-1');
+  });
+
+  test('an unknown persisted role degrades instead of throwing', () async {
+    final id = await repository.createConfig(name: 'Config');
+    final ts = now.millisecondsSinceEpoch;
+    await db.customStatement(
+      "INSERT INTO cylinder_config_items "
+      "(id, config_id, sort_order, tank_role, created_at, updated_at) "
+      "VALUES ('i1', '$id', 0, 'notARole', $ts, $ts)",
+    );
+
+    final loaded = await repository.getConfigById(id);
+    expect(loaded!.items.single.tankRole, TankRole.backGas);
+  });
+}

From 7195f18d63e8d33a1e886cc18ae0675044d883fd Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 18:11:22 -0400
Subject: [PATCH 14/20] Register cylinder configurations as synced entities
 (#804)

Both entities added across the 14 serializer sites and the sync service's
merge order, entityHasUpdatedAt, and parentRefs, modelled on
equipmentSetGeofences.

cylinderConfigs merges after equipment (its nullable FK parent) and
cylinderConfigItems after cylinderConfigs, so the deferred-FK commit always
sees the parent row. Both of cylinderConfigs' parent refs are declared
nullable: deleting a rebreather demotes its configurations to generic gas
plans, so a peer's config referencing a locally-deleted unit gets its
reference cleared rather than being skipped.

Registering both in sync_parent_refs_completeness_test's table map activates
the live-schema FK guard for them, which is what catches an unguarded
reference before it dangles at COMMIT.
---
 .../services/sync/sync_data_serializer.dart   | 122 +++++++++++++++
 lib/core/services/sync/sync_service.dart      |  26 ++++
 .../sync/cylinder_config_sync_test.dart       | 147 ++++++++++++++++++
 .../sync_parent_refs_completeness_test.dart   |   2 +
 4 files changed, 297 insertions(+)
 create mode 100644 test/core/services/sync/cylinder_config_sync_test.dart

diff --git a/lib/core/services/sync/sync_data_serializer.dart b/lib/core/services/sync/sync_data_serializer.dart
index 1705c327d3..b07a85b3b5 100644
--- a/lib/core/services/sync/sync_data_serializer.dart
+++ b/lib/core/services/sync/sync_data_serializer.dart
@@ -223,6 +223,8 @@ class SyncData {
   final List<Map<String, dynamic>> equipmentSets;
   final List<Map<String, dynamic>> equipmentSetItems;
   final List<Map<String, dynamic>> equipmentSetGeofences;
+  final List<Map<String, dynamic>> cylinderConfigs;
+  final List<Map<String, dynamic>> cylinderConfigItems;
   final List<Map<String, dynamic>> qualityFindings;
   final List<Map<String, dynamic>> equipmentAttributes;
   final List<Map<String, dynamic>> media;
@@ -295,6 +297,8 @@ class SyncData {
     this.equipmentSets = const [],
     this.equipmentSetItems = const [],
     this.equipmentSetGeofences = const [],
+    this.cylinderConfigs = const [],
+    this.cylinderConfigItems = const [],
     this.qualityFindings = const [],
     this.equipmentAttributes = const [],
     this.media = const [],
@@ -368,6 +372,8 @@ class SyncData {
     'equipmentSets': equipmentSets,
     'equipmentSetItems': equipmentSetItems,
     'equipmentSetGeofences': equipmentSetGeofences,
+    'cylinderConfigs': cylinderConfigs,
+    'cylinderConfigItems': cylinderConfigItems,
     'qualityFindings': qualityFindings,
     'equipmentAttributes': equipmentAttributes,
     'media': media,
@@ -442,6 +448,8 @@ class SyncData {
       equipmentSets: _parseList(json['equipmentSets']),
       equipmentSetItems: _parseList(json['equipmentSetItems']),
       equipmentSetGeofences: _parseList(json['equipmentSetGeofences']),
+      cylinderConfigs: _parseList(json['cylinderConfigs']),
+      cylinderConfigItems: _parseList(json['cylinderConfigItems']),
       qualityFindings: _parseList(json['qualityFindings']),
       equipmentAttributes: _parseList(json['equipmentAttributes']),
       media: _parseList(json['media']),
@@ -655,6 +663,18 @@ class SyncDataSerializer {
       blob: false,
       full: null,
     ),
+    (
+      key: 'cylinderConfigs',
+      table: _db.cylinderConfigs,
+      blob: false,
+      full: null,
+    ),
+    (
+      key: 'cylinderConfigItems',
+      table: _db.cylinderConfigItems,
+      blob: false,
+      full: null,
+    ),
     (
       key: 'qualityFindings',
       table: _db.qualityFindings,
@@ -1157,6 +1177,14 @@ class SyncDataSerializer {
         'equipmentSetGeofences',
         () => _exportEquipmentSetGeofences(hlcSince),
       ),
+      cylinderConfigs: await _safeExport(
+        'cylinderConfigs',
+        () => _exportCylinderConfigs(hlcSince),
+      ),
+      cylinderConfigItems: await _safeExport(
+        'cylinderConfigItems',
+        () => _exportCylinderConfigItems(hlcSince),
+      ),
       qualityFindings: await _safeExport(
         'qualityFindings',
         () => _exportQualityFindings(hlcSince),
@@ -1543,6 +1571,16 @@ class SyncDataSerializer {
           _db.equipmentSetGeofences,
         )..where((t) => t.id.equals(recordId))).getSingleOrNull();
         return row?.toJson();
+      case 'cylinderConfigs':
+        final row = await (_db.select(
+          _db.cylinderConfigs,
+        )..where((t) => t.id.equals(recordId))).getSingleOrNull();
+        return row?.toJson();
+      case 'cylinderConfigItems':
+        final row = await (_db.select(
+          _db.cylinderConfigItems,
+        )..where((t) => t.id.equals(recordId))).getSingleOrNull();
+        return row?.toJson();
       case 'qualityFindings':
         final row = await (_db.select(
           _db.qualityFindings,
@@ -1915,6 +1953,16 @@ class SyncDataSerializer {
           _db.equipmentSetGeofences,
         )..where((t) => t.id.isIn(idList))).get();
         return {for (final r in rows) r.id: r.toJson()};
+      case 'cylinderConfigs':
+        final rows = await (_db.select(
+          _db.cylinderConfigs,
+        )..where((t) => t.id.isIn(idList))).get();
+        return {for (final r in rows) r.id: r.toJson()};
+      case 'cylinderConfigItems':
+        final rows = await (_db.select(
+          _db.cylinderConfigItems,
+        )..where((t) => t.id.isIn(idList))).get();
+        return {for (final r in rows) r.id: r.toJson()};
       case 'qualityFindings':
         final rows = await (_db.select(
           _db.qualityFindings,
@@ -2210,6 +2258,20 @@ class SyncDataSerializer {
               EquipmentSetGeofence.fromJson(data).toCompanion(false),
             );
         return;
+      case 'cylinderConfigs':
+        await _db
+            .into(_db.cylinderConfigs)
+            .insertOnConflictUpdate(
+              CylinderConfig.fromJson(data).toCompanion(false),
+            );
+        return;
+      case 'cylinderConfigItems':
+        await _db
+            .into(_db.cylinderConfigItems)
+            .insertOnConflictUpdate(
+              CylinderConfigItem.fromJson(data).toCompanion(false),
+            );
+        return;
       case 'qualityFindings':
         await _db
             .into(_db.qualityFindings)
@@ -2726,6 +2788,26 @@ class SyncDataSerializer {
           ),
         );
         return;
+      case 'cylinderConfigs':
+        await _db.batch(
+          (b) => b.insertAllOnConflictUpdate(
+            _db.cylinderConfigs,
+            records
+                .map((r) => CylinderConfig.fromJson(r).toCompanion(false))
+                .toList(),
+          ),
+        );
+        return;
+      case 'cylinderConfigItems':
+        await _db.batch(
+          (b) => b.insertAllOnConflictUpdate(
+            _db.cylinderConfigItems,
+            records
+                .map((r) => CylinderConfigItem.fromJson(r).toCompanion(false))
+                .toList(),
+          ),
+        );
+        return;
       case 'qualityFindings':
         await _db.batch(
           (b) => b.insertAllOnConflictUpdate(
@@ -3446,6 +3528,10 @@ class SyncDataSerializer {
         return plain(_db.equipmentSets, _db.equipmentSets.id);
       case 'equipmentSetGeofences':
         return plain(_db.equipmentSetGeofences, _db.equipmentSetGeofences.id);
+      case 'cylinderConfigs':
+        return plain(_db.cylinderConfigs, _db.cylinderConfigs.id);
+      case 'cylinderConfigItems':
+        return plain(_db.cylinderConfigItems, _db.cylinderConfigItems.id);
       case 'qualityFindings':
         return plain(_db.qualityFindings, _db.qualityFindings.id);
       case 'equipmentAttributes':
@@ -3667,6 +3753,10 @@ class SyncDataSerializer {
         return _db.equipmentSets;
       case 'equipmentSetGeofences':
         return _db.equipmentSetGeofences;
+      case 'cylinderConfigs':
+        return _db.cylinderConfigs;
+      case 'cylinderConfigItems':
+        return _db.cylinderConfigItems;
       case 'qualityFindings':
         return _db.qualityFindings;
       case 'equipmentAttributes':
@@ -3827,6 +3917,16 @@ class SyncDataSerializer {
           _db.equipmentSetGeofences,
         )..where((t) => t.id.equals(recordId))).go();
         return;
+      case 'cylinderConfigs':
+        await (_db.delete(
+          _db.cylinderConfigs,
+        )..where((t) => t.id.equals(recordId))).go();
+        return;
+      case 'cylinderConfigItems':
+        await (_db.delete(
+          _db.cylinderConfigItems,
+        )..where((t) => t.id.equals(recordId))).go();
+        return;
       case 'qualityFindings':
         await (_db.delete(
           _db.qualityFindings,
@@ -4301,6 +4401,28 @@ class SyncDataSerializer {
     return rows.map((r) => r.toJson()).toList();
   }
 
+  Future<List<Map<String, dynamic>>> _exportCylinderConfigs(
+    String? hlcSince,
+  ) async {
+    final query = _db.select(_db.cylinderConfigs);
+    if (hlcSince != null) {
+      query.where((t) => t.hlc.isBiggerThanValue(hlcSince));
+    }
+    final rows = await query.get();
+    return rows.map((r) => r.toJson()).toList();
+  }
+
+  Future<List<Map<String, dynamic>>> _exportCylinderConfigItems(
+    String? hlcSince,
+  ) async {
+    final query = _db.select(_db.cylinderConfigItems);
+    if (hlcSince != null) {
+      query.where((t) => t.hlc.isBiggerThanValue(hlcSince));
+    }
+    final rows = await query.get();
+    return rows.map((r) => r.toJson()).toList();
+  }
+
   Future<List<Map<String, dynamic>>> _exportQualityFindings(
     String? hlcSince,
   ) async {
diff --git a/lib/core/services/sync/sync_service.dart b/lib/core/services/sync/sync_service.dart
index ef1066a097..8e0d0dcbcd 100644
--- a/lib/core/services/sync/sync_service.dart
+++ b/lib/core/services/sync/sync_service.dart
@@ -1143,6 +1143,19 @@ class SyncService {
             records: data.equipmentSetGeofences,
             hasUpdatedAt: true,
           ),
+          // References equipment (nullably); must apply after it.
+          (
+            type: 'cylinderConfigs',
+            records: data.cylinderConfigs,
+            hasUpdatedAt: true,
+          ),
+          // Child of cylinderConfigs; must apply after its parent so the
+          // deferred-FK commit sees the config row.
+          (
+            type: 'cylinderConfigItems',
+            records: data.cylinderConfigItems,
+            hasUpdatedAt: true,
+          ),
           // Child of equipment; must apply after its parent so the
           // deferred-FK commit sees the equipment row.
           (
@@ -1815,6 +1828,8 @@ class SyncService {
     'equipmentSets': true,
     'equipmentSetItems': false,
     'equipmentSetGeofences': true,
+    'cylinderConfigs': true,
+    'cylinderConfigItems': true,
     'qualityFindings': true,
     'equipmentAttributes': true,
     'divePlanEquipment': false,
@@ -2011,6 +2026,17 @@ class SyncService {
     'equipmentSetGeofences': [
       (field: 'setId', parent: 'equipmentSets', nullable: false),
     ],
+    // equipmentId is nullable by design: deleting a rebreather demotes its
+    // configurations to generic gas plans (ON DELETE SET NULL) rather than
+    // destroying them, so a peer's config referencing a locally-deleted unit
+    // must have the reference cleared, not be skipped.
+    'cylinderConfigs': [
+      (field: 'diverId', parent: 'divers', nullable: true),
+      (field: 'equipmentId', parent: 'equipment', nullable: true),
+    ],
+    'cylinderConfigItems': [
+      (field: 'configId', parent: 'cylinderConfigs', nullable: false),
+    ],
     'divePlanEquipment': [
       (field: 'planId', parent: 'divePlans', nullable: false),
       (field: 'equipmentId', parent: 'equipment', nullable: false),
diff --git a/test/core/services/sync/cylinder_config_sync_test.dart b/test/core/services/sync/cylinder_config_sync_test.dart
new file mode 100644
index 0000000000..f6ebf3ee07
--- /dev/null
+++ b/test/core/services/sync/cylinder_config_sync_test.dart
@@ -0,0 +1,147 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/services/sync/sync_data_serializer.dart';
+import 'package:submersion/core/services/sync/sync_service.dart';
+
+import '../../../helpers/test_database.dart';
+
+void main() {
+  late SyncDataSerializer serializer;
+
+  setUp(() async {
+    await setUpTestDatabase();
+    serializer = SyncDataSerializer();
+  });
+  tearDown(tearDownTestDatabase);
+
+  Future<void> seedUnit(String id) => serializer.upsertRecord('equipment', {
+    'id': id,
+    'name': 'JJ-CCR',
+    'type': 'rebreather',
+    'status': 'active',
+    'purchaseCurrency': 'USD',
+    'notes': '',
+    'isActive': true,
+    'createdAt': 1000,
+    'updatedAt': 1000,
+  });
+
+  Future<void> seedConfig(String id, {String? equipmentId}) =>
+      serializer.upsertRecord('cylinderConfigs', {
+        'id': id,
+        'equipmentId': equipmentId,
+        'name': 'JJ trimix',
+        'description': '',
+        'sortOrder': 0,
+        'createdAt': 1000,
+        'updatedAt': 1000,
+      });
+
+  Future<void> seedItem(
+    String id,
+    String configId, {
+    String role = 'diluent',
+    double o2 = 18,
+    double he = 45,
+  }) => serializer.upsertRecord('cylinderConfigItems', {
+    'id': id,
+    'configId': configId,
+    'sortOrder': 0,
+    'tankRole': role,
+    'o2Percent': o2,
+    'hePercent': he,
+    'createdAt': 1000,
+    'updatedAt': 1000,
+  });
+
+  test('a config and its items export intact', () async {
+    await seedUnit('rb-1');
+    await seedConfig('c1', equipmentId: 'rb-1');
+    await seedItem('i1', 'c1');
+
+    final payload = await serializer.exportData(
+      deviceId: 'test-device',
+      deletions: const [],
+    );
+
+    final configs = payload.data.cylinderConfigs;
+    expect(configs.map((c) => c['id']), contains('c1'));
+    expect(configs.single['equipmentId'], 'rb-1');
+
+    final items = payload.data.cylinderConfigItems;
+    expect(items.map((i) => i['id']), contains('i1'));
+    expect(items.single['o2Percent'], 18);
+    expect(items.single['hePercent'], 45);
+    expect(items.single['tankRole'], 'diluent');
+  });
+
+  test('a generic gas plan with no owning unit round-trips', () async {
+    await seedConfig('c1');
+    await seedItem('i1', 'c1', role: 'backGas', o2: 21, he: 0);
+
+    final payload = await serializer.exportData(
+      deviceId: 'test-device',
+      deletions: const [],
+    );
+
+    expect(payload.data.cylinderConfigs.single['equipmentId'], isNull);
+  });
+
+  test('the exported payload survives a JSON round-trip', () async {
+    await seedConfig('c1');
+    await seedItem('i1', 'c1');
+
+    final payload = await serializer.exportData(
+      deviceId: 'test-device',
+      deletions: const [],
+    );
+    final revived = SyncData.fromJson(payload.data.toJson());
+
+    expect(revived.cylinderConfigs.map((c) => c['id']), contains('c1'));
+    expect(revived.cylinderConfigItems.map((i) => i['id']), contains('i1'));
+  });
+
+  test('parentRefs guards every FK to a deletable parent', () {
+    // The merge applies remote records in a deferred-FK transaction. An
+    // unguarded FK to a locally-deleted parent dangles and fails the whole
+    // sync at COMMIT (SqliteException 787). Merge ORDER is enforced by the
+    // inline list in SyncService plus the no-silent-drift check in
+    // sync_parent_refs_completeness_test; this pins the guards themselves.
+    final configRefs = SyncService.parentRefs['cylinderConfigs']!;
+    expect(
+      configRefs.map((r) => '${r.field}->${r.parent}:${r.nullable}'),
+      containsAll([
+        'diverId->divers:true',
+        // Nullable by design: deleting a rebreather demotes its configs to
+        // generic gas plans rather than destroying them, so the reference is
+        // cleared instead of the row being skipped.
+        'equipmentId->equipment:true',
+      ]),
+    );
+
+    final itemRefs = SyncService.parentRefs['cylinderConfigItems']!;
+    expect(
+      itemRefs.map((r) => '${r.field}->${r.parent}:${r.nullable}'),
+      contains('configId->cylinderConfigs:false'),
+    );
+  });
+
+  test('both entities declare updatedAt so HLC comparison works', () {
+    expect(SyncService.entityHasUpdatedAt['cylinderConfigs'], isTrue);
+    expect(SyncService.entityHasUpdatedAt['cylinderConfigItems'], isTrue);
+  });
+
+  test('deleting a config through the serializer removes it', () async {
+    await seedConfig('c1');
+    await seedItem('i1', 'c1');
+
+    await serializer.deleteRecord('cylinderConfigItems', 'i1');
+    await serializer.deleteRecord('cylinderConfigs', 'c1');
+
+    final payload = await serializer.exportData(
+      deviceId: 'test-device',
+      deletions: const [],
+    );
+    expect(payload.data.cylinderConfigs, isEmpty);
+    expect(payload.data.cylinderConfigItems, isEmpty);
+  });
+}
diff --git a/test/core/services/sync/sync_parent_refs_completeness_test.dart b/test/core/services/sync/sync_parent_refs_completeness_test.dart
index 41b4249a40..8ae3690f7b 100644
--- a/test/core/services/sync/sync_parent_refs_completeness_test.dart
+++ b/test/core/services/sync/sync_parent_refs_completeness_test.dart
@@ -32,6 +32,8 @@ void main() {
     'equipment_sets': 'equipmentSets',
     'equipment_set_items': 'equipmentSetItems',
     'equipment_set_geofences': 'equipmentSetGeofences',
+    'cylinder_configs': 'cylinderConfigs',
+    'cylinder_config_items': 'cylinderConfigItems',
     'quality_findings': 'qualityFindings',
     'dive_types': 'diveTypes',
     'tank_presets': 'tankPresets',

From 07c4a970004b1074310f6bcd0e1a81e2ad9c9871 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 18:21:01 -0400
Subject: [PATCH 15/20] Add cylinder configuration providers (#804)

Repository, diver-scoped list, per-unit family, and single-config family,
following equipment_set_providers. The list provider hydrates items eagerly
because every surface that lists configurations shows a cylinder count, so a
lazy variant would just add a round trip per row.

Full suite passes at 14861: adding a provider dependency breaks consumer tests
that analyze cannot catch, so the whole suite is the only real check.
---
 .../providers/cylinder_config_providers.dart  |  62 +++++++++
 .../cylinder_config_providers_test.dart       | 127 ++++++++++++++++++
 2 files changed, 189 insertions(+)
 create mode 100644 lib/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart
 create mode 100644 test/features/cylinder_configs/presentation/cylinder_config_providers_test.dart

diff --git a/lib/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart b/lib/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart
new file mode 100644
index 0000000000..9bcc011e3b
--- /dev/null
+++ b/lib/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart
@@ -0,0 +1,62 @@
+import 'package:submersion/core/providers/provider.dart';
+
+import 'package:submersion/features/cylinder_configs/data/repositories/cylinder_config_repository.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config.dart';
+import 'package:submersion/features/divers/presentation/providers/diver_providers.dart';
+
+/// Repository provider
+final cylinderConfigRepositoryProvider = Provider<CylinderConfigRepository>((
+  ref,
+) {
+  return CylinderConfigRepository();
+});
+
+/// Every configuration belonging to the active diver, items hydrated.
+///
+/// Items are included eagerly because every surface that lists configurations
+/// shows a cylinder count or the roles, so a lazy variant would just mean an
+/// extra round trip on each row.
+final cylinderConfigsProvider = FutureProvider<List<CylinderConfig>>((
+  ref,
+) async {
+  final repository = ref.watch(cylinderConfigRepositoryProvider);
+  final validatedDiverId = await ref.watch(
+    validatedCurrentDiverIdProvider.future,
+  );
+  return repository.getAllConfigs(
+    diverId: validatedDiverId,
+    includeItems: true,
+  );
+});
+
+/// Configurations owned by one rebreather.
+final cylinderConfigsForEquipmentProvider =
+    FutureProvider.family<List<CylinderConfig>, String>((
+      ref,
+      equipmentId,
+    ) async {
+      final repository = ref.watch(cylinderConfigRepositoryProvider);
+      return repository.getConfigsForEquipment(equipmentId);
+    });
+
+/// A single configuration with its cylinders.
+final cylinderConfigProvider = FutureProvider.family<CylinderConfig?, String>((
+  ref,
+  id,
+) async {
+  final repository = ref.watch(cylinderConfigRepositoryProvider);
+  return repository.getConfigById(id);
+});
+
+/// Invalidates every configuration view. Call after a create, update, delete,
+/// or item save so the list, the owning unit's card, and any open detail all
+/// refetch together.
+void invalidateCylinderConfigs(Ref ref, {String? configId}) {
+  ref.invalidate(cylinderConfigsProvider);
+  ref.invalidate(cylinderConfigsForEquipmentProvider);
+  if (configId != null) {
+    ref.invalidate(cylinderConfigProvider(configId));
+  } else {
+    ref.invalidate(cylinderConfigProvider);
+  }
+}
diff --git a/test/features/cylinder_configs/presentation/cylinder_config_providers_test.dart b/test/features/cylinder_configs/presentation/cylinder_config_providers_test.dart
new file mode 100644
index 0000000000..ee3e6b9dcd
--- /dev/null
+++ b/test/features/cylinder_configs/presentation/cylinder_config_providers_test.dart
@@ -0,0 +1,127 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+// Both names collide with the generated Drift row classes; the domain
+// entities are the ones under test here.
+import 'package:submersion/core/database/database.dart'
+    hide CylinderConfig, CylinderConfigItem;
+import 'package:submersion/core/providers/provider.dart';
+import 'package:submersion/features/cylinder_configs/data/repositories/cylinder_config_repository.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+import 'package:submersion/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart';
+import 'package:submersion/features/divers/presentation/providers/diver_providers.dart';
+
+import '../../../helpers/test_database.dart';
+
+void main() {
+  late AppDatabase db;
+  late CylinderConfigRepository repo;
+  final now = DateTime.utc(2026, 8, 5);
+
+  setUp(() async {
+    db = await setUpTestDatabase();
+    repo = CylinderConfigRepository();
+    final t = now.millisecondsSinceEpoch;
+    await db
+        .into(db.divers)
+        .insert(
+          DiversCompanion.insert(
+            id: 'd1',
+            name: 'd1',
+            createdAt: t,
+            updatedAt: t,
+          ),
+        );
+    await db
+        .into(db.divers)
+        .insert(
+          DiversCompanion.insert(
+            id: 'd2',
+            name: 'd2',
+            createdAt: t,
+            updatedAt: t,
+          ),
+        );
+    await db
+        .into(db.equipment)
+        .insert(
+          EquipmentCompanion.insert(
+            id: 'rb-1',
+            name: 'JJ',
+            type: 'rebreather',
+            createdAt: t,
+            updatedAt: t,
+          ),
+        );
+  });
+  tearDown(tearDownTestDatabase);
+
+  ProviderContainer makeContainer() {
+    final container = ProviderContainer(
+      overrides: [
+        validatedCurrentDiverIdProvider.overrideWith((ref) async => 'd1'),
+      ],
+    );
+    addTearDown(container.dispose);
+    return container;
+  }
+
+  test(
+    "cylinderConfigsProvider returns only the active diver's configs",
+    () async {
+      await repo.createConfig(diverId: 'd1', name: 'Mine');
+      await repo.createConfig(diverId: 'd2', name: 'Someone else');
+
+      final configs = await makeContainer().read(
+        cylinderConfigsProvider.future,
+      );
+      expect(configs.map((c) => c.name), ['Mine']);
+    },
+  );
+
+  test('cylinderConfigsProvider hydrates items', () async {
+    final id = await repo.createConfig(diverId: 'd1', name: 'JJ trimix');
+    await repo.saveItems(id, [
+      CylinderConfigItem(
+        id: 'i1',
+        configId: id,
+        tankRole: TankRole.diluent,
+        o2Percent: 18,
+        hePercent: 45,
+        createdAt: now,
+        updatedAt: now,
+      ),
+    ]);
+
+    final configs = await makeContainer().read(cylinderConfigsProvider.future);
+    expect(configs.single.cylinderCount, 1);
+    expect(configs.single.items.single.tankRole, TankRole.diluent);
+  });
+
+  test('cylinderConfigsForEquipmentProvider filters by unit', () async {
+    await repo.createConfig(diverId: 'd1', equipmentId: 'rb-1', name: 'Owned');
+    await repo.createConfig(diverId: 'd1', name: 'Generic');
+
+    final owned = await makeContainer().read(
+      cylinderConfigsForEquipmentProvider('rb-1').future,
+    );
+    expect(owned.map((c) => c.name), ['Owned']);
+  });
+
+  test('cylinderConfigProvider returns null for an unknown id', () async {
+    final config = await makeContainer().read(
+      cylinderConfigProvider('nope').future,
+    );
+    expect(config, isNull);
+  });
+
+  test('invalidating the list provider refetches', () async {
+    final container = makeContainer();
+    await repo.createConfig(diverId: 'd1', name: 'First');
+    expect((await container.read(cylinderConfigsProvider.future)).length, 1);
+
+    await repo.createConfig(diverId: 'd1', name: 'Second');
+    container.invalidate(cylinderConfigsProvider);
+
+    expect((await container.read(cylinderConfigsProvider.future)).length, 2);
+  });
+}

From 4488b63cd3fc336a40ccbe9803138f69a9ff9cbd Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 18:27:21 -0400
Subject: [PATCH 16/20] Add cylinder configuration list and edit pages (#804)

New feature directory lib/features/cylinder_configs with a list page grouping
configurations by owning rebreather (generic gas plans last), a reorderable
edit page, and a per-cylinder editor whose preset picker seeds the spec fields
rather than holding a live reference.

Routes are registered under /equipment/cylinder-configs, placed before the
':equipmentId' catch-all which would otherwise swallow the path segment.

Fixes a crash the widget tests surfaced: the owning-unit dropdown passed a
value from the route while the diver-scoped equipment list was still loading,
and a Flutter dropdown asserts exactly one item matches its value. It now
falls back to the generic option until the unit appears, which also covers a
deleted owning unit. Adds 19 UI strings plus two pluralized apply-result
strings across all 11 locales.
---
 lib/core/router/app_router.dart               |  25 ++
 .../pages/cylinder_config_edit_page.dart      | 232 ++++++++++++++++++
 .../pages/cylinder_config_list_page.dart      | 145 +++++++++++
 .../providers/cylinder_config_providers.dart  |   2 +-
 .../widgets/cylinder_config_item_editor.dart  | 224 +++++++++++++++++
 lib/l10n/arb/app_ar.arb                       |  35 +++
 lib/l10n/arb/app_de.arb                       |  35 +++
 lib/l10n/arb/app_en.arb                       |  35 +++
 lib/l10n/arb/app_es.arb                       |  35 +++
 lib/l10n/arb/app_fr.arb                       |  35 +++
 lib/l10n/arb/app_he.arb                       |  35 +++
 lib/l10n/arb/app_hu.arb                       |  35 +++
 lib/l10n/arb/app_it.arb                       |  35 +++
 lib/l10n/arb/app_localizations.dart           | 126 ++++++++++
 lib/l10n/arb/app_localizations_ar.dart        |  82 +++++++
 lib/l10n/arb/app_localizations_de.dart        |  82 +++++++
 lib/l10n/arb/app_localizations_en.dart        |  82 +++++++
 lib/l10n/arb/app_localizations_es.dart        |  82 +++++++
 lib/l10n/arb/app_localizations_fr.dart        |  82 +++++++
 lib/l10n/arb/app_localizations_he.dart        |  81 ++++++
 lib/l10n/arb/app_localizations_hu.dart        |  80 ++++++
 lib/l10n/arb/app_localizations_it.dart        |  82 +++++++
 lib/l10n/arb/app_localizations_nl.dart        |  82 +++++++
 lib/l10n/arb/app_localizations_pt.dart        |  82 +++++++
 lib/l10n/arb/app_localizations_zh.dart        |  77 ++++++
 lib/l10n/arb/app_nl.arb                       |  35 +++
 lib/l10n/arb/app_pt.arb                       |  35 +++
 lib/l10n/arb/app_zh.arb                       |  35 +++
 .../cylinder_config_edit_page_test.dart       | 165 +++++++++++++
 29 files changed, 2197 insertions(+), 1 deletion(-)
 create mode 100644 lib/features/cylinder_configs/presentation/pages/cylinder_config_edit_page.dart
 create mode 100644 lib/features/cylinder_configs/presentation/pages/cylinder_config_list_page.dart
 create mode 100644 lib/features/cylinder_configs/presentation/widgets/cylinder_config_item_editor.dart
 create mode 100644 test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart

diff --git a/lib/core/router/app_router.dart b/lib/core/router/app_router.dart
index ef62b5d4d3..bd88816998 100644
--- a/lib/core/router/app_router.dart
+++ b/lib/core/router/app_router.dart
@@ -63,6 +63,8 @@ import 'package:submersion/features/dive_sites/presentation/pages/site_match_rev
 import 'package:submersion/features/equipment/presentation/pages/equipment_list_page.dart';
 import 'package:submersion/features/equipment/presentation/pages/equipment_detail_page.dart';
 import 'package:submersion/features/equipment/presentation/pages/equipment_edit_page.dart';
+import 'package:submersion/features/cylinder_configs/presentation/pages/cylinder_config_edit_page.dart';
+import 'package:submersion/features/cylinder_configs/presentation/pages/cylinder_config_list_page.dart';
 import 'package:submersion/features/equipment/presentation/pages/equipment_set_list_page.dart';
 import 'package:submersion/features/equipment/presentation/pages/service_kind_list_page.dart';
 import 'package:submersion/features/equipment/presentation/pages/equipment_set_detail_page.dart';
@@ -510,6 +512,29 @@ final appRouterProvider = Provider<GoRouter>((ref) {
                 name: 'manageServiceTypes',
                 builder: (context, state) => const ServiceKindListPage(),
               ),
+              // Must precede the ':equipmentId' catch-all below, which would
+              // otherwise swallow 'cylinder-configs' as an equipment id.
+              GoRoute(
+                path: 'cylinder-configs',
+                name: 'cylinderConfigs',
+                builder: (context, state) => const CylinderConfigListPage(),
+                routes: [
+                  GoRoute(
+                    path: 'new',
+                    name: 'newCylinderConfig',
+                    builder: (context, state) => CylinderConfigEditPage(
+                      equipmentId: state.uri.queryParameters['equipmentId'],
+                    ),
+                  ),
+                  GoRoute(
+                    path: ':configId',
+                    name: 'cylinderConfigEdit',
+                    builder: (context, state) => CylinderConfigEditPage(
+                      configId: state.pathParameters['configId'],
+                    ),
+                  ),
+                ],
+              ),
               GoRoute(
                 path: ':equipmentId',
                 name: 'equipmentDetail',
diff --git a/lib/features/cylinder_configs/presentation/pages/cylinder_config_edit_page.dart b/lib/features/cylinder_configs/presentation/pages/cylinder_config_edit_page.dart
new file mode 100644
index 0000000000..e2dda4d949
--- /dev/null
+++ b/lib/features/cylinder_configs/presentation/pages/cylinder_config_edit_page.dart
@@ -0,0 +1,232 @@
+import 'package:flutter/material.dart';
+import 'package:uuid/uuid.dart';
+
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/core/providers/provider.dart';
+import 'package:submersion/core/utils/unit_formatter.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+import 'package:submersion/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart';
+import 'package:submersion/features/cylinder_configs/presentation/widgets/cylinder_config_item_editor.dart';
+import 'package:submersion/features/equipment/domain/entities/equipment_item.dart';
+import 'package:submersion/features/equipment/presentation/providers/equipment_providers.dart';
+import 'package:submersion/features/settings/presentation/providers/settings_providers.dart';
+import 'package:submersion/l10n/l10n_extension.dart';
+
+/// Creates or edits one configuration. Cylinders are a reorderable list;
+/// their sortOrder is derived from list position on save.
+class CylinderConfigEditPage extends ConsumerStatefulWidget {
+  const CylinderConfigEditPage({super.key, this.configId, this.equipmentId});
+
+  /// Null when creating.
+  final String? configId;
+
+  /// Pre-selects the owning unit when arriving from a rebreather's card.
+  final String? equipmentId;
+
+  @override
+  ConsumerState<CylinderConfigEditPage> createState() =>
+      _CylinderConfigEditPageState();
+}
+
+class _CylinderConfigEditPageState
+    extends ConsumerState<CylinderConfigEditPage> {
+  final _formKey = GlobalKey<FormState>();
+  final _uuid = const Uuid();
+  final _nameController = TextEditingController();
+
+  List<CylinderConfigItem> _items = [];
+  String? _equipmentId;
+  bool _loaded = false;
+  bool _saving = false;
+
+  @override
+  void initState() {
+    super.initState();
+    _equipmentId = widget.equipmentId;
+    if (widget.configId == null) {
+      _loaded = true;
+    } else {
+      _load();
+    }
+  }
+
+  @override
+  void dispose() {
+    _nameController.dispose();
+    super.dispose();
+  }
+
+  Future<void> _load() async {
+    final config = await ref.read(
+      cylinderConfigProvider(widget.configId!).future,
+    );
+    if (!mounted) return;
+    setState(() {
+      _nameController.text = config?.name ?? '';
+      _equipmentId = config?.equipmentId ?? widget.equipmentId;
+      _items = [...?config?.items];
+      _loaded = true;
+    });
+  }
+
+  void _addCylinder() {
+    final now = DateTime.now();
+    setState(() {
+      _items = [
+        ..._items,
+        CylinderConfigItem(
+          id: _uuid.v4(),
+          configId: widget.configId ?? '',
+          sortOrder: _items.length,
+          tankRole: TankRole.bailout,
+          createdAt: now,
+          updatedAt: now,
+        ),
+      ];
+    });
+  }
+
+  Future<void> _save() async {
+    if (!(_formKey.currentState?.validate() ?? false)) return;
+    setState(() => _saving = true);
+
+    final repository = ref.read(cylinderConfigRepositoryProvider);
+    final diverId = await ref
+        .read(cylinderConfigsProvider.future)
+        .then((configs) => configs.isNotEmpty ? configs.first.diverId : null);
+
+    var id = widget.configId;
+    if (id == null) {
+      id = await repository.createConfig(
+        diverId: diverId,
+        equipmentId: _equipmentId,
+        name: _nameController.text.trim(),
+      );
+    } else {
+      final existing = await repository.getConfigById(id);
+      if (existing != null) {
+        await repository.updateConfig(
+          existing.copyWith(
+            name: _nameController.text.trim(),
+            equipmentId: _equipmentId,
+            clearEquipmentId: _equipmentId == null,
+          ),
+        );
+      }
+    }
+    await repository.saveItems(id, _items);
+
+    if (!mounted) return;
+    invalidateCylinderConfigs(ref, configId: id);
+    Navigator.of(context).pop();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final l10n = context.l10n;
+    final units = UnitFormatter(ref.watch(settingsProvider));
+    final equipment = ref.watch(allEquipmentProvider).valueOrNull ?? const [];
+    final rebreathers = equipment
+        .where((e) => e.type == EquipmentType.rebreather)
+        .toList();
+
+    return Scaffold(
+      appBar: AppBar(
+        title: Text(
+          widget.configId == null
+              ? l10n.cylinderConfigs_new
+              : l10n.cylinderConfigs_title,
+        ),
+        actions: [
+          TextButton(
+            onPressed: _saving ? null : _save,
+            child: Text(MaterialLocalizations.of(context).saveButtonLabel),
+          ),
+        ],
+      ),
+      body: !_loaded
+          ? const Center(child: CircularProgressIndicator())
+          : Form(
+              key: _formKey,
+              child: ListView(
+                padding: const EdgeInsets.all(16),
+                children: [
+                  TextFormField(
+                    controller: _nameController,
+                    decoration: InputDecoration(
+                      labelText: l10n.cylinderConfigs_name,
+                    ),
+                    validator: (value) => (value ?? '').trim().isEmpty
+                        ? l10n.cylinderConfigs_nameRequired
+                        : null,
+                  ),
+                  const SizedBox(height: 12),
+                  DropdownButtonFormField<String?>(
+                    // The equipment list loads asynchronously, so on the first
+                    // frame it is empty even when _equipmentId is set from the
+                    // route. A dropdown value with no matching item throws, so
+                    // fall back to the generic option until the unit appears
+                    // (also covers an owning unit that was deleted).
+                    initialValue:
+                        rebreathers.any((unit) => unit.id == _equipmentId)
+                        ? _equipmentId
+                        : null,
+                    decoration: InputDecoration(
+                      labelText: l10n.cylinderConfigs_forUnit,
+                    ),
+                    items: [
+                      DropdownMenuItem<String?>(
+                        value: null,
+                        child: Text(l10n.cylinderConfigs_noUnit),
+                      ),
+                      for (final EquipmentItem unit in rebreathers)
+                        DropdownMenuItem<String?>(
+                          value: unit.id,
+                          child: Text(unit.name),
+                        ),
+                    ],
+                    onChanged: (value) => setState(() => _equipmentId = value),
+                  ),
+                  const Divider(height: 32),
+                  ReorderableListView(
+                    shrinkWrap: true,
+                    physics: const NeverScrollableScrollPhysics(),
+                    // onReorderItem already adjusts newIndex for the removed
+                    // item, so no oldIndex/newIndex correction is needed.
+                    onReorderItem: (oldIndex, newIndex) => setState(() {
+                      final next = [..._items];
+                      next.insert(newIndex, next.removeAt(oldIndex));
+                      _items = next;
+                    }),
+                    children: [
+                      for (var i = 0; i < _items.length; i++)
+                        Padding(
+                          key: ValueKey(_items[i].id),
+                          padding: const EdgeInsets.only(bottom: 8),
+                          child: CylinderConfigItemEditor(
+                            item: _items[i],
+                            units: units,
+                            onChanged: (updated) => setState(() {
+                              final next = [..._items];
+                              next[i] = updated;
+                              _items = next;
+                            }),
+                            onRemove: () => setState(() {
+                              final next = [..._items]..removeAt(i);
+                              _items = next;
+                            }),
+                          ),
+                        ),
+                    ],
+                  ),
+                  TextButton.icon(
+                    onPressed: _addCylinder,
+                    icon: const Icon(Icons.add),
+                    label: Text(l10n.cylinderConfigs_addCylinder),
+                  ),
+                ],
+              ),
+            ),
+    );
+  }
+}
diff --git a/lib/features/cylinder_configs/presentation/pages/cylinder_config_list_page.dart b/lib/features/cylinder_configs/presentation/pages/cylinder_config_list_page.dart
new file mode 100644
index 0000000000..47cda0c3a0
--- /dev/null
+++ b/lib/features/cylinder_configs/presentation/pages/cylinder_config_list_page.dart
@@ -0,0 +1,145 @@
+import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
+
+import 'package:submersion/core/providers/provider.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config.dart';
+import 'package:submersion/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart';
+import 'package:submersion/features/equipment/presentation/providers/equipment_providers.dart';
+import 'package:submersion/l10n/arb/app_localizations.dart';
+import 'package:submersion/l10n/l10n_extension.dart';
+
+/// Lists every configuration, grouped by owning rebreather with generic gas
+/// plans last.
+class CylinderConfigListPage extends ConsumerWidget {
+  const CylinderConfigListPage({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final l10n = context.l10n;
+    final configsAsync = ref.watch(cylinderConfigsProvider);
+    final equipmentAsync = ref.watch(allEquipmentProvider);
+
+    return Scaffold(
+      appBar: AppBar(title: Text(l10n.cylinderConfigs_title)),
+      body: configsAsync.when(
+        loading: () => const Center(child: CircularProgressIndicator()),
+        error: (error, _) => Center(child: Text('$error')),
+        data: (configs) {
+          if (configs.isEmpty) {
+            return _EmptyState(l10n: l10n);
+          }
+
+          final unitNames = <String, String>{
+            for (final item in equipmentAsync.valueOrNull ?? const [])
+              item.id: item.name,
+          };
+
+          final owned = <String, List<CylinderConfig>>{};
+          final generic = <CylinderConfig>[];
+          for (final config in configs) {
+            final unitId = config.equipmentId;
+            if (unitId == null) {
+              generic.add(config);
+            } else {
+              owned.putIfAbsent(unitId, () => []).add(config);
+            }
+          }
+
+          return ListView(
+            children: [
+              for (final entry in owned.entries) ...[
+                _GroupHeader(
+                  label: unitNames[entry.key] ?? l10n.cylinderConfigs_forUnit,
+                ),
+                for (final config in entry.value) _ConfigTile(config: config),
+              ],
+              if (generic.isNotEmpty) ...[
+                _GroupHeader(label: l10n.cylinderConfigs_gasPlans),
+                for (final config in generic) _ConfigTile(config: config),
+              ],
+            ],
+          );
+        },
+      ),
+      floatingActionButton: FloatingActionButton.extended(
+        onPressed: () => context.push('/equipment/cylinder-configs/new'),
+        icon: const Icon(Icons.add),
+        label: Text(l10n.cylinderConfigs_new),
+      ),
+    );
+  }
+}
+
+class _EmptyState extends StatelessWidget {
+  const _EmptyState({required this.l10n});
+
+  final AppLocalizations l10n;
+
+  @override
+  Widget build(BuildContext context) {
+    return Center(
+      child: Padding(
+        padding: const EdgeInsets.all(32),
+        child: Column(
+          mainAxisAlignment: MainAxisAlignment.center,
+          children: [
+            Icon(
+              Icons.propane_tank_outlined,
+              size: 48,
+              color: Theme.of(context).colorScheme.onSurfaceVariant,
+            ),
+            const SizedBox(height: 12),
+            Text(
+              l10n.cylinderConfigs_empty,
+              style: Theme.of(context).textTheme.titleMedium,
+            ),
+            const SizedBox(height: 8),
+            Text(
+              l10n.cylinderConfigs_emptyBody,
+              textAlign: TextAlign.center,
+              style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                color: Theme.of(context).colorScheme.onSurfaceVariant,
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}
+
+class _GroupHeader extends StatelessWidget {
+  const _GroupHeader({required this.label});
+
+  final String label;
+
+  @override
+  Widget build(BuildContext context) {
+    return Padding(
+      padding: const EdgeInsets.fromLTRB(16, 16, 16, 4),
+      child: Text(
+        label,
+        style: Theme.of(context).textTheme.labelLarge?.copyWith(
+          color: Theme.of(context).colorScheme.primary,
+        ),
+      ),
+    );
+  }
+}
+
+class _ConfigTile extends StatelessWidget {
+  const _ConfigTile({required this.config});
+
+  final CylinderConfig config;
+
+  @override
+  Widget build(BuildContext context) {
+    final roles = config.items.map((i) => i.tankRole.displayName).join(', ');
+    return ListTile(
+      title: Text(config.name),
+      subtitle: roles.isEmpty ? null : Text(roles),
+      trailing: Text('${config.cylinderCount}'),
+      onTap: () => context.push('/equipment/cylinder-configs/${config.id}'),
+    );
+  }
+}
diff --git a/lib/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart b/lib/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart
index 9bcc011e3b..0d3991e153 100644
--- a/lib/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart
+++ b/lib/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart
@@ -51,7 +51,7 @@ final cylinderConfigProvider = FutureProvider.family<CylinderConfig?, String>((
 /// Invalidates every configuration view. Call after a create, update, delete,
 /// or item save so the list, the owning unit's card, and any open detail all
 /// refetch together.
-void invalidateCylinderConfigs(Ref ref, {String? configId}) {
+void invalidateCylinderConfigs(WidgetRef ref, {String? configId}) {
   ref.invalidate(cylinderConfigsProvider);
   ref.invalidate(cylinderConfigsForEquipmentProvider);
   if (configId != null) {
diff --git a/lib/features/cylinder_configs/presentation/widgets/cylinder_config_item_editor.dart b/lib/features/cylinder_configs/presentation/widgets/cylinder_config_item_editor.dart
new file mode 100644
index 0000000000..8f593e8b44
--- /dev/null
+++ b/lib/features/cylinder_configs/presentation/widgets/cylinder_config_item_editor.dart
@@ -0,0 +1,224 @@
+import 'package:flutter/material.dart';
+
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/core/providers/provider.dart';
+import 'package:submersion/core/utils/unit_formatter.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+import 'package:submersion/features/tank_presets/domain/entities/tank_preset_entity.dart';
+import 'package:submersion/features/tank_presets/presentation/providers/tank_preset_providers.dart';
+import 'package:submersion/l10n/l10n_extension.dart';
+
+/// One editable cylinder inside a configuration.
+///
+/// Spec fields are plain editable values, not a live preset reference: the
+/// preset picker only seeds them. A configuration records what the diver
+/// actually dives, so a later preset edit must not rewrite it.
+class CylinderConfigItemEditor extends ConsumerStatefulWidget {
+  const CylinderConfigItemEditor({
+    super.key,
+    required this.item,
+    required this.units,
+    required this.onChanged,
+    required this.onRemove,
+  });
+
+  final CylinderConfigItem item;
+  final UnitFormatter units;
+  final ValueChanged<CylinderConfigItem> onChanged;
+  final VoidCallback onRemove;
+
+  @override
+  ConsumerState<CylinderConfigItemEditor> createState() =>
+      _CylinderConfigItemEditorState();
+}
+
+class _CylinderConfigItemEditorState
+    extends ConsumerState<CylinderConfigItemEditor> {
+  late TextEditingController _o2;
+  late TextEditingController _he;
+  late TextEditingController _label;
+
+  @override
+  void initState() {
+    super.initState();
+    _o2 = TextEditingController(text: _trim(widget.item.o2Percent));
+    _he = TextEditingController(text: _trim(widget.item.hePercent));
+    _label = TextEditingController(text: widget.item.label ?? '');
+  }
+
+  @override
+  void dispose() {
+    _o2.dispose();
+    _he.dispose();
+    _label.dispose();
+    super.dispose();
+  }
+
+  static String _trim(double value) =>
+      value == value.roundToDouble() ? value.round().toString() : '$value';
+
+  void _applyPreset(TankPresetEntity preset) {
+    widget.onChanged(
+      widget.item.copyWith(
+        volumeL: preset.volumeLiters,
+        workingPressureBar: preset.workingPressureBar,
+        tankMaterial: preset.material,
+        label: widget.item.label ?? preset.displayName,
+      ),
+    );
+    if (widget.item.label == null) {
+      _label.text = preset.displayName;
+    }
+  }
+
+  Future<void> _pickPreset() async {
+    final presets = await ref.read(tankPresetsProvider.future);
+    if (!mounted || presets.isEmpty) return;
+
+    final chosen = await showModalBottomSheet<TankPresetEntity>(
+      context: context,
+      builder: (sheetContext) => SafeArea(
+        child: ListView(
+          shrinkWrap: true,
+          children: [
+            for (final preset in presets)
+              ListTile(
+                title: Text(preset.displayName),
+                subtitle: Text(
+                  '${widget.units.formatVolume(preset.volumeLiters)} - '
+                  '${widget.units.formatPressure(preset.workingPressureBar)}',
+                ),
+                onTap: () => Navigator.of(sheetContext).pop(preset),
+              ),
+          ],
+        ),
+      ),
+    );
+    if (chosen != null) _applyPreset(chosen);
+  }
+
+  double? _parse(String text) {
+    final trimmed = text.trim();
+    if (trimmed.isEmpty) return null;
+    return double.tryParse(trimmed);
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final l10n = context.l10n;
+    final item = widget.item;
+
+    return Padding(
+      padding: const EdgeInsets.symmetric(vertical: 6),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Row(
+            children: [
+              Expanded(
+                child: DropdownButtonFormField<TankRole>(
+                  initialValue: item.tankRole,
+                  decoration: InputDecoration(
+                    labelText: l10n.cylinderConfigs_role,
+                  ),
+                  items: [
+                    for (final role in TankRole.values)
+                      DropdownMenuItem(
+                        value: role,
+                        child: Text(role.displayName),
+                      ),
+                  ],
+                  onChanged: (role) {
+                    if (role != null) {
+                      widget.onChanged(item.copyWith(tankRole: role));
+                    }
+                  },
+                ),
+              ),
+              IconButton(
+                onPressed: widget.onRemove,
+                icon: const Icon(Icons.delete_outline),
+                tooltip: MaterialLocalizations.of(context).deleteButtonTooltip,
+              ),
+            ],
+          ),
+          Row(
+            children: [
+              Expanded(
+                child: TextField(
+                  controller: _o2,
+                  keyboardType: const TextInputType.numberWithOptions(
+                    decimal: true,
+                  ),
+                  decoration: const InputDecoration(labelText: 'O2 %'),
+                  // Only a parseable value updates the model: transient states
+                  // like a lone "." must not clobber the stored mix.
+                  onChanged: (text) {
+                    final parsed = _parse(text);
+                    if (parsed != null) {
+                      widget.onChanged(item.copyWith(o2Percent: parsed));
+                    }
+                  },
+                ),
+              ),
+              const SizedBox(width: 8),
+              Expanded(
+                child: TextField(
+                  controller: _he,
+                  keyboardType: const TextInputType.numberWithOptions(
+                    decimal: true,
+                  ),
+                  decoration: const InputDecoration(labelText: 'He %'),
+                  onChanged: (text) {
+                    final parsed = _parse(text);
+                    if (parsed != null) {
+                      widget.onChanged(item.copyWith(hePercent: parsed));
+                    }
+                  },
+                ),
+              ),
+            ],
+          ),
+          Row(
+            children: [
+              Expanded(
+                child: TextField(
+                  controller: _label,
+                  decoration: InputDecoration(
+                    labelText: l10n.cylinderConfigs_label,
+                  ),
+                  onChanged: (text) => widget.onChanged(
+                    text.trim().isEmpty
+                        ? item.copyWith(clearLabel: true)
+                        : item.copyWith(label: text),
+                  ),
+                ),
+              ),
+              const SizedBox(width: 8),
+              TextButton.icon(
+                onPressed: _pickPreset,
+                icon: const Icon(Icons.inventory_2_outlined),
+                label: Text(l10n.cylinderConfigs_fromPreset),
+              ),
+            ],
+          ),
+          if (item.volumeL != null || item.workingPressureBar != null)
+            Padding(
+              padding: const EdgeInsets.only(top: 4),
+              child: Text(
+                [
+                  if (item.volumeL != null)
+                    widget.units.formatVolume(item.volumeL!),
+                  if (item.workingPressureBar != null)
+                    widget.units.formatPressure(item.workingPressureBar!),
+                ].join(' - '),
+                style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                  color: Theme.of(context).colorScheme.onSurfaceVariant,
+                ),
+              ),
+            ),
+        ],
+      ),
+    );
+  }
+}
diff --git a/lib/l10n/arb/app_ar.arb b/lib/l10n/arb/app_ar.arb
index ef7fd62153..94c7136ca8 100644
--- a/lib/l10n/arb/app_ar.arb
+++ b/lib/l10n/arb/app_ar.arb
@@ -3218,6 +3218,41 @@
   "equipment_serviceClocks_overdueSince": "متأخر منذ {date}",
   "equipment_serviceClocks_overdue": "متأخر",
   "equipment_serviceClocks_divesLeft": "متبقٍ {remaining} من {total} غوصة",
+  "cylinderConfigs_title": "إعدادات الأسطوانات",
+  "cylinderConfigs_empty": "لا توجد إعدادات بعد",
+  "cylinderConfigs_emptyBody": "احفظ إعداد المخفف والبديل مرة واحدة ثم طبّقه على أي غوصة.",
+  "cylinderConfigs_new": "إعداد جديد",
+  "cylinderConfigs_name": "الاسم",
+  "cylinderConfigs_nameRequired": "أدخل اسمًا",
+  "cylinderConfigs_forUnit": "للجهاز",
+  "cylinderConfigs_noUnit": "خطة غاز عامة",
+  "cylinderConfigs_gasPlans": "خطط الغاز",
+  "cylinderConfigs_addCylinder": "إضافة أسطوانة",
+  "cylinderConfigs_role": "الدور",
+  "cylinderConfigs_startPressure": "ضغط البداية",
+  "cylinderConfigs_label": "التسمية",
+  "cylinderConfigs_fromPreset": "من قالب",
+  "cylinderConfigs_deleteTitle": "حذف الإعداد؟",
+  "cylinderConfigs_deleteBody": "لن تتغير الغوصات التي طُبّق عليها بالفعل.",
+  "cylinderConfigs_applyAction": "تطبيق إعداد",
+  "cylinderConfigs_applyAdded": "{count, plural, =1{تمت إضافة أسطوانة واحدة} other{تمت إضافة {count} أسطوانات}}",
+  "@cylinderConfigs_applyAdded": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyKept": "{count, plural, =1{مع الإبقاء على واحدة} other{مع الإبقاء على {count}}}",
+  "@cylinderConfigs_applyKept": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyNothingToDo": "هذه الغوصة تطابق الإعداد بالفعل",
+  "cylinderConfigs_sectionTitle": "الإعدادات",
   "equipment_serviceClocks_hoursSource": "محسوب من زمن الغوص المسجل",
   "equipment_serviceClocks_hoursLeft": "متبقٍ {remaining} من {total} ساعة",
   "equipment_serviceClocks_manageKinds": "إدارة أنواع الصيانة",
diff --git a/lib/l10n/arb/app_de.arb b/lib/l10n/arb/app_de.arb
index b5bfe68e06..5fac055d96 100644
--- a/lib/l10n/arb/app_de.arb
+++ b/lib/l10n/arb/app_de.arb
@@ -3218,6 +3218,41 @@
   "equipment_serviceClocks_overdueSince": "Überfällig seit {date}",
   "equipment_serviceClocks_overdue": "Überfällig",
   "equipment_serviceClocks_divesLeft": "{remaining} von {total} Tauchgängen übrig",
+  "cylinderConfigs_title": "Flaschenkonfigurationen",
+  "cylinderConfigs_empty": "Noch keine Konfigurationen",
+  "cylinderConfigs_emptyBody": "Diluent- und Bailout-Aufbau einmal speichern und auf jeden Tauchgang anwenden.",
+  "cylinderConfigs_new": "Neue Konfiguration",
+  "cylinderConfigs_name": "Name",
+  "cylinderConfigs_nameRequired": "Namen eingeben",
+  "cylinderConfigs_forUnit": "Für Gerät",
+  "cylinderConfigs_noUnit": "Allgemeiner Gasplan",
+  "cylinderConfigs_gasPlans": "Gaspläne",
+  "cylinderConfigs_addCylinder": "Flasche hinzufügen",
+  "cylinderConfigs_role": "Rolle",
+  "cylinderConfigs_startPressure": "Anfangsdruck",
+  "cylinderConfigs_label": "Bezeichnung",
+  "cylinderConfigs_fromPreset": "Aus Vorlage",
+  "cylinderConfigs_deleteTitle": "Konfiguration löschen?",
+  "cylinderConfigs_deleteBody": "Bereits angewendete Tauchgänge bleiben unverändert.",
+  "cylinderConfigs_applyAction": "Konfiguration anwenden",
+  "cylinderConfigs_applyAdded": "{count, plural, =1{1 Flasche hinzugefügt} other{{count} Flaschen hinzugefügt}}",
+  "@cylinderConfigs_applyAdded": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyKept": "{count, plural, =1{1 beibehalten} other{{count} beibehalten}}",
+  "@cylinderConfigs_applyKept": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyNothingToDo": "Dieser Tauchgang entspricht bereits der Konfiguration",
+  "cylinderConfigs_sectionTitle": "Konfigurationen",
   "equipment_serviceClocks_hoursSource": "Aus der protokollierten Tauchzeit berechnet",
   "equipment_serviceClocks_hoursLeft": "{remaining} von {total} Stunden übrig",
   "equipment_serviceClocks_manageKinds": "Wartungsarten verwalten",
diff --git a/lib/l10n/arb/app_en.arb b/lib/l10n/arb/app_en.arb
index 230e137db9..81d64ef307 100644
--- a/lib/l10n/arb/app_en.arb
+++ b/lib/l10n/arb/app_en.arb
@@ -5708,6 +5708,41 @@
       }
     }
   },
+  "cylinderConfigs_title": "Cylinder configurations",
+  "cylinderConfigs_empty": "No configurations yet",
+  "cylinderConfigs_emptyBody": "Save a diluent and bailout setup once, then apply it to any dive.",
+  "cylinderConfigs_new": "New configuration",
+  "cylinderConfigs_name": "Name",
+  "cylinderConfigs_nameRequired": "Enter a name",
+  "cylinderConfigs_forUnit": "For unit",
+  "cylinderConfigs_noUnit": "Generic gas plan",
+  "cylinderConfigs_gasPlans": "Gas plans",
+  "cylinderConfigs_addCylinder": "Add cylinder",
+  "cylinderConfigs_role": "Role",
+  "cylinderConfigs_startPressure": "Start pressure",
+  "cylinderConfigs_label": "Label",
+  "cylinderConfigs_fromPreset": "From preset",
+  "cylinderConfigs_deleteTitle": "Delete configuration?",
+  "cylinderConfigs_deleteBody": "This does not change any dive it was already applied to.",
+  "cylinderConfigs_applyAction": "Apply configuration",
+  "cylinderConfigs_applyAdded": "{count, plural, =1{Added 1 cylinder} other{Added {count} cylinders}}",
+  "@cylinderConfigs_applyAdded": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyKept": "{count, plural, =1{kept 1} other{kept {count}}}",
+  "@cylinderConfigs_applyKept": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyNothingToDo": "This dive already matches the configuration",
+  "cylinderConfigs_sectionTitle": "Configurations",
   "equipment_serviceClocks_hoursSource": "Counted from logged dive time",
   "equipment_serviceClocks_hoursLeft": "{remaining} of {total} hours left",
   "@equipment_serviceClocks_hoursLeft": {
diff --git a/lib/l10n/arb/app_es.arb b/lib/l10n/arb/app_es.arb
index 772028c15c..dcd9dcc40e 100644
--- a/lib/l10n/arb/app_es.arb
+++ b/lib/l10n/arb/app_es.arb
@@ -3218,6 +3218,41 @@
   "equipment_serviceClocks_overdueSince": "Vencido desde el {date}",
   "equipment_serviceClocks_overdue": "Vencido",
   "equipment_serviceClocks_divesLeft": "Quedan {remaining} de {total} inmersiones",
+  "cylinderConfigs_title": "Configuraciones de botellas",
+  "cylinderConfigs_empty": "Aún no hay configuraciones",
+  "cylinderConfigs_emptyBody": "Guarda un montaje de diluyente y bailout una vez y aplícalo a cualquier inmersión.",
+  "cylinderConfigs_new": "Nueva configuración",
+  "cylinderConfigs_name": "Nombre",
+  "cylinderConfigs_nameRequired": "Introduce un nombre",
+  "cylinderConfigs_forUnit": "Para el equipo",
+  "cylinderConfigs_noUnit": "Plan de gas genérico",
+  "cylinderConfigs_gasPlans": "Planes de gas",
+  "cylinderConfigs_addCylinder": "Añadir botella",
+  "cylinderConfigs_role": "Función",
+  "cylinderConfigs_startPressure": "Presión inicial",
+  "cylinderConfigs_label": "Etiqueta",
+  "cylinderConfigs_fromPreset": "Desde preajuste",
+  "cylinderConfigs_deleteTitle": "¿Eliminar la configuración?",
+  "cylinderConfigs_deleteBody": "Las inmersiones ya aplicadas no cambian.",
+  "cylinderConfigs_applyAction": "Aplicar configuración",
+  "cylinderConfigs_applyAdded": "{count, plural, =1{1 botella añadida} other{{count} botellas añadidas}}",
+  "@cylinderConfigs_applyAdded": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyKept": "{count, plural, =1{1 conservada} other{{count} conservadas}}",
+  "@cylinderConfigs_applyKept": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyNothingToDo": "Esta inmersión ya coincide con la configuración",
+  "cylinderConfigs_sectionTitle": "Configuraciones",
   "equipment_serviceClocks_hoursSource": "Calculado a partir del tiempo de buceo registrado",
   "equipment_serviceClocks_hoursLeft": "Quedan {remaining} de {total} horas",
   "equipment_serviceClocks_manageKinds": "Gestionar tipos de mantenimiento",
diff --git a/lib/l10n/arb/app_fr.arb b/lib/l10n/arb/app_fr.arb
index 3cbce94eb9..34e5115864 100644
--- a/lib/l10n/arb/app_fr.arb
+++ b/lib/l10n/arb/app_fr.arb
@@ -3146,6 +3146,41 @@
   "equipment_serviceClocks_overdueSince": "En retard depuis le {date}",
   "equipment_serviceClocks_overdue": "En retard",
   "equipment_serviceClocks_divesLeft": "{remaining} plongées restantes sur {total}",
+  "cylinderConfigs_title": "Configurations de bouteilles",
+  "cylinderConfigs_empty": "Aucune configuration",
+  "cylinderConfigs_emptyBody": "Enregistrez un montage diluant et bailout une fois, puis appliquez-le à n'importe quelle plongée.",
+  "cylinderConfigs_new": "Nouvelle configuration",
+  "cylinderConfigs_name": "Nom",
+  "cylinderConfigs_nameRequired": "Saisissez un nom",
+  "cylinderConfigs_forUnit": "Pour l'appareil",
+  "cylinderConfigs_noUnit": "Plan de gaz générique",
+  "cylinderConfigs_gasPlans": "Plans de gaz",
+  "cylinderConfigs_addCylinder": "Ajouter une bouteille",
+  "cylinderConfigs_role": "Rôle",
+  "cylinderConfigs_startPressure": "Pression de départ",
+  "cylinderConfigs_label": "Libellé",
+  "cylinderConfigs_fromPreset": "Depuis un préréglage",
+  "cylinderConfigs_deleteTitle": "Supprimer la configuration ?",
+  "cylinderConfigs_deleteBody": "Les plongées déjà concernées ne sont pas modifiées.",
+  "cylinderConfigs_applyAction": "Appliquer une configuration",
+  "cylinderConfigs_applyAdded": "{count, plural, =1{1 bouteille ajoutée} other{{count} bouteilles ajoutées}}",
+  "@cylinderConfigs_applyAdded": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyKept": "{count, plural, =1{1 conservée} other{{count} conservées}}",
+  "@cylinderConfigs_applyKept": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyNothingToDo": "Cette plongée correspond déjà à la configuration",
+  "cylinderConfigs_sectionTitle": "Configurations",
   "equipment_serviceClocks_hoursSource": "Calculé à partir du temps de plongée enregistré",
   "equipment_serviceClocks_hoursLeft": "{remaining} heures restantes sur {total}",
   "equipment_serviceClocks_manageKinds": "Gérer les types d'entretien",
diff --git a/lib/l10n/arb/app_he.arb b/lib/l10n/arb/app_he.arb
index eee8faa066..64b684c840 100644
--- a/lib/l10n/arb/app_he.arb
+++ b/lib/l10n/arb/app_he.arb
@@ -3146,6 +3146,41 @@
   "equipment_serviceClocks_overdueSince": "באיחור מאז {date}",
   "equipment_serviceClocks_overdue": "באיחור",
   "equipment_serviceClocks_divesLeft": "נותרו {remaining} מתוך {total} צלילות",
+  "cylinderConfigs_title": "תצורות בלונים",
+  "cylinderConfigs_empty": "אין עדיין תצורות",
+  "cylinderConfigs_emptyBody": "שמור פעם אחת מערך מדלל וביילאאוט, ואז החל אותו על כל צלילה.",
+  "cylinderConfigs_new": "תצורה חדשה",
+  "cylinderConfigs_name": "שם",
+  "cylinderConfigs_nameRequired": "הזן שם",
+  "cylinderConfigs_forUnit": "עבור היחידה",
+  "cylinderConfigs_noUnit": "תוכנית גז כללית",
+  "cylinderConfigs_gasPlans": "תוכניות גז",
+  "cylinderConfigs_addCylinder": "הוסף בלון",
+  "cylinderConfigs_role": "תפקיד",
+  "cylinderConfigs_startPressure": "לחץ התחלתי",
+  "cylinderConfigs_label": "תווית",
+  "cylinderConfigs_fromPreset": "מתבנית",
+  "cylinderConfigs_deleteTitle": "למחוק את התצורה?",
+  "cylinderConfigs_deleteBody": "צלילות שהתצורה כבר הוחלה עליהן לא ישתנו.",
+  "cylinderConfigs_applyAction": "החל תצורה",
+  "cylinderConfigs_applyAdded": "{count, plural, =1{בלון אחד נוסף} other{{count} בלונים נוספו}}",
+  "@cylinderConfigs_applyAdded": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyKept": "{count, plural, =1{אחד נשמר} other{{count} נשמרו}}",
+  "@cylinderConfigs_applyKept": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyNothingToDo": "הצלילה כבר תואמת לתצורה",
+  "cylinderConfigs_sectionTitle": "תצורות",
   "equipment_serviceClocks_hoursSource": "מחושב מזמן הצלילה המתועד",
   "equipment_serviceClocks_hoursLeft": "נותרו {remaining} מתוך {total} שעות",
   "equipment_serviceClocks_manageKinds": "ניהול סוגי טיפול",
diff --git a/lib/l10n/arb/app_hu.arb b/lib/l10n/arb/app_hu.arb
index ff5c01dbca..b3ce470b58 100644
--- a/lib/l10n/arb/app_hu.arb
+++ b/lib/l10n/arb/app_hu.arb
@@ -3146,6 +3146,41 @@
   "equipment_serviceClocks_overdueSince": "{date} óta esedékes",
   "equipment_serviceClocks_overdue": "Lejárt",
   "equipment_serviceClocks_divesLeft": "{remaining} / {total} merülés van hátra",
+  "cylinderConfigs_title": "Palackkonfigurációk",
+  "cylinderConfigs_empty": "Még nincs konfiguráció",
+  "cylinderConfigs_emptyBody": "Mentsd el egyszer a diluent- és bailout-összeállítást, majd alkalmazd bármelyik merülésre.",
+  "cylinderConfigs_new": "Új konfiguráció",
+  "cylinderConfigs_name": "Név",
+  "cylinderConfigs_nameRequired": "Adj meg egy nevet",
+  "cylinderConfigs_forUnit": "Készülékhez",
+  "cylinderConfigs_noUnit": "Általános gázterv",
+  "cylinderConfigs_gasPlans": "Gáztervek",
+  "cylinderConfigs_addCylinder": "Palack hozzáadása",
+  "cylinderConfigs_role": "Szerep",
+  "cylinderConfigs_startPressure": "Kezdőnyomás",
+  "cylinderConfigs_label": "Címke",
+  "cylinderConfigs_fromPreset": "Sablonból",
+  "cylinderConfigs_deleteTitle": "Törlöd a konfigurációt?",
+  "cylinderConfigs_deleteBody": "A már alkalmazott merülések nem változnak.",
+  "cylinderConfigs_applyAction": "Konfiguráció alkalmazása",
+  "cylinderConfigs_applyAdded": "{count, plural, other{{count} palack hozzáadva}}",
+  "@cylinderConfigs_applyAdded": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyKept": "{count, plural, other{{count} megtartva}}",
+  "@cylinderConfigs_applyKept": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyNothingToDo": "Ez a merülés már megegyezik a konfigurációval",
+  "cylinderConfigs_sectionTitle": "Konfigurációk",
   "equipment_serviceClocks_hoursSource": "A naplózott merülési idő alapján számolva",
   "equipment_serviceClocks_hoursLeft": "{remaining} / {total} óra van hátra",
   "equipment_serviceClocks_manageKinds": "Szerviztípusok kezelése",
diff --git a/lib/l10n/arb/app_it.arb b/lib/l10n/arb/app_it.arb
index 08019e0616..3aa9675eea 100644
--- a/lib/l10n/arb/app_it.arb
+++ b/lib/l10n/arb/app_it.arb
@@ -3146,6 +3146,41 @@
   "equipment_serviceClocks_overdueSince": "In ritardo dal {date}",
   "equipment_serviceClocks_overdue": "In ritardo",
   "equipment_serviceClocks_divesLeft": "{remaining} immersioni rimanenti su {total}",
+  "cylinderConfigs_title": "Configurazioni bombole",
+  "cylinderConfigs_empty": "Nessuna configurazione",
+  "cylinderConfigs_emptyBody": "Salva una volta un assetto diluente e bailout, poi applicalo a qualsiasi immersione.",
+  "cylinderConfigs_new": "Nuova configurazione",
+  "cylinderConfigs_name": "Nome",
+  "cylinderConfigs_nameRequired": "Inserisci un nome",
+  "cylinderConfigs_forUnit": "Per unità",
+  "cylinderConfigs_noUnit": "Piano gas generico",
+  "cylinderConfigs_gasPlans": "Piani gas",
+  "cylinderConfigs_addCylinder": "Aggiungi bombola",
+  "cylinderConfigs_role": "Ruolo",
+  "cylinderConfigs_startPressure": "Pressione iniziale",
+  "cylinderConfigs_label": "Etichetta",
+  "cylinderConfigs_fromPreset": "Da preimpostazione",
+  "cylinderConfigs_deleteTitle": "Eliminare la configurazione?",
+  "cylinderConfigs_deleteBody": "Le immersioni a cui è già stata applicata non cambiano.",
+  "cylinderConfigs_applyAction": "Applica configurazione",
+  "cylinderConfigs_applyAdded": "{count, plural, =1{1 bombola aggiunta} other{{count} bombole aggiunte}}",
+  "@cylinderConfigs_applyAdded": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyKept": "{count, plural, =1{1 mantenuta} other{{count} mantenute}}",
+  "@cylinderConfigs_applyKept": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyNothingToDo": "Questa immersione corrisponde già alla configurazione",
+  "cylinderConfigs_sectionTitle": "Configurazioni",
   "equipment_serviceClocks_hoursSource": "Calcolato dal tempo di immersione registrato",
   "equipment_serviceClocks_hoursLeft": "{remaining} ore rimanenti su {total}",
   "equipment_serviceClocks_manageKinds": "Gestisci tipi di manutenzione",
diff --git a/lib/l10n/arb/app_localizations.dart b/lib/l10n/arb/app_localizations.dart
index 68ea895cba..965ed28b8f 100644
--- a/lib/l10n/arb/app_localizations.dart
+++ b/lib/l10n/arb/app_localizations.dart
@@ -17427,6 +17427,132 @@ abstract class AppLocalizations {
   /// **'{remaining} of {total} dives left'**
   String equipment_serviceClocks_divesLeft(int remaining, int total);
 
+  /// No description provided for @cylinderConfigs_title.
+  ///
+  /// In en, this message translates to:
+  /// **'Cylinder configurations'**
+  String get cylinderConfigs_title;
+
+  /// No description provided for @cylinderConfigs_empty.
+  ///
+  /// In en, this message translates to:
+  /// **'No configurations yet'**
+  String get cylinderConfigs_empty;
+
+  /// No description provided for @cylinderConfigs_emptyBody.
+  ///
+  /// In en, this message translates to:
+  /// **'Save a diluent and bailout setup once, then apply it to any dive.'**
+  String get cylinderConfigs_emptyBody;
+
+  /// No description provided for @cylinderConfigs_new.
+  ///
+  /// In en, this message translates to:
+  /// **'New configuration'**
+  String get cylinderConfigs_new;
+
+  /// No description provided for @cylinderConfigs_name.
+  ///
+  /// In en, this message translates to:
+  /// **'Name'**
+  String get cylinderConfigs_name;
+
+  /// No description provided for @cylinderConfigs_nameRequired.
+  ///
+  /// In en, this message translates to:
+  /// **'Enter a name'**
+  String get cylinderConfigs_nameRequired;
+
+  /// No description provided for @cylinderConfigs_forUnit.
+  ///
+  /// In en, this message translates to:
+  /// **'For unit'**
+  String get cylinderConfigs_forUnit;
+
+  /// No description provided for @cylinderConfigs_noUnit.
+  ///
+  /// In en, this message translates to:
+  /// **'Generic gas plan'**
+  String get cylinderConfigs_noUnit;
+
+  /// No description provided for @cylinderConfigs_gasPlans.
+  ///
+  /// In en, this message translates to:
+  /// **'Gas plans'**
+  String get cylinderConfigs_gasPlans;
+
+  /// No description provided for @cylinderConfigs_addCylinder.
+  ///
+  /// In en, this message translates to:
+  /// **'Add cylinder'**
+  String get cylinderConfigs_addCylinder;
+
+  /// No description provided for @cylinderConfigs_role.
+  ///
+  /// In en, this message translates to:
+  /// **'Role'**
+  String get cylinderConfigs_role;
+
+  /// No description provided for @cylinderConfigs_startPressure.
+  ///
+  /// In en, this message translates to:
+  /// **'Start pressure'**
+  String get cylinderConfigs_startPressure;
+
+  /// No description provided for @cylinderConfigs_label.
+  ///
+  /// In en, this message translates to:
+  /// **'Label'**
+  String get cylinderConfigs_label;
+
+  /// No description provided for @cylinderConfigs_fromPreset.
+  ///
+  /// In en, this message translates to:
+  /// **'From preset'**
+  String get cylinderConfigs_fromPreset;
+
+  /// No description provided for @cylinderConfigs_deleteTitle.
+  ///
+  /// In en, this message translates to:
+  /// **'Delete configuration?'**
+  String get cylinderConfigs_deleteTitle;
+
+  /// No description provided for @cylinderConfigs_deleteBody.
+  ///
+  /// In en, this message translates to:
+  /// **'This does not change any dive it was already applied to.'**
+  String get cylinderConfigs_deleteBody;
+
+  /// No description provided for @cylinderConfigs_applyAction.
+  ///
+  /// In en, this message translates to:
+  /// **'Apply configuration'**
+  String get cylinderConfigs_applyAction;
+
+  /// No description provided for @cylinderConfigs_applyAdded.
+  ///
+  /// In en, this message translates to:
+  /// **'{count, plural, =1{Added 1 cylinder} other{Added {count} cylinders}}'**
+  String cylinderConfigs_applyAdded(int count);
+
+  /// No description provided for @cylinderConfigs_applyKept.
+  ///
+  /// In en, this message translates to:
+  /// **'{count, plural, =1{kept 1} other{kept {count}}}'**
+  String cylinderConfigs_applyKept(int count);
+
+  /// No description provided for @cylinderConfigs_applyNothingToDo.
+  ///
+  /// In en, this message translates to:
+  /// **'This dive already matches the configuration'**
+  String get cylinderConfigs_applyNothingToDo;
+
+  /// No description provided for @cylinderConfigs_sectionTitle.
+  ///
+  /// In en, this message translates to:
+  /// **'Configurations'**
+  String get cylinderConfigs_sectionTitle;
+
   /// No description provided for @equipment_serviceClocks_hoursSource.
   ///
   /// In en, this message translates to:
diff --git a/lib/l10n/arb/app_localizations_ar.dart b/lib/l10n/arb/app_localizations_ar.dart
index ef16274db3..dd86d54d11 100644
--- a/lib/l10n/arb/app_localizations_ar.dart
+++ b/lib/l10n/arb/app_localizations_ar.dart
@@ -10014,6 +10014,88 @@ class AppLocalizationsAr extends AppLocalizations {
     return 'متبقٍ $remaining من $total غوصة';
   }
 
+  @override
+  String get cylinderConfigs_title => 'إعدادات الأسطوانات';
+
+  @override
+  String get cylinderConfigs_empty => 'لا توجد إعدادات بعد';
+
+  @override
+  String get cylinderConfigs_emptyBody =>
+      'احفظ إعداد المخفف والبديل مرة واحدة ثم طبّقه على أي غوصة.';
+
+  @override
+  String get cylinderConfigs_new => 'إعداد جديد';
+
+  @override
+  String get cylinderConfigs_name => 'الاسم';
+
+  @override
+  String get cylinderConfigs_nameRequired => 'أدخل اسمًا';
+
+  @override
+  String get cylinderConfigs_forUnit => 'للجهاز';
+
+  @override
+  String get cylinderConfigs_noUnit => 'خطة غاز عامة';
+
+  @override
+  String get cylinderConfigs_gasPlans => 'خطط الغاز';
+
+  @override
+  String get cylinderConfigs_addCylinder => 'إضافة أسطوانة';
+
+  @override
+  String get cylinderConfigs_role => 'الدور';
+
+  @override
+  String get cylinderConfigs_startPressure => 'ضغط البداية';
+
+  @override
+  String get cylinderConfigs_label => 'التسمية';
+
+  @override
+  String get cylinderConfigs_fromPreset => 'من قالب';
+
+  @override
+  String get cylinderConfigs_deleteTitle => 'حذف الإعداد؟';
+
+  @override
+  String get cylinderConfigs_deleteBody =>
+      'لن تتغير الغوصات التي طُبّق عليها بالفعل.';
+
+  @override
+  String get cylinderConfigs_applyAction => 'تطبيق إعداد';
+
+  @override
+  String cylinderConfigs_applyAdded(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: 'تمت إضافة $count أسطوانات',
+      one: 'تمت إضافة أسطوانة واحدة',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String cylinderConfigs_applyKept(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: 'مع الإبقاء على $count',
+      one: 'مع الإبقاء على واحدة',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get cylinderConfigs_applyNothingToDo =>
+      'هذه الغوصة تطابق الإعداد بالفعل';
+
+  @override
+  String get cylinderConfigs_sectionTitle => 'الإعدادات';
+
   @override
   String get equipment_serviceClocks_hoursSource => 'محسوب من زمن الغوص المسجل';
 
diff --git a/lib/l10n/arb/app_localizations_de.dart b/lib/l10n/arb/app_localizations_de.dart
index c53263f998..006c3635a5 100644
--- a/lib/l10n/arb/app_localizations_de.dart
+++ b/lib/l10n/arb/app_localizations_de.dart
@@ -10188,6 +10188,88 @@ class AppLocalizationsDe extends AppLocalizations {
     return '$remaining von $total Tauchgängen übrig';
   }
 
+  @override
+  String get cylinderConfigs_title => 'Flaschenkonfigurationen';
+
+  @override
+  String get cylinderConfigs_empty => 'Noch keine Konfigurationen';
+
+  @override
+  String get cylinderConfigs_emptyBody =>
+      'Diluent- und Bailout-Aufbau einmal speichern und auf jeden Tauchgang anwenden.';
+
+  @override
+  String get cylinderConfigs_new => 'Neue Konfiguration';
+
+  @override
+  String get cylinderConfigs_name => 'Name';
+
+  @override
+  String get cylinderConfigs_nameRequired => 'Namen eingeben';
+
+  @override
+  String get cylinderConfigs_forUnit => 'Für Gerät';
+
+  @override
+  String get cylinderConfigs_noUnit => 'Allgemeiner Gasplan';
+
+  @override
+  String get cylinderConfigs_gasPlans => 'Gaspläne';
+
+  @override
+  String get cylinderConfigs_addCylinder => 'Flasche hinzufügen';
+
+  @override
+  String get cylinderConfigs_role => 'Rolle';
+
+  @override
+  String get cylinderConfigs_startPressure => 'Anfangsdruck';
+
+  @override
+  String get cylinderConfigs_label => 'Bezeichnung';
+
+  @override
+  String get cylinderConfigs_fromPreset => 'Aus Vorlage';
+
+  @override
+  String get cylinderConfigs_deleteTitle => 'Konfiguration löschen?';
+
+  @override
+  String get cylinderConfigs_deleteBody =>
+      'Bereits angewendete Tauchgänge bleiben unverändert.';
+
+  @override
+  String get cylinderConfigs_applyAction => 'Konfiguration anwenden';
+
+  @override
+  String cylinderConfigs_applyAdded(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count Flaschen hinzugefügt',
+      one: '1 Flasche hinzugefügt',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String cylinderConfigs_applyKept(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count beibehalten',
+      one: '1 beibehalten',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get cylinderConfigs_applyNothingToDo =>
+      'Dieser Tauchgang entspricht bereits der Konfiguration';
+
+  @override
+  String get cylinderConfigs_sectionTitle => 'Konfigurationen';
+
   @override
   String get equipment_serviceClocks_hoursSource =>
       'Aus der protokollierten Tauchzeit berechnet';
diff --git a/lib/l10n/arb/app_localizations_en.dart b/lib/l10n/arb/app_localizations_en.dart
index f8682cb0c0..b9577b6e16 100644
--- a/lib/l10n/arb/app_localizations_en.dart
+++ b/lib/l10n/arb/app_localizations_en.dart
@@ -10035,6 +10035,88 @@ class AppLocalizationsEn extends AppLocalizations {
     return '$remaining of $total dives left';
   }
 
+  @override
+  String get cylinderConfigs_title => 'Cylinder configurations';
+
+  @override
+  String get cylinderConfigs_empty => 'No configurations yet';
+
+  @override
+  String get cylinderConfigs_emptyBody =>
+      'Save a diluent and bailout setup once, then apply it to any dive.';
+
+  @override
+  String get cylinderConfigs_new => 'New configuration';
+
+  @override
+  String get cylinderConfigs_name => 'Name';
+
+  @override
+  String get cylinderConfigs_nameRequired => 'Enter a name';
+
+  @override
+  String get cylinderConfigs_forUnit => 'For unit';
+
+  @override
+  String get cylinderConfigs_noUnit => 'Generic gas plan';
+
+  @override
+  String get cylinderConfigs_gasPlans => 'Gas plans';
+
+  @override
+  String get cylinderConfigs_addCylinder => 'Add cylinder';
+
+  @override
+  String get cylinderConfigs_role => 'Role';
+
+  @override
+  String get cylinderConfigs_startPressure => 'Start pressure';
+
+  @override
+  String get cylinderConfigs_label => 'Label';
+
+  @override
+  String get cylinderConfigs_fromPreset => 'From preset';
+
+  @override
+  String get cylinderConfigs_deleteTitle => 'Delete configuration?';
+
+  @override
+  String get cylinderConfigs_deleteBody =>
+      'This does not change any dive it was already applied to.';
+
+  @override
+  String get cylinderConfigs_applyAction => 'Apply configuration';
+
+  @override
+  String cylinderConfigs_applyAdded(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: 'Added $count cylinders',
+      one: 'Added 1 cylinder',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String cylinderConfigs_applyKept(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: 'kept $count',
+      one: 'kept 1',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get cylinderConfigs_applyNothingToDo =>
+      'This dive already matches the configuration';
+
+  @override
+  String get cylinderConfigs_sectionTitle => 'Configurations';
+
   @override
   String get equipment_serviceClocks_hoursSource =>
       'Counted from logged dive time';
diff --git a/lib/l10n/arb/app_localizations_es.dart b/lib/l10n/arb/app_localizations_es.dart
index 7c9259c045..01e851e6f0 100644
--- a/lib/l10n/arb/app_localizations_es.dart
+++ b/lib/l10n/arb/app_localizations_es.dart
@@ -10186,6 +10186,88 @@ class AppLocalizationsEs extends AppLocalizations {
     return 'Quedan $remaining de $total inmersiones';
   }
 
+  @override
+  String get cylinderConfigs_title => 'Configuraciones de botellas';
+
+  @override
+  String get cylinderConfigs_empty => 'Aún no hay configuraciones';
+
+  @override
+  String get cylinderConfigs_emptyBody =>
+      'Guarda un montaje de diluyente y bailout una vez y aplícalo a cualquier inmersión.';
+
+  @override
+  String get cylinderConfigs_new => 'Nueva configuración';
+
+  @override
+  String get cylinderConfigs_name => 'Nombre';
+
+  @override
+  String get cylinderConfigs_nameRequired => 'Introduce un nombre';
+
+  @override
+  String get cylinderConfigs_forUnit => 'Para el equipo';
+
+  @override
+  String get cylinderConfigs_noUnit => 'Plan de gas genérico';
+
+  @override
+  String get cylinderConfigs_gasPlans => 'Planes de gas';
+
+  @override
+  String get cylinderConfigs_addCylinder => 'Añadir botella';
+
+  @override
+  String get cylinderConfigs_role => 'Función';
+
+  @override
+  String get cylinderConfigs_startPressure => 'Presión inicial';
+
+  @override
+  String get cylinderConfigs_label => 'Etiqueta';
+
+  @override
+  String get cylinderConfigs_fromPreset => 'Desde preajuste';
+
+  @override
+  String get cylinderConfigs_deleteTitle => '¿Eliminar la configuración?';
+
+  @override
+  String get cylinderConfigs_deleteBody =>
+      'Las inmersiones ya aplicadas no cambian.';
+
+  @override
+  String get cylinderConfigs_applyAction => 'Aplicar configuración';
+
+  @override
+  String cylinderConfigs_applyAdded(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count botellas añadidas',
+      one: '1 botella añadida',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String cylinderConfigs_applyKept(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count conservadas',
+      one: '1 conservada',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get cylinderConfigs_applyNothingToDo =>
+      'Esta inmersión ya coincide con la configuración';
+
+  @override
+  String get cylinderConfigs_sectionTitle => 'Configuraciones';
+
   @override
   String get equipment_serviceClocks_hoursSource =>
       'Calculado a partir del tiempo de buceo registrado';
diff --git a/lib/l10n/arb/app_localizations_fr.dart b/lib/l10n/arb/app_localizations_fr.dart
index cc418dbf8d..fcc637fb9a 100644
--- a/lib/l10n/arb/app_localizations_fr.dart
+++ b/lib/l10n/arb/app_localizations_fr.dart
@@ -10218,6 +10218,88 @@ class AppLocalizationsFr extends AppLocalizations {
     return '$remaining plongées restantes sur $total';
   }
 
+  @override
+  String get cylinderConfigs_title => 'Configurations de bouteilles';
+
+  @override
+  String get cylinderConfigs_empty => 'Aucune configuration';
+
+  @override
+  String get cylinderConfigs_emptyBody =>
+      'Enregistrez un montage diluant et bailout une fois, puis appliquez-le à n\'importe quelle plongée.';
+
+  @override
+  String get cylinderConfigs_new => 'Nouvelle configuration';
+
+  @override
+  String get cylinderConfigs_name => 'Nom';
+
+  @override
+  String get cylinderConfigs_nameRequired => 'Saisissez un nom';
+
+  @override
+  String get cylinderConfigs_forUnit => 'Pour l\'appareil';
+
+  @override
+  String get cylinderConfigs_noUnit => 'Plan de gaz générique';
+
+  @override
+  String get cylinderConfigs_gasPlans => 'Plans de gaz';
+
+  @override
+  String get cylinderConfigs_addCylinder => 'Ajouter une bouteille';
+
+  @override
+  String get cylinderConfigs_role => 'Rôle';
+
+  @override
+  String get cylinderConfigs_startPressure => 'Pression de départ';
+
+  @override
+  String get cylinderConfigs_label => 'Libellé';
+
+  @override
+  String get cylinderConfigs_fromPreset => 'Depuis un préréglage';
+
+  @override
+  String get cylinderConfigs_deleteTitle => 'Supprimer la configuration ?';
+
+  @override
+  String get cylinderConfigs_deleteBody =>
+      'Les plongées déjà concernées ne sont pas modifiées.';
+
+  @override
+  String get cylinderConfigs_applyAction => 'Appliquer une configuration';
+
+  @override
+  String cylinderConfigs_applyAdded(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count bouteilles ajoutées',
+      one: '1 bouteille ajoutée',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String cylinderConfigs_applyKept(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count conservées',
+      one: '1 conservée',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get cylinderConfigs_applyNothingToDo =>
+      'Cette plongée correspond déjà à la configuration';
+
+  @override
+  String get cylinderConfigs_sectionTitle => 'Configurations';
+
   @override
   String get equipment_serviceClocks_hoursSource =>
       'Calculé à partir du temps de plongée enregistré';
diff --git a/lib/l10n/arb/app_localizations_he.dart b/lib/l10n/arb/app_localizations_he.dart
index f5ab040d6b..75cf4df8cc 100644
--- a/lib/l10n/arb/app_localizations_he.dart
+++ b/lib/l10n/arb/app_localizations_he.dart
@@ -9956,6 +9956,87 @@ class AppLocalizationsHe extends AppLocalizations {
     return 'נותרו $remaining מתוך $total צלילות';
   }
 
+  @override
+  String get cylinderConfigs_title => 'תצורות בלונים';
+
+  @override
+  String get cylinderConfigs_empty => 'אין עדיין תצורות';
+
+  @override
+  String get cylinderConfigs_emptyBody =>
+      'שמור פעם אחת מערך מדלל וביילאאוט, ואז החל אותו על כל צלילה.';
+
+  @override
+  String get cylinderConfigs_new => 'תצורה חדשה';
+
+  @override
+  String get cylinderConfigs_name => 'שם';
+
+  @override
+  String get cylinderConfigs_nameRequired => 'הזן שם';
+
+  @override
+  String get cylinderConfigs_forUnit => 'עבור היחידה';
+
+  @override
+  String get cylinderConfigs_noUnit => 'תוכנית גז כללית';
+
+  @override
+  String get cylinderConfigs_gasPlans => 'תוכניות גז';
+
+  @override
+  String get cylinderConfigs_addCylinder => 'הוסף בלון';
+
+  @override
+  String get cylinderConfigs_role => 'תפקיד';
+
+  @override
+  String get cylinderConfigs_startPressure => 'לחץ התחלתי';
+
+  @override
+  String get cylinderConfigs_label => 'תווית';
+
+  @override
+  String get cylinderConfigs_fromPreset => 'מתבנית';
+
+  @override
+  String get cylinderConfigs_deleteTitle => 'למחוק את התצורה?';
+
+  @override
+  String get cylinderConfigs_deleteBody =>
+      'צלילות שהתצורה כבר הוחלה עליהן לא ישתנו.';
+
+  @override
+  String get cylinderConfigs_applyAction => 'החל תצורה';
+
+  @override
+  String cylinderConfigs_applyAdded(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count בלונים נוספו',
+      one: 'בלון אחד נוסף',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String cylinderConfigs_applyKept(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count נשמרו',
+      one: 'אחד נשמר',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get cylinderConfigs_applyNothingToDo => 'הצלילה כבר תואמת לתצורה';
+
+  @override
+  String get cylinderConfigs_sectionTitle => 'תצורות';
+
   @override
   String get equipment_serviceClocks_hoursSource => 'מחושב מזמן הצלילה המתועד';
 
diff --git a/lib/l10n/arb/app_localizations_hu.dart b/lib/l10n/arb/app_localizations_hu.dart
index 5b62d9d19a..3fd337c811 100644
--- a/lib/l10n/arb/app_localizations_hu.dart
+++ b/lib/l10n/arb/app_localizations_hu.dart
@@ -10167,6 +10167,86 @@ class AppLocalizationsHu extends AppLocalizations {
     return '$remaining / $total merülés van hátra';
   }
 
+  @override
+  String get cylinderConfigs_title => 'Palackkonfigurációk';
+
+  @override
+  String get cylinderConfigs_empty => 'Még nincs konfiguráció';
+
+  @override
+  String get cylinderConfigs_emptyBody =>
+      'Mentsd el egyszer a diluent- és bailout-összeállítást, majd alkalmazd bármelyik merülésre.';
+
+  @override
+  String get cylinderConfigs_new => 'Új konfiguráció';
+
+  @override
+  String get cylinderConfigs_name => 'Név';
+
+  @override
+  String get cylinderConfigs_nameRequired => 'Adj meg egy nevet';
+
+  @override
+  String get cylinderConfigs_forUnit => 'Készülékhez';
+
+  @override
+  String get cylinderConfigs_noUnit => 'Általános gázterv';
+
+  @override
+  String get cylinderConfigs_gasPlans => 'Gáztervek';
+
+  @override
+  String get cylinderConfigs_addCylinder => 'Palack hozzáadása';
+
+  @override
+  String get cylinderConfigs_role => 'Szerep';
+
+  @override
+  String get cylinderConfigs_startPressure => 'Kezdőnyomás';
+
+  @override
+  String get cylinderConfigs_label => 'Címke';
+
+  @override
+  String get cylinderConfigs_fromPreset => 'Sablonból';
+
+  @override
+  String get cylinderConfigs_deleteTitle => 'Törlöd a konfigurációt?';
+
+  @override
+  String get cylinderConfigs_deleteBody =>
+      'A már alkalmazott merülések nem változnak.';
+
+  @override
+  String get cylinderConfigs_applyAction => 'Konfiguráció alkalmazása';
+
+  @override
+  String cylinderConfigs_applyAdded(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count palack hozzáadva',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String cylinderConfigs_applyKept(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count megtartva',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get cylinderConfigs_applyNothingToDo =>
+      'Ez a merülés már megegyezik a konfigurációval';
+
+  @override
+  String get cylinderConfigs_sectionTitle => 'Konfigurációk';
+
   @override
   String get equipment_serviceClocks_hoursSource =>
       'A naplózott merülési idő alapján számolva';
diff --git a/lib/l10n/arb/app_localizations_it.dart b/lib/l10n/arb/app_localizations_it.dart
index 03b8b7f4b4..f81ac9f282 100644
--- a/lib/l10n/arb/app_localizations_it.dart
+++ b/lib/l10n/arb/app_localizations_it.dart
@@ -10184,6 +10184,88 @@ class AppLocalizationsIt extends AppLocalizations {
     return '$remaining immersioni rimanenti su $total';
   }
 
+  @override
+  String get cylinderConfigs_title => 'Configurazioni bombole';
+
+  @override
+  String get cylinderConfigs_empty => 'Nessuna configurazione';
+
+  @override
+  String get cylinderConfigs_emptyBody =>
+      'Salva una volta un assetto diluente e bailout, poi applicalo a qualsiasi immersione.';
+
+  @override
+  String get cylinderConfigs_new => 'Nuova configurazione';
+
+  @override
+  String get cylinderConfigs_name => 'Nome';
+
+  @override
+  String get cylinderConfigs_nameRequired => 'Inserisci un nome';
+
+  @override
+  String get cylinderConfigs_forUnit => 'Per unità';
+
+  @override
+  String get cylinderConfigs_noUnit => 'Piano gas generico';
+
+  @override
+  String get cylinderConfigs_gasPlans => 'Piani gas';
+
+  @override
+  String get cylinderConfigs_addCylinder => 'Aggiungi bombola';
+
+  @override
+  String get cylinderConfigs_role => 'Ruolo';
+
+  @override
+  String get cylinderConfigs_startPressure => 'Pressione iniziale';
+
+  @override
+  String get cylinderConfigs_label => 'Etichetta';
+
+  @override
+  String get cylinderConfigs_fromPreset => 'Da preimpostazione';
+
+  @override
+  String get cylinderConfigs_deleteTitle => 'Eliminare la configurazione?';
+
+  @override
+  String get cylinderConfigs_deleteBody =>
+      'Le immersioni a cui è già stata applicata non cambiano.';
+
+  @override
+  String get cylinderConfigs_applyAction => 'Applica configurazione';
+
+  @override
+  String cylinderConfigs_applyAdded(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count bombole aggiunte',
+      one: '1 bombola aggiunta',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String cylinderConfigs_applyKept(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count mantenute',
+      one: '1 mantenuta',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get cylinderConfigs_applyNothingToDo =>
+      'Questa immersione corrisponde già alla configurazione';
+
+  @override
+  String get cylinderConfigs_sectionTitle => 'Configurazioni';
+
   @override
   String get equipment_serviceClocks_hoursSource =>
       'Calcolato dal tempo di immersione registrato';
diff --git a/lib/l10n/arb/app_localizations_nl.dart b/lib/l10n/arb/app_localizations_nl.dart
index e43972b9e4..6059ea48ad 100644
--- a/lib/l10n/arb/app_localizations_nl.dart
+++ b/lib/l10n/arb/app_localizations_nl.dart
@@ -10114,6 +10114,88 @@ class AppLocalizationsNl extends AppLocalizations {
     return '$remaining van $total duiken resterend';
   }
 
+  @override
+  String get cylinderConfigs_title => 'Flesconfiguraties';
+
+  @override
+  String get cylinderConfigs_empty => 'Nog geen configuraties';
+
+  @override
+  String get cylinderConfigs_emptyBody =>
+      'Sla een diluent- en bailout-opstelling één keer op en pas hem toe op elke duik.';
+
+  @override
+  String get cylinderConfigs_new => 'Nieuwe configuratie';
+
+  @override
+  String get cylinderConfigs_name => 'Naam';
+
+  @override
+  String get cylinderConfigs_nameRequired => 'Voer een naam in';
+
+  @override
+  String get cylinderConfigs_forUnit => 'Voor unit';
+
+  @override
+  String get cylinderConfigs_noUnit => 'Algemeen gasplan';
+
+  @override
+  String get cylinderConfigs_gasPlans => 'Gasplannen';
+
+  @override
+  String get cylinderConfigs_addCylinder => 'Fles toevoegen';
+
+  @override
+  String get cylinderConfigs_role => 'Rol';
+
+  @override
+  String get cylinderConfigs_startPressure => 'Begindruk';
+
+  @override
+  String get cylinderConfigs_label => 'Label';
+
+  @override
+  String get cylinderConfigs_fromPreset => 'Uit voorinstelling';
+
+  @override
+  String get cylinderConfigs_deleteTitle => 'Configuratie verwijderen?';
+
+  @override
+  String get cylinderConfigs_deleteBody =>
+      'Duiken waarop hij al is toegepast veranderen niet.';
+
+  @override
+  String get cylinderConfigs_applyAction => 'Configuratie toepassen';
+
+  @override
+  String cylinderConfigs_applyAdded(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count flessen toegevoegd',
+      one: '1 fles toegevoegd',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String cylinderConfigs_applyKept(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count behouden',
+      one: '1 behouden',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get cylinderConfigs_applyNothingToDo =>
+      'Deze duik komt al overeen met de configuratie';
+
+  @override
+  String get cylinderConfigs_sectionTitle => 'Configuraties';
+
   @override
   String get equipment_serviceClocks_hoursSource =>
       'Berekend op basis van geregistreerde duiktijd';
diff --git a/lib/l10n/arb/app_localizations_pt.dart b/lib/l10n/arb/app_localizations_pt.dart
index 691ee1a786..8e52e437e8 100644
--- a/lib/l10n/arb/app_localizations_pt.dart
+++ b/lib/l10n/arb/app_localizations_pt.dart
@@ -10185,6 +10185,88 @@ class AppLocalizationsPt extends AppLocalizations {
     return 'Restam $remaining de $total mergulhos';
   }
 
+  @override
+  String get cylinderConfigs_title => 'Configurações de garrafas';
+
+  @override
+  String get cylinderConfigs_empty => 'Ainda sem configurações';
+
+  @override
+  String get cylinderConfigs_emptyBody =>
+      'Guarde uma montagem de diluente e bailout uma vez e aplique-a a qualquer mergulho.';
+
+  @override
+  String get cylinderConfigs_new => 'Nova configuração';
+
+  @override
+  String get cylinderConfigs_name => 'Nome';
+
+  @override
+  String get cylinderConfigs_nameRequired => 'Introduza um nome';
+
+  @override
+  String get cylinderConfigs_forUnit => 'Para a unidade';
+
+  @override
+  String get cylinderConfigs_noUnit => 'Plano de gás genérico';
+
+  @override
+  String get cylinderConfigs_gasPlans => 'Planos de gás';
+
+  @override
+  String get cylinderConfigs_addCylinder => 'Adicionar garrafa';
+
+  @override
+  String get cylinderConfigs_role => 'Função';
+
+  @override
+  String get cylinderConfigs_startPressure => 'Pressão inicial';
+
+  @override
+  String get cylinderConfigs_label => 'Etiqueta';
+
+  @override
+  String get cylinderConfigs_fromPreset => 'A partir de predefinição';
+
+  @override
+  String get cylinderConfigs_deleteTitle => 'Eliminar a configuração?';
+
+  @override
+  String get cylinderConfigs_deleteBody =>
+      'Os mergulhos onde já foi aplicada não são alterados.';
+
+  @override
+  String get cylinderConfigs_applyAction => 'Aplicar configuração';
+
+  @override
+  String cylinderConfigs_applyAdded(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count garrafas adicionadas',
+      one: '1 garrafa adicionada',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String cylinderConfigs_applyKept(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count mantidas',
+      one: '1 mantida',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get cylinderConfigs_applyNothingToDo =>
+      'Este mergulho já corresponde à configuração';
+
+  @override
+  String get cylinderConfigs_sectionTitle => 'Configurações';
+
   @override
   String get equipment_serviceClocks_hoursSource =>
       'Calculado a partir do tempo de mergulho registado';
diff --git a/lib/l10n/arb/app_localizations_zh.dart b/lib/l10n/arb/app_localizations_zh.dart
index c792d41217..2c9fde85f9 100644
--- a/lib/l10n/arb/app_localizations_zh.dart
+++ b/lib/l10n/arb/app_localizations_zh.dart
@@ -9747,6 +9747,83 @@ class AppLocalizationsZh extends AppLocalizations {
     return '剩余 $remaining/$total 次潜水';
   }
 
+  @override
+  String get cylinderConfigs_title => '气瓶配置';
+
+  @override
+  String get cylinderConfigs_empty => '尚无配置';
+
+  @override
+  String get cylinderConfigs_emptyBody => '保存一次稀释气与备用气配置，即可应用到任何一次潜水。';
+
+  @override
+  String get cylinderConfigs_new => '新建配置';
+
+  @override
+  String get cylinderConfigs_name => '名称';
+
+  @override
+  String get cylinderConfigs_nameRequired => '请输入名称';
+
+  @override
+  String get cylinderConfigs_forUnit => '所属设备';
+
+  @override
+  String get cylinderConfigs_noUnit => '通用气体方案';
+
+  @override
+  String get cylinderConfigs_gasPlans => '气体方案';
+
+  @override
+  String get cylinderConfigs_addCylinder => '添加气瓶';
+
+  @override
+  String get cylinderConfigs_role => '用途';
+
+  @override
+  String get cylinderConfigs_startPressure => '起始压力';
+
+  @override
+  String get cylinderConfigs_label => '标签';
+
+  @override
+  String get cylinderConfigs_fromPreset => '从预设填入';
+
+  @override
+  String get cylinderConfigs_deleteTitle => '删除此配置？';
+
+  @override
+  String get cylinderConfigs_deleteBody => '已应用过的潜水不会改变。';
+
+  @override
+  String get cylinderConfigs_applyAction => '应用配置';
+
+  @override
+  String cylinderConfigs_applyAdded(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '已添加 $count 个气瓶',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String cylinderConfigs_applyKept(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '保留 $count 个',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get cylinderConfigs_applyNothingToDo => '该潜水已与配置一致';
+
+  @override
+  String get cylinderConfigs_sectionTitle => '配置';
+
   @override
   String get equipment_serviceClocks_hoursSource => '根据已记录的潜水时间计算';
 
diff --git a/lib/l10n/arb/app_nl.arb b/lib/l10n/arb/app_nl.arb
index 860ad48515..b02968680c 100644
--- a/lib/l10n/arb/app_nl.arb
+++ b/lib/l10n/arb/app_nl.arb
@@ -3218,6 +3218,41 @@
   "equipment_serviceClocks_overdueSince": "Achterstallig sinds {date}",
   "equipment_serviceClocks_overdue": "Te laat",
   "equipment_serviceClocks_divesLeft": "{remaining} van {total} duiken resterend",
+  "cylinderConfigs_title": "Flesconfiguraties",
+  "cylinderConfigs_empty": "Nog geen configuraties",
+  "cylinderConfigs_emptyBody": "Sla een diluent- en bailout-opstelling één keer op en pas hem toe op elke duik.",
+  "cylinderConfigs_new": "Nieuwe configuratie",
+  "cylinderConfigs_name": "Naam",
+  "cylinderConfigs_nameRequired": "Voer een naam in",
+  "cylinderConfigs_forUnit": "Voor unit",
+  "cylinderConfigs_noUnit": "Algemeen gasplan",
+  "cylinderConfigs_gasPlans": "Gasplannen",
+  "cylinderConfigs_addCylinder": "Fles toevoegen",
+  "cylinderConfigs_role": "Rol",
+  "cylinderConfigs_startPressure": "Begindruk",
+  "cylinderConfigs_label": "Label",
+  "cylinderConfigs_fromPreset": "Uit voorinstelling",
+  "cylinderConfigs_deleteTitle": "Configuratie verwijderen?",
+  "cylinderConfigs_deleteBody": "Duiken waarop hij al is toegepast veranderen niet.",
+  "cylinderConfigs_applyAction": "Configuratie toepassen",
+  "cylinderConfigs_applyAdded": "{count, plural, =1{1 fles toegevoegd} other{{count} flessen toegevoegd}}",
+  "@cylinderConfigs_applyAdded": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyKept": "{count, plural, =1{1 behouden} other{{count} behouden}}",
+  "@cylinderConfigs_applyKept": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyNothingToDo": "Deze duik komt al overeen met de configuratie",
+  "cylinderConfigs_sectionTitle": "Configuraties",
   "equipment_serviceClocks_hoursSource": "Berekend op basis van geregistreerde duiktijd",
   "equipment_serviceClocks_hoursLeft": "{remaining} van {total} uur resterend",
   "equipment_serviceClocks_manageKinds": "Servicetypen beheren",
diff --git a/lib/l10n/arb/app_pt.arb b/lib/l10n/arb/app_pt.arb
index 6d7bbf152f..bf36cd7822 100644
--- a/lib/l10n/arb/app_pt.arb
+++ b/lib/l10n/arb/app_pt.arb
@@ -3218,6 +3218,41 @@
   "equipment_serviceClocks_overdueSince": "Atrasado desde {date}",
   "equipment_serviceClocks_overdue": "Atrasado",
   "equipment_serviceClocks_divesLeft": "Restam {remaining} de {total} mergulhos",
+  "cylinderConfigs_title": "Configurações de garrafas",
+  "cylinderConfigs_empty": "Ainda sem configurações",
+  "cylinderConfigs_emptyBody": "Guarde uma montagem de diluente e bailout uma vez e aplique-a a qualquer mergulho.",
+  "cylinderConfigs_new": "Nova configuração",
+  "cylinderConfigs_name": "Nome",
+  "cylinderConfigs_nameRequired": "Introduza um nome",
+  "cylinderConfigs_forUnit": "Para a unidade",
+  "cylinderConfigs_noUnit": "Plano de gás genérico",
+  "cylinderConfigs_gasPlans": "Planos de gás",
+  "cylinderConfigs_addCylinder": "Adicionar garrafa",
+  "cylinderConfigs_role": "Função",
+  "cylinderConfigs_startPressure": "Pressão inicial",
+  "cylinderConfigs_label": "Etiqueta",
+  "cylinderConfigs_fromPreset": "A partir de predefinição",
+  "cylinderConfigs_deleteTitle": "Eliminar a configuração?",
+  "cylinderConfigs_deleteBody": "Os mergulhos onde já foi aplicada não são alterados.",
+  "cylinderConfigs_applyAction": "Aplicar configuração",
+  "cylinderConfigs_applyAdded": "{count, plural, =1{1 garrafa adicionada} other{{count} garrafas adicionadas}}",
+  "@cylinderConfigs_applyAdded": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyKept": "{count, plural, =1{1 mantida} other{{count} mantidas}}",
+  "@cylinderConfigs_applyKept": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyNothingToDo": "Este mergulho já corresponde à configuração",
+  "cylinderConfigs_sectionTitle": "Configurações",
   "equipment_serviceClocks_hoursSource": "Calculado a partir do tempo de mergulho registado",
   "equipment_serviceClocks_hoursLeft": "Restam {remaining} de {total} horas",
   "equipment_serviceClocks_manageKinds": "Gerenciar tipos de manutenção",
diff --git a/lib/l10n/arb/app_zh.arb b/lib/l10n/arb/app_zh.arb
index 6e1e991fb4..31eda178b6 100644
--- a/lib/l10n/arb/app_zh.arb
+++ b/lib/l10n/arb/app_zh.arb
@@ -3360,6 +3360,41 @@
   "equipment_serviceClocks_overdueSince": "自 {date} 起逾期",
   "equipment_serviceClocks_overdue": "已逾期",
   "equipment_serviceClocks_divesLeft": "剩余 {remaining}/{total} 次潜水",
+  "cylinderConfigs_title": "气瓶配置",
+  "cylinderConfigs_empty": "尚无配置",
+  "cylinderConfigs_emptyBody": "保存一次稀释气与备用气配置，即可应用到任何一次潜水。",
+  "cylinderConfigs_new": "新建配置",
+  "cylinderConfigs_name": "名称",
+  "cylinderConfigs_nameRequired": "请输入名称",
+  "cylinderConfigs_forUnit": "所属设备",
+  "cylinderConfigs_noUnit": "通用气体方案",
+  "cylinderConfigs_gasPlans": "气体方案",
+  "cylinderConfigs_addCylinder": "添加气瓶",
+  "cylinderConfigs_role": "用途",
+  "cylinderConfigs_startPressure": "起始压力",
+  "cylinderConfigs_label": "标签",
+  "cylinderConfigs_fromPreset": "从预设填入",
+  "cylinderConfigs_deleteTitle": "删除此配置？",
+  "cylinderConfigs_deleteBody": "已应用过的潜水不会改变。",
+  "cylinderConfigs_applyAction": "应用配置",
+  "cylinderConfigs_applyAdded": "{count, plural, other{已添加 {count} 个气瓶}}",
+  "@cylinderConfigs_applyAdded": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyKept": "{count, plural, other{保留 {count} 个}}",
+  "@cylinderConfigs_applyKept": {
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "cylinderConfigs_applyNothingToDo": "该潜水已与配置一致",
+  "cylinderConfigs_sectionTitle": "配置",
   "equipment_serviceClocks_hoursSource": "根据已记录的潜水时间计算",
   "equipment_serviceClocks_hoursLeft": "剩余 {remaining}/{total} 小时",
   "equipment_serviceClocks_manageKinds": "管理维护类型",
diff --git a/test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart b/test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart
new file mode 100644
index 0000000000..d495b62d53
--- /dev/null
+++ b/test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart
@@ -0,0 +1,165 @@
+import 'package:drift/drift.dart' show Value;
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/core/database/database.dart'
+    hide CylinderConfig, CylinderConfigItem;
+import 'package:submersion/core/providers/provider.dart';
+import 'package:submersion/features/cylinder_configs/data/repositories/cylinder_config_repository.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+import 'package:submersion/features/cylinder_configs/presentation/pages/cylinder_config_edit_page.dart';
+import 'package:submersion/features/divers/presentation/providers/diver_providers.dart';
+import 'package:submersion/features/settings/presentation/providers/settings_providers.dart';
+import 'package:submersion/l10n/arb/app_localizations.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+import '../../../helpers/test_database.dart';
+
+void main() {
+  late AppDatabase db;
+  late CylinderConfigRepository repo;
+  late SharedPreferences prefs;
+  final now = DateTime.utc(2026, 8, 5);
+
+  setUp(() async {
+    // settingsProvider reads SharedPreferences; without this the page throws
+    // "SharedPreferences must be initialized before use".
+    SharedPreferences.setMockInitialValues({});
+    prefs = await SharedPreferences.getInstance();
+    db = await setUpTestDatabase();
+    repo = CylinderConfigRepository();
+    final t = now.millisecondsSinceEpoch;
+    await db
+        .into(db.divers)
+        .insert(
+          DiversCompanion.insert(
+            id: 'd1',
+            name: 'd1',
+            createdAt: t,
+            updatedAt: t,
+          ),
+        );
+    await db
+        .into(db.equipment)
+        .insert(
+          EquipmentCompanion.insert(
+            id: 'rb-1',
+            name: 'JJ-CCR',
+            type: 'rebreather',
+            // allEquipmentProvider is diver-scoped; an unowned row is
+            // invisible to it.
+            diverId: const Value('d1'),
+            createdAt: t,
+            updatedAt: t,
+          ),
+        );
+  });
+  tearDown(tearDownTestDatabase);
+
+  Widget host({String? configId, String? equipmentId}) => ProviderScope(
+    overrides: [
+      validatedCurrentDiverIdProvider.overrideWith((ref) async => 'd1'),
+      sharedPreferencesProvider.overrideWithValue(prefs),
+    ],
+    child: MaterialApp(
+      // Pinned: an unpinned locale makes text finders machine-dependent.
+      locale: const Locale('en'),
+      localizationsDelegates: AppLocalizations.localizationsDelegates,
+      supportedLocales: AppLocalizations.supportedLocales,
+      home: CylinderConfigEditPage(
+        configId: configId,
+        equipmentId: equipmentId,
+      ),
+    ),
+  );
+
+  testWidgets('a new configuration starts with no cylinders', (tester) async {
+    await tester.pumpWidget(host());
+    await tester.pumpAndSettle();
+
+    expect(find.text('New configuration'), findsOneWidget);
+    expect(find.text('Add cylinder'), findsOneWidget);
+    expect(find.text('Role'), findsNothing);
+  });
+
+  testWidgets('adding a cylinder appends a row with a role selector', (
+    tester,
+  ) async {
+    await tester.pumpWidget(host());
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Add cylinder'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Role'), findsOneWidget);
+    expect(find.text('O2 %'), findsOneWidget);
+    expect(find.text('He %'), findsOneWidget);
+  });
+
+  testWidgets('saving with an empty name shows a validation error', (
+    tester,
+  ) async {
+    await tester.pumpWidget(host());
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Save'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Enter a name'), findsOneWidget);
+  });
+
+  testWidgets('an existing configuration loads its name and cylinders', (
+    tester,
+  ) async {
+    final id = await repo.createConfig(diverId: 'd1', name: 'JJ trimix');
+    await repo.saveItems(id, [
+      CylinderConfigItem(
+        id: 'i1',
+        configId: id,
+        tankRole: TankRole.diluent,
+        o2Percent: 18,
+        hePercent: 45,
+        createdAt: now,
+        updatedAt: now,
+      ),
+    ]);
+
+    await tester.pumpWidget(host(configId: id));
+    await tester.pumpAndSettle();
+
+    expect(find.text('JJ trimix'), findsOneWidget);
+    expect(find.text('18'), findsOneWidget);
+    expect(find.text('45'), findsOneWidget);
+  });
+
+  testWidgets('the owning unit dropdown lists rebreathers plus a generic '
+      'option', (tester) async {
+    await tester.pumpWidget(host());
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Generic gas plan'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('JJ-CCR'), findsOneWidget);
+  });
+
+  testWidgets('saving persists the configuration and its cylinders', (
+    tester,
+  ) async {
+    await tester.pumpWidget(host(equipmentId: 'rb-1'));
+    await tester.pumpAndSettle();
+
+    await tester.enterText(find.byType(TextFormField).first, 'Bailout plan');
+    await tester.tap(find.text('Add cylinder'));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Save'));
+    await tester.pumpAndSettle();
+
+    final saved = await repo.getAllConfigs(includeItems: true);
+    expect(saved, hasLength(1));
+    expect(saved.single.name, 'Bailout plan');
+    expect(saved.single.equipmentId, 'rb-1');
+    expect(saved.single.cylinderCount, 1);
+  });
+}

From 9d6d9278a2e420da6a705e6e5ab4a1e247eba0f4 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 18:32:23 -0400
Subject: [PATCH 17/20] Apply cylinder configurations to a dive's cylinders
 (#804)

Adds an Apply configuration menu to the dive edit gas/gear section, grouped by
owning rebreather with generic gas plans separate, hidden entirely when the
diver has no configurations.

Deviates from the plan on where the merge lands. The plan had a service
writing to dive_tanks, but the dive edit page holds its cylinders as unsaved
form state until Save: writing through would bypass dirty tracking and persist
changes even if the diver then cancelled. DiveTankConfigAdapter therefore
translates between DiveTank and the pure applier's view and returns a NEW
list, which the page merges into its local state and marks dirty.

All merge rules still live in CylinderConfigApplier, so the never-overwrite-gas
guarantee is unchanged and the adapter stays pure (ids are supplied by the
caller, no DateTime.now()).
---
 .../services/dive_tank_config_adapter.dart    |  85 +++++++++
 .../widgets/apply_configuration_menu.dart     |  87 +++++++++
 .../presentation/pages/dive_edit_page.dart    |  43 +++++
 .../edit_sections/gas_gear_section.dart       |   6 +
 .../dive_tank_config_adapter_test.dart        | 175 ++++++++++++++++++
 .../apply_configuration_menu_test.dart        | 117 ++++++++++++
 6 files changed, 513 insertions(+)
 create mode 100644 lib/features/cylinder_configs/domain/services/dive_tank_config_adapter.dart
 create mode 100644 lib/features/cylinder_configs/presentation/widgets/apply_configuration_menu.dart
 create mode 100644 test/features/cylinder_configs/domain/services/dive_tank_config_adapter_test.dart
 create mode 100644 test/features/cylinder_configs/presentation/apply_configuration_menu_test.dart

diff --git a/lib/features/cylinder_configs/domain/services/dive_tank_config_adapter.dart b/lib/features/cylinder_configs/domain/services/dive_tank_config_adapter.dart
new file mode 100644
index 0000000000..bcc5022bf6
--- /dev/null
+++ b/lib/features/cylinder_configs/domain/services/dive_tank_config_adapter.dart
@@ -0,0 +1,85 @@
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+import 'package:submersion/features/cylinder_configs/domain/services/cylinder_config_applier.dart';
+import 'package:submersion/features/dive_log/domain/entities/dive.dart';
+
+/// Applies a cylinder configuration to an in-memory list of dive tanks.
+///
+/// The dive edit page holds its cylinders as unsaved local state and persists
+/// them only when the diver taps Save, so applying a configuration must
+/// produce a NEW list rather than writing to dive_tanks. Writing straight to
+/// the database would bypass the page's dirty tracking and would persist
+/// changes even if the diver then cancelled.
+///
+/// All merge rules live in [CylinderConfigApplier]; this only translates
+/// between DiveTank and the applier's ExistingTank view, and materialises the
+/// resulting ops.
+class DiveTankConfigAdapter {
+  const DiveTankConfigAdapter({this.applier = const CylinderConfigApplier()});
+
+  final CylinderConfigApplier applier;
+
+  ExistingTank _toExisting(DiveTank tank) => ExistingTank(
+    id: tank.id,
+    tankRole: tank.role,
+    volumeL: tank.volume,
+    workingPressureBar: tank.workingPressure,
+    tankMaterial: tank.material,
+    startPressureBar: tank.startPressure,
+    tankName: tank.name,
+    tankOrder: tank.order,
+  );
+
+  DiveTank _fromItem(CylinderConfigItem item, int order, String id) => DiveTank(
+    id: id,
+    name: item.label,
+    volume: item.volumeL,
+    workingPressure: item.workingPressureBar,
+    startPressure: item.defaultStartPressureBar,
+    gasMix: GasMix(o2: item.o2Percent, he: item.hePercent),
+    role: item.tankRole,
+    material: item.tankMaterial,
+    order: order,
+  );
+
+  /// Returns the merged tank list plus the counts to report to the diver.
+  ///
+  /// [newId] mints an id for each inserted tank; the caller supplies it so
+  /// this stays pure and testable (no Uuid, no DateTime.now()).
+  ({List<DiveTank> tanks, int added, int kept}) apply({
+    required List<DiveTank> tanks,
+    required List<CylinderConfigItem> items,
+    required String Function(int insertIndex) newId,
+  }) {
+    final plan = applier.plan(
+      existing: tanks.map(_toExisting).toList(),
+      items: items,
+    );
+
+    final byId = {for (final tank in tanks) tank.id: tank};
+    var insertIndex = 0;
+
+    for (final op in plan.ops) {
+      switch (op) {
+        case FillTank():
+          final current = byId[op.tankId];
+          if (current == null) continue;
+          byId[op.tankId] = current.copyWith(
+            volume: op.volumeL,
+            workingPressure: op.workingPressureBar,
+            material: op.tankMaterial,
+            startPressure: op.startPressureBar,
+            name: op.tankName,
+          );
+        case InsertTank():
+          final id = newId(insertIndex);
+          byId[id] = _fromItem(op.item, op.tankOrder, id);
+          insertIndex++;
+      }
+    }
+
+    final merged = byId.values.toList()
+      ..sort((a, b) => a.order.compareTo(b.order));
+
+    return (tanks: merged, added: plan.insertedCount, kept: plan.keptCount);
+  }
+}
diff --git a/lib/features/cylinder_configs/presentation/widgets/apply_configuration_menu.dart b/lib/features/cylinder_configs/presentation/widgets/apply_configuration_menu.dart
new file mode 100644
index 0000000000..c6e7dd77d8
--- /dev/null
+++ b/lib/features/cylinder_configs/presentation/widgets/apply_configuration_menu.dart
@@ -0,0 +1,87 @@
+import 'package:flutter/material.dart';
+
+import 'package:submersion/core/providers/provider.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config.dart';
+import 'package:submersion/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart';
+import 'package:submersion/features/equipment/presentation/providers/equipment_providers.dart';
+import 'package:submersion/l10n/l10n_extension.dart';
+
+/// Lets the diver pick a configuration to merge into the dive's cylinders.
+///
+/// Renders nothing when the diver has no configurations, so the control never
+/// appears as a dead end.
+class ApplyConfigurationMenu extends ConsumerWidget {
+  const ApplyConfigurationMenu({super.key, required this.onSelected});
+
+  final ValueChanged<CylinderConfig> onSelected;
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final l10n = context.l10n;
+    final configs = ref.watch(cylinderConfigsProvider).valueOrNull ?? const [];
+    if (configs.isEmpty) return const SizedBox.shrink();
+
+    final unitNames = <String, String>{
+      for (final item
+          in ref.watch(allEquipmentProvider).valueOrNull ?? const [])
+        item.id: item.name,
+    };
+
+    final owned = <String, List<CylinderConfig>>{};
+    final generic = <CylinderConfig>[];
+    for (final config in configs) {
+      final unitId = config.equipmentId;
+      if (unitId == null) {
+        generic.add(config);
+      } else {
+        owned.putIfAbsent(unitId, () => []).add(config);
+      }
+    }
+
+    return PopupMenuButton<CylinderConfig>(
+      tooltip: l10n.cylinderConfigs_applyAction,
+      onSelected: onSelected,
+      itemBuilder: (context) => [
+        for (final entry in owned.entries) ...[
+          PopupMenuItem<CylinderConfig>(
+            enabled: false,
+            child: Text(
+              unitNames[entry.key] ?? l10n.cylinderConfigs_forUnit,
+              style: Theme.of(context).textTheme.labelSmall,
+            ),
+          ),
+          for (final config in entry.value)
+            PopupMenuItem<CylinderConfig>(
+              value: config,
+              child: Text(config.name),
+            ),
+        ],
+        if (generic.isNotEmpty) ...[
+          PopupMenuItem<CylinderConfig>(
+            enabled: false,
+            child: Text(
+              l10n.cylinderConfigs_gasPlans,
+              style: Theme.of(context).textTheme.labelSmall,
+            ),
+          ),
+          for (final config in generic)
+            PopupMenuItem<CylinderConfig>(
+              value: config,
+              child: Text(config.name),
+            ),
+        ],
+      ],
+      child: Padding(
+        padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 12),
+        child: Row(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            const Icon(Icons.playlist_add_check, size: 20),
+            const SizedBox(width: 8),
+            Text(l10n.cylinderConfigs_applyAction),
+          ],
+        ),
+      ),
+    );
+  }
+}
diff --git a/lib/features/dive_log/presentation/pages/dive_edit_page.dart b/lib/features/dive_log/presentation/pages/dive_edit_page.dart
index 8bf89101eb..9bef2168cd 100644
--- a/lib/features/dive_log/presentation/pages/dive_edit_page.dart
+++ b/lib/features/dive_log/presentation/pages/dive_edit_page.dart
@@ -54,6 +54,9 @@ import 'package:submersion/features/dive_log/presentation/widgets/edit_sections/
 import 'package:submersion/features/dive_log/presentation/widgets/edit_sections/experience_section.dart';
 import 'package:submersion/features/dive_log/presentation/widgets/edit_sections/gas_gear_section.dart';
 import 'package:submersion/features/dive_log/presentation/widgets/edit_sections/rare_sections.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config.dart';
+import 'package:submersion/features/cylinder_configs/domain/services/dive_tank_config_adapter.dart';
+import 'package:submersion/features/cylinder_configs/presentation/widgets/apply_configuration_menu.dart';
 import 'package:submersion/features/dive_log/presentation/widgets/edit_sections/tank_row.dart';
 import 'package:submersion/features/dive_log/presentation/widgets/edit_sections/the_dive_section.dart';
 import 'package:submersion/features/dive_log/presentation/widgets/edit_sections/trip_section.dart';
@@ -2451,6 +2454,9 @@ class _DiveEditPageState extends ConsumerState<DiveEditPage> {
       ],
       onAddTank: _addTank,
       addTankLabel: context.l10n.diveLog_edit_addTank,
+      applyConfigChild: ApplyConfigurationMenu(
+        onSelected: _applyCylinderConfig,
+      ),
       equipmentChild: _equipmentChild(),
       weightChild: _weightChild(units),
       showTankControls: _diveMode != DiveMode.gauge,
@@ -2719,6 +2725,43 @@ class _DiveEditPageState extends ConsumerState<DiveEditPage> {
     );
   }
 
+  /// Merges a saved cylinder configuration into the in-memory tank list.
+  ///
+  /// Deliberately does not touch dive_tanks: these cylinders are unsaved form
+  /// state until the diver taps Save, so writing through would bypass dirty
+  /// tracking and persist changes even if they then cancelled. All merge
+  /// rules live in CylinderConfigApplier via DiveTankConfigAdapter, which
+  /// never overwrites a gas mix already on the dive.
+  void _applyCylinderConfig(CylinderConfig config) {
+    final messenger = ScaffoldMessenger.of(context);
+    final l10n = context.l10n;
+
+    final result = const DiveTankConfigAdapter().apply(
+      tanks: _tanks,
+      items: config.items,
+      newId: (_) => _uuid.v4(),
+    );
+
+    setState(() {
+      _markDirty();
+      _tanksDirty = true;
+      _tanks
+        ..clear()
+        ..addAll(result.tanks);
+    });
+
+    messenger.showSnackBar(
+      SnackBar(
+        content: Text(
+          result.added == 0 && result.kept == 0
+              ? l10n.cylinderConfigs_applyNothingToDo
+              : '${l10n.cylinderConfigs_applyAdded(result.added)}, '
+                    '${l10n.cylinderConfigs_applyKept(result.kept)}',
+        ),
+      ),
+    );
+  }
+
   void _addTank() {
     final settings = ref.read(settingsProvider);
     setState(() {
diff --git a/lib/features/dive_log/presentation/widgets/edit_sections/gas_gear_section.dart b/lib/features/dive_log/presentation/widgets/edit_sections/gas_gear_section.dart
index 831af73102..6f053d4ceb 100644
--- a/lib/features/dive_log/presentation/widgets/edit_sections/gas_gear_section.dart
+++ b/lib/features/dive_log/presentation/widgets/edit_sections/gas_gear_section.dart
@@ -22,6 +22,7 @@ class GasGearSection extends StatelessWidget {
     required this.equipmentChild,
     required this.weightChild,
     this.rebreatherPanel,
+    this.applyConfigChild,
     this.showTankControls = true,
     this.errorCount = 0,
   });
@@ -41,6 +42,10 @@ class GasGearSection extends StatelessWidget {
   /// CcrSettingsPanel / ScrSettingsPanel when the mode requires one.
   final Widget? rebreatherPanel;
 
+  /// ApplyConfigurationMenu, when the diver has saved configurations. Sits
+  /// below the add-cylinder row because it is the bulk alternative to it.
+  final Widget? applyConfigChild;
+
   /// False for gauge dives, which log depth and time only.
   final bool showTankControls;
 
@@ -67,6 +72,7 @@ class GasGearSection extends StatelessWidget {
               FormOverline(label: l10n.diveLog_edit_overline_tanks),
               ...tanks,
               FormAppendRow(label: addTankLabel, onTap: onAddTank),
+              ?applyConfigChild,
             ],
           ),
         equipmentChild,
diff --git a/test/features/cylinder_configs/domain/services/dive_tank_config_adapter_test.dart b/test/features/cylinder_configs/domain/services/dive_tank_config_adapter_test.dart
new file mode 100644
index 0000000000..a95422b576
--- /dev/null
+++ b/test/features/cylinder_configs/domain/services/dive_tank_config_adapter_test.dart
@@ -0,0 +1,175 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+import 'package:submersion/features/cylinder_configs/domain/services/dive_tank_config_adapter.dart';
+import 'package:submersion/features/dive_log/domain/entities/dive.dart';
+
+void main() {
+  final now = DateTime.utc(2026, 8, 5);
+  const adapter = DiveTankConfigAdapter();
+
+  String newId(int index) => 'new-$index';
+
+  CylinderConfigItem cfg({
+    required String id,
+    required TankRole role,
+    int order = 0,
+    double o2 = 21,
+    double he = 0,
+    double? volume,
+    double? pressure,
+    TankMaterial? material,
+    double? startPressure,
+    String? label,
+  }) => CylinderConfigItem(
+    id: id,
+    configId: 'c1',
+    sortOrder: order,
+    tankRole: role,
+    o2Percent: o2,
+    hePercent: he,
+    volumeL: volume,
+    workingPressureBar: pressure,
+    tankMaterial: material,
+    defaultStartPressureBar: startPressure,
+    label: label,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  test('an empty dive gets every cylinder, with gas and roles', () {
+    final result = adapter.apply(
+      tanks: const [],
+      items: [
+        cfg(id: 'a', role: TankRole.diluent, order: 0, o2: 18, he: 45),
+        cfg(id: 'b', role: TankRole.oxygenSupply, order: 1, o2: 100),
+        cfg(id: 'c', role: TankRole.bailout, order: 2, o2: 21),
+      ],
+      newId: newId,
+    );
+
+    expect(result.added, 3);
+    expect(result.kept, 0);
+    expect(result.tanks.map((t) => t.role), [
+      TankRole.diluent,
+      TankRole.oxygenSupply,
+      TankRole.bailout,
+    ]);
+    expect(result.tanks.first.gasMix.o2, 18);
+    expect(result.tanks.first.gasMix.he, 45);
+    expect(result.tanks[1].gasMix.o2, 100);
+  });
+
+  test('a downloaded gas mix survives the merge untouched', () {
+    final result = adapter.apply(
+      tanks: [
+        const DiveTank(
+          id: 't1',
+          role: TankRole.diluent,
+          gasMix: GasMix(o2: 21, he: 0),
+        ),
+      ],
+      items: [
+        cfg(id: 'a', role: TankRole.diluent, o2: 18, he: 45, pressure: 232),
+      ],
+      newId: newId,
+    );
+
+    expect(result.kept, 1);
+    expect(result.added, 0);
+
+    final diluent = result.tanks.single;
+    expect(diluent.id, 't1');
+    expect(diluent.gasMix.o2, 21, reason: 'downloaded gas must not change');
+    expect(diluent.gasMix.he, 0);
+    expect(diluent.workingPressure, 232, reason: 'null column is filled');
+  });
+
+  test('only null fields are filled on a claimed tank', () {
+    final result = adapter.apply(
+      tanks: [
+        const DiveTank(
+          id: 't1',
+          role: TankRole.bailout,
+          volume: 11.1,
+          name: 'Downloaded',
+        ),
+      ],
+      items: [
+        cfg(
+          id: 'a',
+          role: TankRole.bailout,
+          volume: 5.7,
+          pressure: 207,
+          material: TankMaterial.aluminum,
+          startPressure: 200,
+          label: 'Bailout 1',
+        ),
+      ],
+      newId: newId,
+    );
+
+    final tank = result.tanks.single;
+    expect(tank.volume, 11.1, reason: 'already set');
+    expect(tank.name, 'Downloaded', reason: 'already set');
+    expect(tank.workingPressure, 207);
+    expect(tank.material, TankMaterial.aluminum);
+    expect(tank.startPressure, 200);
+  });
+
+  test('applying twice is idempotent', () {
+    final items = [
+      cfg(id: 'a', role: TankRole.diluent, order: 0, o2: 18, he: 45),
+      cfg(id: 'b', role: TankRole.bailout, order: 1),
+    ];
+
+    final first = adapter.apply(tanks: const [], items: items, newId: newId);
+    final second = adapter.apply(
+      tanks: first.tanks,
+      items: items,
+      newId: newId,
+    );
+
+    expect(second.added, 0);
+    expect(second.kept, 2);
+    expect(second.tanks, hasLength(2));
+  });
+
+  test('existing tanks the config does not mention are preserved', () {
+    final result = adapter.apply(
+      tanks: [
+        const DiveTank(id: 't1', role: TankRole.stage, order: 0),
+        const DiveTank(id: 't2', role: TankRole.diluent, order: 1),
+      ],
+      items: [cfg(id: 'a', role: TankRole.diluent)],
+      newId: newId,
+    );
+
+    expect(result.tanks.map((t) => t.id), ['t1', 't2']);
+    expect(result.kept, 1);
+    expect(result.added, 0);
+  });
+
+  test('inserted tanks continue the existing order and sort last', () {
+    final result = adapter.apply(
+      tanks: [const DiveTank(id: 't1', role: TankRole.stage, order: 4)],
+      items: [
+        cfg(id: 'a', role: TankRole.diluent, order: 0),
+        cfg(id: 'b', role: TankRole.bailout, order: 1),
+      ],
+      newId: newId,
+    );
+
+    expect(result.tanks.map((t) => t.order), [4, 5, 6]);
+    expect(result.tanks.map((t) => t.id), ['t1', 'new-0', 'new-1']);
+  });
+
+  test('an empty configuration leaves the list alone', () {
+    final tanks = [const DiveTank(id: 't1', role: TankRole.diluent)];
+    final result = adapter.apply(tanks: tanks, items: const [], newId: newId);
+
+    expect(result.tanks, tanks);
+    expect(result.added, 0);
+    expect(result.kept, 0);
+  });
+}
diff --git a/test/features/cylinder_configs/presentation/apply_configuration_menu_test.dart b/test/features/cylinder_configs/presentation/apply_configuration_menu_test.dart
new file mode 100644
index 0000000000..b837469574
--- /dev/null
+++ b/test/features/cylinder_configs/presentation/apply_configuration_menu_test.dart
@@ -0,0 +1,117 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/core/providers/provider.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config.dart';
+import 'package:submersion/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart';
+import 'package:submersion/features/cylinder_configs/presentation/widgets/apply_configuration_menu.dart';
+import 'package:submersion/features/equipment/domain/entities/equipment_item.dart';
+import 'package:submersion/features/equipment/presentation/providers/equipment_providers.dart';
+import 'package:submersion/l10n/arb/app_localizations.dart';
+
+void main() {
+  final now = DateTime.utc(2026, 8, 5);
+
+  CylinderConfig config({
+    required String id,
+    required String name,
+    String? equipmentId,
+  }) => CylinderConfig(
+    id: id,
+    name: name,
+    equipmentId: equipmentId,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  const unit = EquipmentItem(
+    id: 'rb-1',
+    name: 'JJ-CCR',
+    type: EquipmentType.rebreather,
+  );
+
+  Widget host({
+    required List<CylinderConfig> configs,
+    ValueChanged<CylinderConfig>? onSelected,
+  }) => ProviderScope(
+    overrides: [
+      cylinderConfigsProvider.overrideWith((ref) async => configs),
+      allEquipmentProvider.overrideWith((ref) async => [unit]),
+    ],
+    child: MaterialApp(
+      // Pinned: an unpinned locale makes text finders machine-dependent.
+      locale: const Locale('en'),
+      localizationsDelegates: AppLocalizations.localizationsDelegates,
+      supportedLocales: AppLocalizations.supportedLocales,
+      home: Scaffold(
+        body: ApplyConfigurationMenu(onSelected: onSelected ?? (_) {}),
+      ),
+    ),
+  );
+
+  testWidgets('the menu is hidden when the diver has no configurations', (
+    tester,
+  ) async {
+    await tester.pumpWidget(host(configs: const []));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Apply configuration'), findsNothing);
+  });
+
+  testWidgets('configs are grouped by owning unit with a Gas plans section', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      host(
+        configs: [
+          config(id: 'c1', name: 'JJ trimix', equipmentId: 'rb-1'),
+          config(id: 'c2', name: 'Doubles + 50'),
+        ],
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Apply configuration'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('JJ-CCR'), findsOneWidget);
+    expect(find.text('JJ trimix'), findsOneWidget);
+    expect(find.text('Gas plans'), findsOneWidget);
+    expect(find.text('Doubles + 50'), findsOneWidget);
+  });
+
+  testWidgets('choosing a configuration reports it to the caller', (
+    tester,
+  ) async {
+    CylinderConfig? chosen;
+    await tester.pumpWidget(
+      host(
+        configs: [config(id: 'c1', name: 'JJ trimix', equipmentId: 'rb-1')],
+        onSelected: (c) => chosen = c,
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Apply configuration'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('JJ trimix'));
+    await tester.pumpAndSettle();
+
+    expect(chosen?.id, 'c1');
+  });
+
+  testWidgets('a generic-only list shows no unit header', (tester) async {
+    await tester.pumpWidget(
+      host(
+        configs: [config(id: 'c1', name: 'Doubles + 50')],
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Apply configuration'));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Gas plans'), findsOneWidget);
+    expect(find.text('JJ-CCR'), findsNothing);
+  });
+}

From 71f7a1e14e71ca242cc14abf9142b9cd9af48ec0 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 18:35:26 -0400
Subject: [PATCH 18/20] Show cylinder configurations on the rebreather detail
 page (#804)

A Configurations card listing the unit's configurations with their roles and
cylinder count, plus an add action that pre-fills the owning unit through a
query parameter. Rendered only for rebreathers: any other type would show a
card that can never be anything but empty.

Closes the issue's 'configurations for each CCR' phrasing by making them
reachable from the unit, even though the underlying entity is generic and
equally usable as an open-circuit gas plan.
---
 .../widgets/unit_configurations_card.dart     | 96 +++++++++++++++++++
 .../pages/equipment_detail_page.dart          |  7 ++
 .../unit_configurations_card_test.dart        | 73 ++++++++++++++
 3 files changed, 176 insertions(+)
 create mode 100644 lib/features/cylinder_configs/presentation/widgets/unit_configurations_card.dart
 create mode 100644 test/features/cylinder_configs/presentation/unit_configurations_card_test.dart

diff --git a/lib/features/cylinder_configs/presentation/widgets/unit_configurations_card.dart b/lib/features/cylinder_configs/presentation/widgets/unit_configurations_card.dart
new file mode 100644
index 0000000000..2764c1d6c7
--- /dev/null
+++ b/lib/features/cylinder_configs/presentation/widgets/unit_configurations_card.dart
@@ -0,0 +1,96 @@
+import 'package:flutter/material.dart';
+import 'package:go_router/go_router.dart';
+
+import 'package:submersion/core/providers/provider.dart';
+import 'package:submersion/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart';
+import 'package:submersion/l10n/l10n_extension.dart';
+
+/// The configurations belonging to one rebreather, shown on its detail page.
+///
+/// Answers the issue's "configurations for each CCR" phrasing by making them
+/// reachable from the unit, even though the underlying entity is generic.
+class UnitConfigurationsCard extends ConsumerWidget {
+  const UnitConfigurationsCard({super.key, required this.equipmentId});
+
+  final String equipmentId;
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final l10n = context.l10n;
+    final configsAsync = ref.watch(
+      cylinderConfigsForEquipmentProvider(equipmentId),
+    );
+
+    return Card(
+      child: Padding(
+        padding: const EdgeInsets.all(16),
+        child: Column(
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Row(
+              children: [
+                Icon(
+                  Icons.propane_tank_outlined,
+                  color: Theme.of(context).colorScheme.primary,
+                ),
+                const SizedBox(width: 8),
+                Text(
+                  l10n.cylinderConfigs_sectionTitle,
+                  style: Theme.of(context).textTheme.titleMedium,
+                ),
+                const Spacer(),
+                TextButton.icon(
+                  onPressed: () => context.push(
+                    '/equipment/cylinder-configs/new'
+                    '?equipmentId=$equipmentId',
+                  ),
+                  icon: const Icon(Icons.add),
+                  label: Text(l10n.cylinderConfigs_new),
+                ),
+              ],
+            ),
+            const Divider(),
+            configsAsync.when(
+              loading: () => const Padding(
+                padding: EdgeInsets.symmetric(vertical: 12),
+                child: Center(child: CircularProgressIndicator()),
+              ),
+              error: (error, _) => Text('$error'),
+              data: (configs) {
+                if (configs.isEmpty) {
+                  return Padding(
+                    padding: const EdgeInsets.symmetric(vertical: 8),
+                    child: Text(
+                      l10n.cylinderConfigs_emptyBody,
+                      style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                        color: Theme.of(context).colorScheme.onSurfaceVariant,
+                      ),
+                    ),
+                  );
+                }
+                return Column(
+                  children: [
+                    for (final config in configs)
+                      ListTile(
+                        contentPadding: EdgeInsets.zero,
+                        title: Text(config.name),
+                        subtitle: Text(
+                          config.items
+                              .map((i) => i.tankRole.displayName)
+                              .join(', '),
+                        ),
+                        trailing: Text('${config.cylinderCount}'),
+                        onTap: () => context.push(
+                          '/equipment/cylinder-configs/${config.id}',
+                        ),
+                      ),
+                  ],
+                );
+              },
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}
diff --git a/lib/features/equipment/presentation/pages/equipment_detail_page.dart b/lib/features/equipment/presentation/pages/equipment_detail_page.dart
index 9c2994c6aa..b1b5bd69e5 100644
--- a/lib/features/equipment/presentation/pages/equipment_detail_page.dart
+++ b/lib/features/equipment/presentation/pages/equipment_detail_page.dart
@@ -21,6 +21,7 @@ import 'package:submersion/features/equipment/domain/entities/service_record.dar
 import 'package:submersion/features/equipment/presentation/providers/equipment_providers.dart';
 import 'package:submersion/features/equipment/presentation/utils/equipment_attribute_l10n.dart';
 import 'package:submersion/features/equipment/presentation/utils/equipment_attribute_units.dart';
+import 'package:submersion/features/cylinder_configs/presentation/widgets/unit_configurations_card.dart';
 import 'package:submersion/features/equipment/presentation/widgets/service_clocks_card.dart';
 
 class EquipmentDetailPage extends ConsumerStatefulWidget {
@@ -160,6 +161,12 @@ class _EquipmentDetailContent extends ConsumerWidget {
               serviceKindId: status.kind.id,
             ),
           ),
+          // Only rebreathers own configurations; every other type would show
+          // a card that can never be anything but empty.
+          if (equipment.type == EquipmentType.rebreather) ...[
+            const SizedBox(height: 24),
+            UnitConfigurationsCard(equipmentId: equipmentId),
+          ],
           const SizedBox(height: 24),
           _ServiceHistorySection(equipmentId: equipmentId),
           if (equipment.notes.isNotEmpty) ...[
diff --git a/test/features/cylinder_configs/presentation/unit_configurations_card_test.dart b/test/features/cylinder_configs/presentation/unit_configurations_card_test.dart
new file mode 100644
index 0000000000..aadf438bd4
--- /dev/null
+++ b/test/features/cylinder_configs/presentation/unit_configurations_card_test.dart
@@ -0,0 +1,73 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/core/providers/provider.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+import 'package:submersion/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart';
+import 'package:submersion/features/cylinder_configs/presentation/widgets/unit_configurations_card.dart';
+import 'package:submersion/l10n/arb/app_localizations.dart';
+
+void main() {
+  final now = DateTime.utc(2026, 8, 5);
+
+  CylinderConfigItem item(TankRole role) => CylinderConfigItem(
+    id: 'i-${role.name}',
+    configId: 'c1',
+    tankRole: role,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  Widget host(List<CylinderConfig> configs) => ProviderScope(
+    overrides: [
+      cylinderConfigsForEquipmentProvider(
+        'rb-1',
+      ).overrideWith((ref) async => configs),
+    ],
+    child: const MaterialApp(
+      // Pinned: an unpinned locale makes text finders machine-dependent.
+      locale: Locale('en'),
+      localizationsDelegates: AppLocalizations.localizationsDelegates,
+      supportedLocales: AppLocalizations.supportedLocales,
+      home: Scaffold(body: UnitConfigurationsCard(equipmentId: 'rb-1')),
+    ),
+  );
+
+  testWidgets("lists the unit's configurations with cylinder counts", (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      host([
+        CylinderConfig(
+          id: 'c1',
+          name: 'JJ trimix',
+          equipmentId: 'rb-1',
+          items: [item(TankRole.diluent), item(TankRole.oxygenSupply)],
+          createdAt: now,
+          updatedAt: now,
+        ),
+      ]),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.text('Configurations'), findsOneWidget);
+    expect(find.text('JJ trimix'), findsOneWidget);
+    expect(find.text('Diluent, O₂ Supply'), findsOneWidget);
+    expect(find.text('2'), findsOneWidget);
+  });
+
+  testWidgets('shows an empty state with an add action when there are none', (
+    tester,
+  ) async {
+    await tester.pumpWidget(host(const []));
+    await tester.pumpAndSettle();
+
+    expect(find.text('Configurations'), findsOneWidget);
+    expect(find.text('New configuration'), findsOneWidget);
+    expect(
+      find.textContaining('Save a diluent and bailout setup once'),
+      findsOneWidget,
+    );
+  });
+}

From 1089646f360ea711f74cb573d52d007a672d9aa0 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 21:00:43 -0400
Subject: [PATCH 19/20] Address review feedback on PR #868

Three fixes from the Copilot review:

Diver scoping: the edit page inferred diverId from an existing configuration,
so with none yet it saved null. A null diver_id never matches a diver-scoped
query, meaning the FIRST configuration a diver ever created persisted but was
invisible in every list. Now reads validatedCurrentDiverIdProvider directly.
The existing test missed this because it asserted through an unfiltered
getAllConfigs, which skips the where clause entirely; it now reads scoped, and
a regression test covers the empty-database path.

No-op apply: "nothing to do" was derived from added == 0 && kept == 0, but a
repeat apply matches every role and reports a non-zero kept while doing no
work, so it read "Added 0 cylinders, kept 3" and, worse, marked the form
dirty, raising an unsaved-changes prompt for a merge that changed nothing.
DiveTankConfigAdapter now returns a "changed" flag derived from the plan's ops
rather than from the counts.

Localization: the O2 % and He % field labels were hardcoded; they now reuse
gasCalculators_mnd_o2Percent and gasCalculators_mnd_hePercent, which already
carry translations in all 11 locales.
---
 .../services/dive_tank_config_adapter.dart    | 17 ++++++++++---
 .../pages/cylinder_config_edit_page.dart      |  9 ++++---
 .../widgets/cylinder_config_item_editor.dart  |  8 ++++--
 .../presentation/pages/dive_edit_page.dart    | 16 +++++++++---
 .../dive_tank_config_adapter_test.dart        | 19 +++++++++++++-
 .../cylinder_config_edit_page_test.dart       | 25 ++++++++++++++++++-
 6 files changed, 80 insertions(+), 14 deletions(-)

diff --git a/lib/features/cylinder_configs/domain/services/dive_tank_config_adapter.dart b/lib/features/cylinder_configs/domain/services/dive_tank_config_adapter.dart
index bcc5022bf6..07e43c689f 100644
--- a/lib/features/cylinder_configs/domain/services/dive_tank_config_adapter.dart
+++ b/lib/features/cylinder_configs/domain/services/dive_tank_config_adapter.dart
@@ -41,11 +41,17 @@ class DiveTankConfigAdapter {
     order: order,
   );
 
-  /// Returns the merged tank list plus the counts to report to the diver.
+  /// Returns the merged tank list, the counts to report to the diver, and
+  /// whether anything actually changed.
+  ///
+  /// [changed] is derived from the plan's ops, not from the counts: a repeat
+  /// apply matches every role and so reports a non-zero [kept] while doing no
+  /// work at all. Callers use it to avoid marking a form dirty for a merge
+  /// that altered nothing.
   ///
   /// [newId] mints an id for each inserted tank; the caller supplies it so
   /// this stays pure and testable (no Uuid, no DateTime.now()).
-  ({List<DiveTank> tanks, int added, int kept}) apply({
+  ({List<DiveTank> tanks, int added, int kept, bool changed}) apply({
     required List<DiveTank> tanks,
     required List<CylinderConfigItem> items,
     required String Function(int insertIndex) newId,
@@ -80,6 +86,11 @@ class DiveTankConfigAdapter {
     final merged = byId.values.toList()
       ..sort((a, b) => a.order.compareTo(b.order));
 
-    return (tanks: merged, added: plan.insertedCount, kept: plan.keptCount);
+    return (
+      tanks: merged,
+      added: plan.insertedCount,
+      kept: plan.keptCount,
+      changed: plan.ops.isNotEmpty,
+    );
   }
 }
diff --git a/lib/features/cylinder_configs/presentation/pages/cylinder_config_edit_page.dart b/lib/features/cylinder_configs/presentation/pages/cylinder_config_edit_page.dart
index e2dda4d949..6372b21ccb 100644
--- a/lib/features/cylinder_configs/presentation/pages/cylinder_config_edit_page.dart
+++ b/lib/features/cylinder_configs/presentation/pages/cylinder_config_edit_page.dart
@@ -7,6 +7,7 @@ import 'package:submersion/core/utils/unit_formatter.dart';
 import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
 import 'package:submersion/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart';
 import 'package:submersion/features/cylinder_configs/presentation/widgets/cylinder_config_item_editor.dart';
+import 'package:submersion/features/divers/presentation/providers/diver_providers.dart';
 import 'package:submersion/features/equipment/domain/entities/equipment_item.dart';
 import 'package:submersion/features/equipment/presentation/providers/equipment_providers.dart';
 import 'package:submersion/features/settings/presentation/providers/settings_providers.dart';
@@ -91,9 +92,11 @@ class _CylinderConfigEditPageState
     setState(() => _saving = true);
 
     final repository = ref.read(cylinderConfigRepositoryProvider);
-    final diverId = await ref
-        .read(cylinderConfigsProvider.future)
-        .then((configs) => configs.isNotEmpty ? configs.first.diverId : null);
+    // Read the active diver directly. Bootstrapping this from an existing
+    // config made the first write depend on a prior one: with no configs yet
+    // the id was null, and a null diver_id is invisible to every
+    // diver-scoped query, so the first configuration ever saved vanished.
+    final diverId = await ref.read(validatedCurrentDiverIdProvider.future);
 
     var id = widget.configId;
     if (id == null) {
diff --git a/lib/features/cylinder_configs/presentation/widgets/cylinder_config_item_editor.dart b/lib/features/cylinder_configs/presentation/widgets/cylinder_config_item_editor.dart
index 8f593e8b44..5c052cdf70 100644
--- a/lib/features/cylinder_configs/presentation/widgets/cylinder_config_item_editor.dart
+++ b/lib/features/cylinder_configs/presentation/widgets/cylinder_config_item_editor.dart
@@ -150,7 +150,9 @@ class _CylinderConfigItemEditorState
                   keyboardType: const TextInputType.numberWithOptions(
                     decimal: true,
                   ),
-                  decoration: const InputDecoration(labelText: 'O2 %'),
+                  decoration: InputDecoration(
+                    labelText: l10n.gasCalculators_mnd_o2Percent,
+                  ),
                   // Only a parseable value updates the model: transient states
                   // like a lone "." must not clobber the stored mix.
                   onChanged: (text) {
@@ -168,7 +170,9 @@ class _CylinderConfigItemEditorState
                   keyboardType: const TextInputType.numberWithOptions(
                     decimal: true,
                   ),
-                  decoration: const InputDecoration(labelText: 'He %'),
+                  decoration: InputDecoration(
+                    labelText: l10n.gasCalculators_mnd_hePercent,
+                  ),
                   onChanged: (text) {
                     final parsed = _parse(text);
                     if (parsed != null) {
diff --git a/lib/features/dive_log/presentation/pages/dive_edit_page.dart b/lib/features/dive_log/presentation/pages/dive_edit_page.dart
index 9bef2168cd..4e5211c72a 100644
--- a/lib/features/dive_log/presentation/pages/dive_edit_page.dart
+++ b/lib/features/dive_log/presentation/pages/dive_edit_page.dart
@@ -2742,6 +2742,16 @@ class _DiveEditPageState extends ConsumerState<DiveEditPage> {
       newId: (_) => _uuid.v4(),
     );
 
+    // A repeat apply matches every role and so reports a non-zero kept while
+    // doing no work. Rebuilding then would mark the form dirty and raise an
+    // unsaved-changes prompt for a merge that altered nothing.
+    if (!result.changed) {
+      messenger.showSnackBar(
+        SnackBar(content: Text(l10n.cylinderConfigs_applyNothingToDo)),
+      );
+      return;
+    }
+
     setState(() {
       _markDirty();
       _tanksDirty = true;
@@ -2753,10 +2763,8 @@ class _DiveEditPageState extends ConsumerState<DiveEditPage> {
     messenger.showSnackBar(
       SnackBar(
         content: Text(
-          result.added == 0 && result.kept == 0
-              ? l10n.cylinderConfigs_applyNothingToDo
-              : '${l10n.cylinderConfigs_applyAdded(result.added)}, '
-                    '${l10n.cylinderConfigs_applyKept(result.kept)}',
+          '${l10n.cylinderConfigs_applyAdded(result.added)}, '
+          '${l10n.cylinderConfigs_applyKept(result.kept)}',
         ),
       ),
     );
diff --git a/test/features/cylinder_configs/domain/services/dive_tank_config_adapter_test.dart b/test/features/cylinder_configs/domain/services/dive_tank_config_adapter_test.dart
index a95422b576..59fdf4e503 100644
--- a/test/features/cylinder_configs/domain/services/dive_tank_config_adapter_test.dart
+++ b/test/features/cylinder_configs/domain/services/dive_tank_config_adapter_test.dart
@@ -117,13 +117,15 @@ void main() {
     expect(tank.startPressure, 200);
   });
 
-  test('applying twice is idempotent', () {
+  test('applying twice is idempotent and reports no change', () {
     final items = [
       cfg(id: 'a', role: TankRole.diluent, order: 0, o2: 18, he: 45),
       cfg(id: 'b', role: TankRole.bailout, order: 1),
     ];
 
     final first = adapter.apply(tanks: const [], items: items, newId: newId);
+    expect(first.changed, isTrue);
+
     final second = adapter.apply(
       tanks: first.tanks,
       items: items,
@@ -133,6 +135,21 @@ void main() {
     expect(second.added, 0);
     expect(second.kept, 2);
     expect(second.tanks, hasLength(2));
+    // kept is non-zero here, so counts alone cannot distinguish "matched
+    // everything, changed nothing" from real work.
+    expect(second.changed, isFalse);
+  });
+
+  test('a claim that fills a null field counts as a change', () {
+    final result = adapter.apply(
+      tanks: [const DiveTank(id: 't1', role: TankRole.diluent)],
+      items: [cfg(id: 'a', role: TankRole.diluent, pressure: 232)],
+      newId: newId,
+    );
+
+    expect(result.added, 0);
+    expect(result.kept, 1);
+    expect(result.changed, isTrue);
   });
 
   test('existing tanks the config does not mention are preserved', () {
diff --git a/test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart b/test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart
index d495b62d53..0d2dcc830e 100644
--- a/test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart
+++ b/test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart
@@ -156,10 +156,33 @@ void main() {
     await tester.tap(find.text('Save'));
     await tester.pumpAndSettle();
 
-    final saved = await repo.getAllConfigs(includeItems: true);
+    // Scoped to the active diver, not unfiltered: a config saved with a null
+    // diver_id persists but is invisible to every diver-scoped provider, so
+    // an unfiltered read would pass while the feature is broken.
+    final saved = await repo.getAllConfigs(diverId: 'd1', includeItems: true);
     expect(saved, hasLength(1));
     expect(saved.single.name, 'Bailout plan');
     expect(saved.single.equipmentId, 'rb-1');
+    expect(saved.single.diverId, 'd1');
     expect(saved.single.cylinderCount, 1);
   });
+
+  testWidgets('the first configuration a diver saves is diver-scoped', (
+    tester,
+  ) async {
+    // Regression: diverId used to be inferred from an existing config, so the
+    // very first one saved got a null diver_id and vanished from the list.
+    expect(await repo.getAllConfigs(diverId: 'd1'), isEmpty);
+
+    await tester.pumpWidget(host());
+    await tester.pumpAndSettle();
+
+    await tester.enterText(find.byType(TextFormField).first, 'First ever');
+    await tester.tap(find.text('Save'));
+    await tester.pumpAndSettle();
+
+    final saved = await repo.getAllConfigs(diverId: 'd1');
+    expect(saved, hasLength(1), reason: 'must be visible to its own diver');
+    expect(saved.single.diverId, 'd1');
+  });
 }

From 177b7c5983a95500762ada282d0d4043a8d91ae1 Mon Sep 17 00:00:00 2001
From: Eric Griffin <ericgriffin@gmail.com>
Date: Wed, 5 Aug 2026 22:57:29 -0400
Subject: [PATCH 20/20] Raise patch coverage on the cylinder configuration
 surfaces

Patch coverage was 72.85%, concentrated in presentation code that had no
widget test at all: the configuration list page sat at 1.56% and the dive
edit page's apply handler at 8.70%.

Adds 41 tests across 7 files (3 new, 4 extended). Test-only change; no
lib/ files are touched.

- List page: grouping by owning unit with gas plans last, the empty /
  loading / error arms, a config whose unit is gone, and both context.push
  routes driven through a real GoRouter.
- Item editor: gas parsing (including a lone "." that must not clobber a
  saved mix), label clearing, the preset picker, and the spec summary in
  both metric and imperial.
- Serializer: fetchRecord, the batch fetch/upsert paths, and an incremental
  changeset filtered by HLC watermark.
- Dive edit page: applying a configuration, and the repeat-apply no-op that
  must not mark the form dirty.
- Edit page: editing in place, demoting a config to a generic gas plan,
  removing a cylinder, and an edited gas mix reaching the database.
- Entity: config equality, so a field missing from props cannot silently
  stop rebuilding the list.

Measured with Codecov's own method (diff-added lines intersected with lcov
misses, honoring codecov.yml ignores): 74.35% -> 95.04% locally.

The lines left uncovered are Drift column getters in database.dart, which
only execute during query building, plus the router's route builders and
the reorder closure.
---
 .../sync/cylinder_config_sync_test.dart       | 154 ++++++++++
 .../domain/entities/cylinder_config_test.dart |  78 +++++
 .../cylinder_config_edit_page_test.dart       | 111 +++++++
 .../cylinder_config_item_editor_test.dart     | 284 ++++++++++++++++++
 .../cylinder_config_list_page_test.dart       | 247 +++++++++++++++
 .../unit_configurations_card_test.dart        | 132 ++++++++
 .../dive_edit_apply_cylinder_config_test.dart | 163 ++++++++++
 7 files changed, 1169 insertions(+)
 create mode 100644 test/features/cylinder_configs/presentation/cylinder_config_item_editor_test.dart
 create mode 100644 test/features/cylinder_configs/presentation/cylinder_config_list_page_test.dart
 create mode 100644 test/features/dive_log/presentation/pages/dive_edit_apply_cylinder_config_test.dart

diff --git a/test/core/services/sync/cylinder_config_sync_test.dart b/test/core/services/sync/cylinder_config_sync_test.dart
index f6ebf3ee07..45a4d7e68b 100644
--- a/test/core/services/sync/cylinder_config_sync_test.dart
+++ b/test/core/services/sync/cylinder_config_sync_test.dart
@@ -144,4 +144,158 @@ void main() {
     expect(payload.data.cylinderConfigs, isEmpty);
     expect(payload.data.cylinderConfigItems, isEmpty);
   });
+
+  test('a single config and item are fetchable by id', () async {
+    // The per-record fetch is what the conflict resolver reads to compare a
+    // local row against an incoming one, so a missing case here silently
+    // resolves every conflict in the remote's favour.
+    await seedUnit('rb-1');
+    await seedConfig('c1', equipmentId: 'rb-1');
+    await seedItem('i1', 'c1');
+
+    final config = await serializer.fetchRecord('cylinderConfigs', 'c1');
+    expect(config, isNotNull);
+    expect(config!['name'], 'JJ trimix');
+    expect(config['equipmentId'], 'rb-1');
+
+    final item = await serializer.fetchRecord('cylinderConfigItems', 'i1');
+    expect(item, isNotNull);
+    expect(item!['configId'], 'c1');
+    expect(item['tankRole'], 'diluent');
+
+    expect(await serializer.fetchRecord('cylinderConfigs', 'missing'), isNull);
+  });
+
+  test('configs and items round-trip through the batch paths', () async {
+    // The streaming/base sync paths use the batch variants (fetchRecords /
+    // upsertRecords), distinct from the single-record CRUD above.
+    await serializer.upsertRecords('cylinderConfigs', [
+      {
+        'id': 'c1',
+        'name': 'JJ trimix',
+        'description': '',
+        'sortOrder': 0,
+        'createdAt': 1000,
+        'updatedAt': 1000,
+      },
+      {
+        'id': 'c2',
+        'name': 'Doubles + 50',
+        'description': '',
+        'sortOrder': 1,
+        'createdAt': 1000,
+        'updatedAt': 1000,
+      },
+    ]);
+
+    await serializer.upsertRecords('cylinderConfigItems', [
+      {
+        'id': 'i1',
+        'configId': 'c1',
+        'sortOrder': 0,
+        'tankRole': 'diluent',
+        'o2Percent': 18.0,
+        'hePercent': 45.0,
+        'createdAt': 1000,
+        'updatedAt': 1000,
+      },
+      {
+        'id': 'i2',
+        'configId': 'c1',
+        'sortOrder': 1,
+        'tankRole': 'bailout',
+        'o2Percent': 21.0,
+        'hePercent': 0.0,
+        'createdAt': 1000,
+        'updatedAt': 1000,
+      },
+    ]);
+
+    final configs = await serializer.fetchRecords('cylinderConfigs', [
+      'c1',
+      'c2',
+    ]);
+    expect(configs.keys, containsAll(['c1', 'c2']));
+    expect(configs['c2']!['name'], 'Doubles + 50');
+
+    final items = await serializer.fetchRecords('cylinderConfigItems', [
+      'i1',
+      'i2',
+    ]);
+    expect(items.keys, containsAll(['i1', 'i2']));
+    expect(items['i2']!['tankRole'], 'bailout');
+  });
+
+  test(
+    'an incremental changeset carries only rows past the watermark',
+    () async {
+      // Rows arriving from a peer carry an hlc; the watermark filter is what
+      // keeps an incremental changeset from re-sending the whole table.
+      const oldHlc = '2026-07-01T00:00:00.000Z-0000-peer';
+      const newHlc = '2026-08-01T00:00:00.000Z-0000-peer';
+
+      await serializer.upsertRecord('cylinderConfigs', {
+        'id': 'old',
+        'name': 'Unchanged',
+        'description': '',
+        'sortOrder': 0,
+        'createdAt': 1000,
+        'updatedAt': 1000,
+        'hlc': oldHlc,
+      });
+      await serializer.upsertRecord('cylinderConfigs', {
+        'id': 'new',
+        'name': 'Edited',
+        'description': '',
+        'sortOrder': 0,
+        'createdAt': 1000,
+        'updatedAt': 2000,
+        'hlc': newHlc,
+      });
+      await serializer.upsertRecord('cylinderConfigItems', {
+        'id': 'i-old',
+        'configId': 'old',
+        'sortOrder': 0,
+        'tankRole': 'diluent',
+        'o2Percent': 18.0,
+        'hePercent': 45.0,
+        'createdAt': 1000,
+        'updatedAt': 1000,
+        'hlc': oldHlc,
+      });
+      await serializer.upsertRecord('cylinderConfigItems', {
+        'id': 'i-new',
+        'configId': 'new',
+        'sortOrder': 0,
+        'tankRole': 'bailout',
+        'o2Percent': 21.0,
+        'hePercent': 0.0,
+        'createdAt': 1000,
+        'updatedAt': 2000,
+        'hlc': newHlc,
+      });
+
+      final changeset = await serializer.exportChangeset(
+        deviceId: 'test-device',
+        hlcWatermark: oldHlc,
+        deletions: const [],
+      );
+
+      final configIds = changeset.data.cylinderConfigs
+          .map((c) => c['id'])
+          .toSet();
+      expect(configIds, contains('new'));
+      expect(
+        configIds,
+        isNot(contains('old')),
+        reason: 'a config at the watermark must not be re-sent',
+      );
+
+      final itemIds = changeset.data.cylinderConfigItems
+          .map((i) => i['id'])
+          .toSet();
+      expect(itemIds, contains('i-new'));
+      expect(itemIds, isNot(contains('i-old')));
+    },
+  );
 }
diff --git a/test/features/cylinder_configs/domain/entities/cylinder_config_test.dart b/test/features/cylinder_configs/domain/entities/cylinder_config_test.dart
index 968b340c06..69164057c3 100644
--- a/test/features/cylinder_configs/domain/entities/cylinder_config_test.dart
+++ b/test/features/cylinder_configs/domain/entities/cylinder_config_test.dart
@@ -34,6 +34,84 @@ void main() {
     expect(generic.name, 'JJ trimix');
   });
 
+  CylinderConfig config({
+    String id = 'c1',
+    String name = 'JJ trimix',
+    String? diverId = 'd1',
+    String? equipmentId = 'rb-1',
+    String description = '',
+    int sortOrder = 0,
+    List<CylinderConfigItem> items = const [],
+  }) => CylinderConfig(
+    id: id,
+    diverId: diverId,
+    equipmentId: equipmentId,
+    name: name,
+    description: description,
+    sortOrder: sortOrder,
+    items: items,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  test('config equality is by value, so provider rebuilds are stable', () {
+    expect(config(), equals(config()));
+    expect(config().hashCode, equals(config().hashCode));
+  });
+
+  test('every meaningful field participates in config equality', () {
+    // A field missing from props means an edit to it does not rebuild the
+    // list, the owning unit's card, or an open detail pane.
+    expect(config(id: 'c2'), isNot(equals(config())));
+    expect(config(name: 'Other'), isNot(equals(config())));
+    expect(config(diverId: 'd2'), isNot(equals(config())));
+    expect(config(equipmentId: 'rb-2'), isNot(equals(config())));
+    expect(config(description: 'Deep'), isNot(equals(config())));
+    expect(config(sortOrder: 3), isNot(equals(config())));
+    expect(config(items: [item()]), isNot(equals(config())));
+  });
+
+  test('config timestamps are excluded from equality', () {
+    final a = config();
+    expect(a, equals(a.copyWith(updatedAt: now.add(const Duration(days: 1)))));
+  });
+
+  test('cylinderCount reflects the item list', () {
+    expect(config().cylinderCount, 0);
+    expect(
+      config(
+        items: [
+          item(id: 'a'),
+          item(id: 'b'),
+        ],
+      ).cylinderCount,
+      2,
+    );
+  });
+
+  test('clearing the diver detaches a config without touching its unit', () {
+    final orphaned = config().copyWith(clearDiverId: true);
+    expect(orphaned.diverId, isNull);
+    expect(orphaned.equipmentId, 'rb-1');
+  });
+
+  test('copyWith replaces every scalar field', () {
+    final updated = config().copyWith(
+      id: 'c9',
+      diverId: 'd9',
+      equipmentId: 'rb-9',
+      name: 'Renamed',
+      description: 'Trimix bailout',
+      sortOrder: 7,
+    );
+    expect(updated.id, 'c9');
+    expect(updated.diverId, 'd9');
+    expect(updated.equipmentId, 'rb-9');
+    expect(updated.name, 'Renamed');
+    expect(updated.description, 'Trimix bailout');
+    expect(updated.sortOrder, 7);
+  });
+
   test('items default to air and back gas is not assumed', () {
     final i = item();
     expect(i.o2Percent, 21);
diff --git a/test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart b/test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart
index 0d2dcc830e..81e1ae27b7 100644
--- a/test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart
+++ b/test/features/cylinder_configs/presentation/cylinder_config_edit_page_test.dart
@@ -167,6 +167,117 @@ void main() {
     expect(saved.single.cylinderCount, 1);
   });
 
+  testWidgets('editing an existing configuration updates it in place', (
+    tester,
+  ) async {
+    final id = await repo.createConfig(
+      diverId: 'd1',
+      equipmentId: 'rb-1',
+      name: 'JJ trimix',
+    );
+
+    await tester.pumpWidget(host(configId: id));
+    await tester.pumpAndSettle();
+
+    await tester.enterText(find.byType(TextFormField).first, 'JJ air dil');
+    await tester.tap(find.text('Save'));
+    await tester.pumpAndSettle();
+
+    final saved = await repo.getAllConfigs(diverId: 'd1');
+    expect(saved, hasLength(1), reason: 'must not fork into a second config');
+    expect(saved.single.id, id);
+    expect(saved.single.name, 'JJ air dil');
+    expect(saved.single.equipmentId, 'rb-1');
+  });
+
+  testWidgets('clearing the owning unit demotes a config to a gas plan', (
+    tester,
+  ) async {
+    // The generic option is a real value, not "leave unchanged": picking it
+    // must null equipment_id rather than silently keep the old unit.
+    final id = await repo.createConfig(
+      diverId: 'd1',
+      equipmentId: 'rb-1',
+      name: 'JJ trimix',
+    );
+
+    await tester.pumpWidget(host(configId: id));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('JJ-CCR'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('Generic gas plan').last);
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Save'));
+    await tester.pumpAndSettle();
+
+    final saved = await repo.getConfigById(id);
+    expect(saved!.equipmentId, isNull);
+    expect(saved.isOwnedByUnit, isFalse);
+  });
+
+  testWidgets('removing a cylinder drops it from the saved set', (
+    tester,
+  ) async {
+    final id = await repo.createConfig(diverId: 'd1', name: 'JJ trimix');
+    await repo.saveItems(id, [
+      CylinderConfigItem(
+        id: 'i1',
+        configId: id,
+        tankRole: TankRole.diluent,
+        createdAt: now,
+        updatedAt: now,
+      ),
+      CylinderConfigItem(
+        id: 'i2',
+        configId: id,
+        tankRole: TankRole.bailout,
+        createdAt: now,
+        updatedAt: now,
+      ),
+    ]);
+
+    await tester.pumpWidget(host(configId: id));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.byIcon(Icons.delete_outline).first);
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('Save'));
+    await tester.pumpAndSettle();
+
+    final saved = await repo.getConfigById(id);
+    expect(saved!.cylinderCount, 1);
+    expect(saved.items.single.tankRole, TankRole.bailout);
+  });
+
+  testWidgets('an edited gas mix reaches the database on save', (tester) async {
+    final id = await repo.createConfig(diverId: 'd1', name: 'JJ trimix');
+    await repo.saveItems(id, [
+      CylinderConfigItem(
+        id: 'i1',
+        configId: id,
+        tankRole: TankRole.diluent,
+        o2Percent: 21,
+        createdAt: now,
+        updatedAt: now,
+      ),
+    ]);
+
+    await tester.pumpWidget(host(configId: id));
+    await tester.pumpAndSettle();
+
+    await tester.enterText(find.widgetWithText(TextField, 'O2 %'), '18');
+    await tester.enterText(find.widgetWithText(TextField, 'He %'), '45');
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('Save'));
+    await tester.pumpAndSettle();
+
+    final saved = await repo.getConfigById(id);
+    expect(saved!.items.single.o2Percent, 18);
+    expect(saved.items.single.hePercent, 45);
+  });
+
   testWidgets('the first configuration a diver saves is diver-scoped', (
     tester,
   ) async {
diff --git a/test/features/cylinder_configs/presentation/cylinder_config_item_editor_test.dart b/test/features/cylinder_configs/presentation/cylinder_config_item_editor_test.dart
new file mode 100644
index 0000000000..00aa69d767
--- /dev/null
+++ b/test/features/cylinder_configs/presentation/cylinder_config_item_editor_test.dart
@@ -0,0 +1,284 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/core/constants/units.dart';
+import 'package:submersion/core/utils/unit_formatter.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+import 'package:submersion/features/cylinder_configs/presentation/widgets/cylinder_config_item_editor.dart';
+import 'package:submersion/features/settings/presentation/providers/settings_providers.dart';
+import 'package:submersion/features/tank_presets/domain/entities/tank_preset_entity.dart';
+import 'package:submersion/features/tank_presets/presentation/providers/tank_preset_providers.dart';
+
+import '../../../helpers/test_app.dart';
+
+/// Drives [CylinderConfigItemEditor] through a host that owns the item and
+/// rebuilds on every `onChanged`, which is how the edit page uses it: the
+/// widget is controlled, not self-storing.
+void main() {
+  final now = DateTime.utc(2026, 8, 5);
+
+  const metric = UnitFormatter(
+    AppSettings(volumeUnit: VolumeUnit.liters, pressureUnit: PressureUnit.bar),
+  );
+  const imperial = UnitFormatter(
+    AppSettings(
+      volumeUnit: VolumeUnit.cubicFeet,
+      pressureUnit: PressureUnit.psi,
+    ),
+  );
+
+  CylinderConfigItem seed({
+    TankRole role = TankRole.diluent,
+    double o2 = 21,
+    double he = 0,
+    String? label,
+    double? volumeL,
+    double? workingPressureBar,
+  }) => CylinderConfigItem(
+    id: 'i1',
+    configId: 'c1',
+    tankRole: role,
+    o2Percent: o2,
+    hePercent: he,
+    label: label,
+    volumeL: volumeL,
+    workingPressureBar: workingPressureBar,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  TankPresetEntity preset({
+    String id = 'al80',
+    String displayName = 'AL80',
+    double volumeLiters = 11.1,
+    double workingPressureBar = 207,
+    TankMaterial material = TankMaterial.aluminum,
+  }) => TankPresetEntity(
+    id: id,
+    name: id,
+    displayName: displayName,
+    volumeLiters: volumeLiters,
+    workingPressureBar: workingPressureBar,
+    material: material,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  /// Latest item the editor reported, and whether it asked to be removed.
+  late CylinderConfigItem current;
+  late bool removed;
+
+  Widget host({
+    required CylinderConfigItem item,
+    UnitFormatter units = metric,
+    List<TankPresetEntity> presets = const [],
+  }) {
+    current = item;
+    removed = false;
+    return testApp(
+      // Pinned: an unpinned locale makes text finders machine-dependent.
+      locale: const Locale('en'),
+      overrides: [tankPresetsProvider.overrideWith((ref) async => presets)],
+      child: StatefulBuilder(
+        builder: (context, setState) => CylinderConfigItemEditor(
+          item: current,
+          units: units,
+          onChanged: (updated) => setState(() => current = updated),
+          onRemove: () => setState(() => removed = true),
+        ),
+      ),
+    );
+  }
+
+  testWidgets('whole-number gas fractions render without a decimal point', (
+    tester,
+  ) async {
+    await tester.pumpWidget(host(item: seed(o2: 18, he: 45)));
+    await tester.pumpAndSettle();
+
+    expect(find.text('18'), findsOneWidget);
+    expect(find.text('45'), findsOneWidget);
+    expect(find.text('18.0'), findsNothing);
+  });
+
+  testWidgets('a fractional gas fraction keeps its decimals', (tester) async {
+    await tester.pumpWidget(host(item: seed(o2: 32.5)));
+    await tester.pumpAndSettle();
+
+    expect(find.text('32.5'), findsOneWidget);
+  });
+
+  testWidgets('choosing a different role reports it upward', (tester) async {
+    await tester.pumpWidget(host(item: seed(role: TankRole.diluent)));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('Diluent'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('Bailout').last);
+    await tester.pumpAndSettle();
+
+    expect(current.tankRole, TankRole.bailout);
+  });
+
+  testWidgets('editing O2 and He reports the parsed fractions', (tester) async {
+    await tester.pumpWidget(host(item: seed()));
+    await tester.pumpAndSettle();
+
+    await tester.enterText(find.widgetWithText(TextField, 'O2 %'), '18');
+    await tester.enterText(find.widgetWithText(TextField, 'He %'), '45');
+    await tester.pumpAndSettle();
+
+    expect(current.o2Percent, 18);
+    expect(current.hePercent, 45);
+  });
+
+  testWidgets('a half-typed number does not clobber the stored mix', (
+    tester,
+  ) async {
+    // "." is a transient state on the way to "32.5". Writing null (or 0) into
+    // the model here would silently rewrite the gas on a saved configuration.
+    await tester.pumpWidget(host(item: seed(o2: 32)));
+    await tester.pumpAndSettle();
+
+    await tester.enterText(find.widgetWithText(TextField, 'O2 %'), '.');
+    await tester.pumpAndSettle();
+
+    expect(current.o2Percent, 32);
+  });
+
+  testWidgets('the label round-trips and an empty label clears it', (
+    tester,
+  ) async {
+    await tester.pumpWidget(host(item: seed(label: 'Bailout 1')));
+    await tester.pumpAndSettle();
+
+    expect(find.widgetWithText(TextField, 'Bailout 1'), findsOneWidget);
+
+    // Found by its decoration rather than its value: the value changes as the
+    // test types, and a finder keyed on it goes stale after the first entry.
+    final label = find.widgetWithText(TextField, 'Label');
+    await tester.enterText(label, 'Deco 50');
+    await tester.pumpAndSettle();
+    expect(current.label, 'Deco 50');
+
+    // Whitespace-only reads as "no label", not as a label of spaces.
+    await tester.enterText(label, '   ');
+    await tester.pumpAndSettle();
+    expect(current.label, isNull);
+  });
+
+  testWidgets('the delete affordance asks the parent to remove the row', (
+    tester,
+  ) async {
+    await tester.pumpWidget(host(item: seed()));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.byIcon(Icons.delete_outline));
+    await tester.pumpAndSettle();
+
+    expect(removed, isTrue);
+  });
+
+  testWidgets('the spec summary respects the diver metric units', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      host(item: seed(volumeL: 11.1, workingPressureBar: 207)),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.text('11 L - 207 bar'), findsOneWidget);
+  });
+
+  testWidgets('the spec summary respects the diver imperial units', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      host(item: seed(volumeL: 11.1, workingPressureBar: 207), units: imperial),
+    );
+    await tester.pumpAndSettle();
+
+    // 11.1 L -> 0.39 cuft (0 decimals), 207 bar -> 3002 psi.
+    expect(find.text('0 cuft - 3002 psi'), findsOneWidget);
+  });
+
+  testWidgets('a cylinder with only a volume shows just that', (tester) async {
+    await tester.pumpWidget(host(item: seed(volumeL: 12)));
+    await tester.pumpAndSettle();
+
+    expect(find.text('12 L'), findsOneWidget);
+  });
+
+  testWidgets('an unspecified cylinder shows no spec summary', (tester) async {
+    await tester.pumpWidget(host(item: seed()));
+    await tester.pumpAndSettle();
+
+    expect(find.textContaining(' L'), findsNothing);
+    expect(find.textContaining(' bar'), findsNothing);
+  });
+
+  testWidgets('the preset button does nothing when there are no presets', (
+    tester,
+  ) async {
+    await tester.pumpWidget(host(item: seed(), presets: const []));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('From preset'));
+    await tester.pumpAndSettle();
+
+    // No sheet, and nothing written to the model.
+    expect(find.byType(ListTile), findsNothing);
+    expect(current.volumeL, isNull);
+  });
+
+  testWidgets('picking a preset seeds the spec and the empty label', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      host(
+        item: seed(),
+        presets: [
+          preset(),
+          preset(id: 'lp85'),
+        ],
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('From preset'));
+    await tester.pumpAndSettle();
+
+    // The sheet describes each preset in the diver's units.
+    expect(find.text('11 L - 207 bar'), findsWidgets);
+
+    await tester.tap(find.text('AL80').first);
+    await tester.pumpAndSettle();
+
+    expect(current.volumeL, 11.1);
+    expect(current.workingPressureBar, 207);
+    expect(current.tankMaterial, TankMaterial.aluminum);
+    expect(current.label, 'AL80');
+    // The controller is seeded too, so the field is not left stale.
+    expect(find.widgetWithText(TextField, 'AL80'), findsOneWidget);
+  });
+
+  testWidgets('picking a preset never overwrites a label the diver typed', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      host(
+        item: seed(label: 'Bailout 1'),
+        presets: [preset()],
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('From preset'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('AL80').first);
+    await tester.pumpAndSettle();
+
+    expect(current.label, 'Bailout 1');
+    expect(current.volumeL, 11.1);
+  });
+}
diff --git a/test/features/cylinder_configs/presentation/cylinder_config_list_page_test.dart b/test/features/cylinder_configs/presentation/cylinder_config_list_page_test.dart
new file mode 100644
index 0000000000..25cf01deef
--- /dev/null
+++ b/test/features/cylinder_configs/presentation/cylinder_config_list_page_test.dart
@@ -0,0 +1,247 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:go_router/go_router.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+import 'package:submersion/features/cylinder_configs/presentation/pages/cylinder_config_list_page.dart';
+import 'package:submersion/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart';
+import 'package:submersion/features/equipment/domain/entities/equipment_item.dart';
+import 'package:submersion/features/equipment/presentation/providers/equipment_providers.dart';
+
+import '../../../helpers/test_app.dart';
+
+/// Renders [CylinderConfigListPage] behind a real [GoRouter] so the FAB and
+/// the per-tile tap (both `context.push`) actually navigate. The child routes
+/// are placeholders rather than the real edit page: this test is about the
+/// list's own grouping and routing, and the edit page has its own suite that
+/// stands up a database for it.
+void main() {
+  final now = DateTime.utc(2026, 8, 5);
+
+  CylinderConfigItem item(String id, TankRole role) => CylinderConfigItem(
+    id: id,
+    configId: 'c1',
+    tankRole: role,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  CylinderConfig config({
+    required String id,
+    required String name,
+    String? equipmentId,
+    List<CylinderConfigItem> items = const [],
+  }) => CylinderConfig(
+    id: id,
+    name: name,
+    equipmentId: equipmentId,
+    items: items,
+    createdAt: now,
+    updatedAt: now,
+  );
+
+  EquipmentItem unit(String id, String name) =>
+      EquipmentItem(id: id, name: name, type: EquipmentType.rebreather);
+
+  /// The location the router last landed on, so a tap can be asserted on the
+  /// route it pushed rather than on whatever the placeholder happens to show.
+  late String location;
+
+  Widget host({
+    required List<CylinderConfig> configs,
+    List<EquipmentItem> equipment = const [],
+    // A builder, not a Future: an eagerly constructed Future.error has no
+    // listener at construction time and the test framework claims it before
+    // Riverpod can route it to the widget's error arm.
+    Future<List<CylinderConfig>> Function()? configsFuture,
+  }) {
+    Widget probe(String label) => Builder(
+      builder: (context) {
+        location = GoRouterState.of(context).uri.toString();
+        return Scaffold(body: Text(label));
+      },
+    );
+
+    final router = GoRouter(
+      initialLocation: '/equipment/cylinder-configs',
+      routes: [
+        GoRoute(
+          path: '/equipment/cylinder-configs',
+          builder: (context, state) => const CylinderConfigListPage(),
+          routes: [
+            GoRoute(path: 'new', builder: (context, state) => probe('new')),
+            GoRoute(
+              path: ':configId',
+              builder: (context, state) => probe('detail'),
+            ),
+          ],
+        ),
+      ],
+    );
+
+    return testAppRouter(
+      // Pinned: an unpinned locale makes text finders machine-dependent.
+      locale: const Locale('en'),
+      router: router,
+      overrides: [
+        cylinderConfigsProvider.overrideWith(
+          (ref) => configsFuture?.call() ?? Future.value(configs),
+        ),
+        allEquipmentProvider.overrideWith((ref) async => equipment),
+      ],
+    );
+  }
+
+  testWidgets('an empty list explains what a configuration is for', (
+    tester,
+  ) async {
+    await tester.pumpWidget(host(configs: const []));
+    await tester.pumpAndSettle();
+
+    expect(find.text('No configurations yet'), findsOneWidget);
+    expect(
+      find.text(
+        'Save a diluent and bailout setup once, then apply it to any dive.',
+      ),
+      findsOneWidget,
+    );
+    expect(find.byType(ListTile), findsNothing);
+  });
+
+  testWidgets('a pending load shows a spinner rather than the empty state', (
+    tester,
+  ) async {
+    // A never-completing future: the empty state and "still loading" are
+    // different answers, and showing "No configurations yet" while the read
+    // is in flight would read as data loss.
+    await tester.pumpWidget(
+      host(
+        configs: const [],
+        configsFuture: () => Completer<List<CylinderConfig>>().future,
+      ),
+    );
+    await tester.pump();
+
+    expect(find.byType(CircularProgressIndicator), findsOneWidget);
+    expect(find.text('No configurations yet'), findsNothing);
+  });
+
+  testWidgets('a failed read surfaces the error instead of an empty list', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      host(
+        configs: const [],
+        configsFuture: () async => throw Exception('no database'),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.textContaining('no database'), findsOneWidget);
+  });
+
+  testWidgets('configurations group under their owning unit, gas plans last', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      host(
+        equipment: [unit('rb-1', 'JJ-CCR')],
+        configs: [
+          config(
+            id: 'c1',
+            name: 'JJ trimix',
+            equipmentId: 'rb-1',
+            items: [item('i1', TankRole.diluent), item('i2', TankRole.bailout)],
+          ),
+          config(id: 'c2', name: 'JJ air dil', equipmentId: 'rb-1'),
+          config(
+            id: 'c3',
+            name: 'Doubles + 50',
+            items: [item('i3', TankRole.backGas)],
+          ),
+        ],
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    // The owning unit's name heads its group; generic plans get their own.
+    expect(find.text('JJ-CCR'), findsOneWidget);
+    expect(find.text('Gas plans'), findsOneWidget);
+
+    expect(find.text('JJ trimix'), findsOneWidget);
+    expect(find.text('JJ air dil'), findsOneWidget);
+    expect(find.text('Doubles + 50'), findsOneWidget);
+
+    // Roles are the subtitle, cylinder count the trailing value.
+    expect(find.text('Diluent, Bailout'), findsOneWidget);
+    expect(find.text('2'), findsOneWidget);
+
+    // Generic plans sort after every owned group.
+    final gasPlansY = tester.getTopLeft(find.text('Gas plans')).dy;
+    expect(tester.getTopLeft(find.text('JJ-CCR')).dy, lessThan(gasPlansY));
+    expect(
+      tester.getTopLeft(find.text('Doubles + 50')).dy,
+      greaterThan(gasPlansY),
+    );
+  });
+
+  testWidgets('a config whose unit is gone still gets a header', (
+    tester,
+  ) async {
+    // equipment_id is ON DELETE SET NULL, but a config can also be read
+    // before allEquipmentProvider resolves, or reference a unit belonging to
+    // another diver. Neither may drop the row off the page.
+    await tester.pumpWidget(
+      host(
+        equipment: const [],
+        configs: [config(id: 'c1', name: 'Orphaned', equipmentId: 'rb-gone')],
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.text('For unit'), findsOneWidget);
+    expect(find.text('Orphaned'), findsOneWidget);
+  });
+
+  testWidgets('a configuration with no cylinders has no role subtitle', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      host(
+        configs: [config(id: 'c1', name: 'Empty plan')],
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    final tile = tester.widget<ListTile>(find.byType(ListTile));
+    expect(tile.subtitle, isNull);
+    expect(find.text('0'), findsOneWidget);
+  });
+
+  testWidgets('tapping a configuration opens it by id', (tester) async {
+    await tester.pumpWidget(
+      host(
+        configs: [config(id: 'c1', name: 'JJ trimix')],
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('JJ trimix'));
+    await tester.pumpAndSettle();
+
+    expect(location, '/equipment/cylinder-configs/c1');
+  });
+
+  testWidgets('the FAB opens a blank configuration', (tester) async {
+    await tester.pumpWidget(host(configs: const []));
+    await tester.pumpAndSettle();
+
+    await tester.tap(find.text('New configuration'));
+    await tester.pumpAndSettle();
+
+    expect(location, '/equipment/cylinder-configs/new');
+  });
+}
diff --git a/test/features/cylinder_configs/presentation/unit_configurations_card_test.dart b/test/features/cylinder_configs/presentation/unit_configurations_card_test.dart
index aadf438bd4..fbc5425c73 100644
--- a/test/features/cylinder_configs/presentation/unit_configurations_card_test.dart
+++ b/test/features/cylinder_configs/presentation/unit_configurations_card_test.dart
@@ -1,5 +1,8 @@
+import 'dart:async';
+
 import 'package:flutter/material.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:go_router/go_router.dart';
 import 'package:submersion/core/constants/enums.dart';
 import 'package:submersion/core/providers/provider.dart';
 import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config.dart';
@@ -8,6 +11,8 @@ import 'package:submersion/features/cylinder_configs/presentation/providers/cyli
 import 'package:submersion/features/cylinder_configs/presentation/widgets/unit_configurations_card.dart';
 import 'package:submersion/l10n/arb/app_localizations.dart';
 
+import '../../../helpers/test_app.dart';
+
 void main() {
   final now = DateTime.utc(2026, 8, 5);
 
@@ -70,4 +75,131 @@ void main() {
       findsOneWidget,
     );
   });
+
+  testWidgets('a pending read shows a spinner, not the empty state', (
+    tester,
+  ) async {
+    // "None yet" and "still loading" are different answers; showing the empty
+    // copy mid-read reads as though the unit's configurations were lost.
+    await tester.pumpWidget(
+      ProviderScope(
+        overrides: [
+          cylinderConfigsForEquipmentProvider(
+            'rb-1',
+          ).overrideWith((ref) => Completer<List<CylinderConfig>>().future),
+        ],
+        child: const MaterialApp(
+          locale: Locale('en'),
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: Scaffold(body: UnitConfigurationsCard(equipmentId: 'rb-1')),
+        ),
+      ),
+    );
+    await tester.pump();
+
+    expect(find.byType(CircularProgressIndicator), findsOneWidget);
+    expect(
+      find.textContaining('Save a diluent and bailout setup once'),
+      findsNothing,
+    );
+  });
+
+  testWidgets('a failed read surfaces the error', (tester) async {
+    await tester.pumpWidget(
+      ProviderScope(
+        overrides: [
+          // A thrown error, not an eagerly built Future.error: the latter has
+          // no listener at construction time and the test framework claims it
+          // before Riverpod can route it to the widget's error arm.
+          cylinderConfigsForEquipmentProvider(
+            'rb-1',
+          ).overrideWith((ref) async => throw Exception('no database')),
+        ],
+        child: const MaterialApp(
+          locale: Locale('en'),
+          localizationsDelegates: AppLocalizations.localizationsDelegates,
+          supportedLocales: AppLocalizations.supportedLocales,
+          home: Scaffold(body: UnitConfigurationsCard(equipmentId: 'rb-1')),
+        ),
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    expect(find.textContaining('no database'), findsOneWidget);
+  });
+
+  group('navigation', () {
+    late String location;
+
+    Widget routedHost(List<CylinderConfig> configs) {
+      Widget probe() => Builder(
+        builder: (context) {
+          location = GoRouterState.of(context).uri.toString();
+          return const Scaffold(body: Text('elsewhere'));
+        },
+      );
+
+      return testAppRouter(
+        locale: const Locale('en'),
+        overrides: [
+          cylinderConfigsForEquipmentProvider(
+            'rb-1',
+          ).overrideWith((ref) async => configs),
+        ],
+        router: GoRouter(
+          initialLocation: '/equipment/rb-1',
+          routes: [
+            GoRoute(
+              path: '/equipment/rb-1',
+              builder: (context, state) => const Scaffold(
+                body: UnitConfigurationsCard(equipmentId: 'rb-1'),
+              ),
+            ),
+            GoRoute(
+              path: '/equipment/cylinder-configs/new',
+              builder: (context, state) => probe(),
+            ),
+            GoRoute(
+              path: '/equipment/cylinder-configs/:configId',
+              builder: (context, state) => probe(),
+            ),
+          ],
+        ),
+      );
+    }
+
+    testWidgets('the add action pre-selects the owning unit', (tester) async {
+      await tester.pumpWidget(routedHost(const []));
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.text('New configuration'));
+      await tester.pumpAndSettle();
+
+      // The query parameter is what makes the new config belong to this unit
+      // instead of landing as a generic gas plan.
+      expect(location, '/equipment/cylinder-configs/new?equipmentId=rb-1');
+    });
+
+    testWidgets('tapping a configuration opens it by id', (tester) async {
+      await tester.pumpWidget(
+        routedHost([
+          CylinderConfig(
+            id: 'c1',
+            name: 'JJ trimix',
+            equipmentId: 'rb-1',
+            items: [item(TankRole.diluent)],
+            createdAt: now,
+            updatedAt: now,
+          ),
+        ]),
+      );
+      await tester.pumpAndSettle();
+
+      await tester.tap(find.text('JJ trimix'));
+      await tester.pumpAndSettle();
+
+      expect(location, '/equipment/cylinder-configs/c1');
+    });
+  });
 }
diff --git a/test/features/dive_log/presentation/pages/dive_edit_apply_cylinder_config_test.dart b/test/features/dive_log/presentation/pages/dive_edit_apply_cylinder_config_test.dart
new file mode 100644
index 0000000000..f1fb1c83e9
--- /dev/null
+++ b/test/features/dive_log/presentation/pages/dive_edit_apply_cylinder_config_test.dart
@@ -0,0 +1,163 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:submersion/core/constants/enums.dart';
+import 'package:submersion/core/providers/provider.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config.dart';
+import 'package:submersion/features/cylinder_configs/domain/entities/cylinder_config_item.dart';
+import 'package:submersion/features/cylinder_configs/presentation/providers/cylinder_config_providers.dart';
+import 'package:submersion/features/cylinder_configs/presentation/widgets/apply_configuration_menu.dart';
+import 'package:submersion/features/dive_log/data/repositories/dive_repository_impl.dart';
+import 'package:submersion/features/dive_log/domain/entities/dive.dart';
+import 'package:submersion/features/dive_log/presentation/pages/dive_edit_page.dart';
+import 'package:submersion/features/dive_log/presentation/providers/dive_providers.dart';
+import 'package:submersion/features/equipment/presentation/providers/equipment_providers.dart';
+import 'package:submersion/features/tank_presets/presentation/providers/tank_preset_providers.dart';
+import 'package:submersion/l10n/arb/app_localizations.dart';
+
+import '../../../../helpers/mock_providers.dart';
+import '../../../../helpers/test_database.dart';
+
+/// Applying a saved configuration is the payoff of the whole feature: it is
+/// what spares a CCR diver from re-entering diluent and bailout every dive.
+///
+/// The merge deliberately targets the page's in-memory cylinder list, not
+/// dive_tanks -- those cylinders are unsaved form state until Save, so writing
+/// through would bypass dirty tracking and persist even a cancelled edit.
+void main() {
+  final now = DateTime.utc(2026, 8, 5);
+  late DiveRepository repository;
+
+  setUp(() async {
+    await setUpTestDatabase();
+    repository = DiveRepository();
+  });
+  tearDown(tearDownTestDatabase);
+
+  CylinderConfigItem item(String id, TankRole role, {double o2 = 21}) =>
+      CylinderConfigItem(
+        id: id,
+        configId: 'c1',
+        tankRole: role,
+        o2Percent: o2,
+        createdAt: now,
+        updatedAt: now,
+      );
+
+  Future<Widget> host({required List<CylinderConfigItem> items}) async {
+    final dive = Dive(
+      id: 'dive-1',
+      diveNumber: 1,
+      dateTime: DateTime(2026, 3, 28, 10, 0),
+      bottomTime: const Duration(minutes: 40),
+      maxDepth: 30,
+      tanks: const [],
+      profile: const [],
+      equipment: const [],
+      notes: '',
+      photoIds: const [],
+      sightings: const [],
+      weights: const [],
+    );
+    await repository.createDive(dive);
+
+    final base = await getBaseOverrides();
+    return ProviderScope(
+      overrides: [
+        ...base,
+        diveRepositoryProvider.overrideWithValue(repository),
+        diveListNotifierProvider.overrideWith(
+          (ref) => DiveListNotifier(repository, ref),
+        ),
+        customTankPresetsProvider.overrideWith((ref) async => []),
+        allEquipmentProvider.overrideWith((ref) async => []),
+        cylinderConfigsProvider.overrideWith(
+          (ref) async => [
+            CylinderConfig(
+              id: 'c1',
+              name: 'JJ trimix',
+              items: items,
+              createdAt: now,
+              updatedAt: now,
+            ),
+          ],
+        ),
+      ].cast(),
+      child: const MaterialApp(
+        // Pinned: an unpinned locale makes text finders machine-dependent.
+        locale: Locale('en'),
+        localizationsDelegates: AppLocalizations.localizationsDelegates,
+        supportedLocales: AppLocalizations.supportedLocales,
+        home: Scaffold(body: DiveEditPage(diveId: 'dive-1', embedded: true)),
+      ),
+    );
+  }
+
+  /// Gas & Gear collapses by default when editing an existing dive, and the
+  /// menu lives inside it.
+  Future<void> openGasGear(WidgetTester tester) async {
+    await tester.ensureVisible(find.text('Gas & Gear'));
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('Gas & Gear'));
+    await tester.pumpAndSettle();
+  }
+
+  Future<void> applyConfig(WidgetTester tester) async {
+    // ensureVisible beats scrollUntilVisible here: the page has several
+    // Scrollables and the default scrollable finder is ambiguous.
+    final menu = find.byType(ApplyConfigurationMenu);
+    expect(menu, findsOneWidget);
+    await tester.ensureVisible(menu);
+    await tester.pumpAndSettle();
+    await tester.tap(menu);
+    await tester.pumpAndSettle();
+    await tester.tap(find.text('JJ trimix').last);
+    await tester.pumpAndSettle();
+  }
+
+  testWidgets('applying a configuration adds its cylinders to the dive', (
+    tester,
+  ) async {
+    await tester.pumpWidget(
+      await host(
+        items: [
+          item('i1', TankRole.diluent),
+          item('i2', TankRole.bailout, o2: 50),
+        ],
+      ),
+    );
+    await tester.pumpAndSettle();
+
+    await openGasGear(tester);
+    await applyConfig(tester);
+
+    expect(find.textContaining('Added 2 cylinders'), findsOneWidget);
+    expect(find.textContaining('kept 0'), findsOneWidget);
+  });
+
+  testWidgets('applying the same configuration twice reports nothing to do', (
+    tester,
+  ) async {
+    // The second apply matches every role and so reports a non-zero kept while
+    // doing no work. Rebuilding then would mark the form dirty and raise an
+    // unsaved-changes prompt for a merge that altered nothing.
+    await tester.pumpWidget(await host(items: [item('i1', TankRole.diluent)]));
+    await tester.pumpAndSettle();
+
+    await openGasGear(tester);
+    await applyConfig(tester);
+    expect(find.textContaining('Added 1 cylinder'), findsOneWidget);
+
+    // Let the first snackbar retire: ScaffoldMessenger queues, so a second
+    // one raised while the first is still up would not be on screen to find.
+    await tester.pump(const Duration(seconds: 6));
+    await tester.pumpAndSettle();
+
+    await applyConfig(tester);
+    await tester.pumpAndSettle();
+
+    expect(
+      find.text('This dive already matches the configuration'),
+      findsOneWidget,
+    );
+  });
+}