Skip to content

PostgreSQL backup tool with Point-In-Time-Recovery and restore verification

REFACTOR (docs): Record which server versions we accept and which clients ship

Rostislav Duginf284540b4076
diff --git a/openspec/changes/support-mysql-26-and-mariadb-13/.openspec.yaml b/openspec/changes/support-mysql-26-and-mariadb-13/.openspec.yaml
new file mode 100644
index 00000000..cbd245e4
--- /dev/null
+++ b/openspec/changes/support-mysql-26-and-mariadb-13/.openspec.yaml
@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-09-20
diff --git a/openspec/changes/support-mysql-26-and-mariadb-13/assets-tools-agents-draft.md b/openspec/changes/support-mysql-26-and-mariadb-13/assets-tools-agents-draft.md
new file mode 100644
index 00000000..c7105476
--- /dev/null
+++ b/openspec/changes/support-mysql-26-and-mariadb-13/assets-tools-agents-draft.md
@@ -0,0 +1,139 @@
+# Draft content for `assets/tools/AGENTS.md`
+
+This file is planning content, not the shipped document. Task 6.2 places it at
+`assets/tools/AGENTS.md`; review and edit it here first.
+
+---
+
+# Client binaries — rules for changing this tree
+
+Every file under `assets/tools/` is a vendored third-party binary that runs in
+production. ADR-0005 explains why they are committed instead of installed at
+image build time. Two rules follow from that and apply to every change here:
+the bytes in the repository are the bytes that ship, so a binary must be
+verified in the runtime environment rather than on a developer machine, and a
+directory name is a label chosen by us, which the startup check holds you to
+but which nothing enforces while you are assembling the bundle.
+
+The backend resolves a binary as
+`assets/tools/<arch>/<engine>/<engine>-<bundle>/bin/<command>`, where `<arch>`
+is `x64` for `linux/amd64` and `arm` for `linux/arm64`. The mapping lives in
+`backend/internal/util/tools/paths.go`.
+
+## Before adding a version
+
+Adding an engine version is mostly about the binary, not about the code that
+reads the version. Work through this list before committing anything; the
+first two items often end the job early.
+
+- [ ] **A new upstream release line needs a client here before it is
+ supported.** Until the bundle lands, a server on that line is refused at
+ the connection test, by design: we never dump a server with a client from
+ an older line. Both engines open a line roughly once a quarter, so this
+ is the recurring task that keeps that promise.
+- [ ] **Is this a new line, or a new release inside a line we already serve?**
+ Only a new line needs a bundle. A newer release inside a served line —
+ MariaDB 13.2 against our 13.0 client, MySQL 26.10 against our 26.7 one —
+ keeps working, and the bundle is refreshed when there is a reason to.
+ MariaDB's modern client additionally serves every line from 10.2 up by
+ designation, which is recorded in `README.md` in this directory.
+- [ ] **Is the release line one upstream still patches?** Short-term and
+ innovation releases live about a quarter. Prefer the long-term release of
+ that era; bundle a short-term release only when users run it. When a line
+ we bundle later gets a long-term release, refresh the bundle to it rather
+ than adding an identity.
+- [ ] **Do binaries exist for both architectures?** Check, in order: the
+ vendor's architecture-independent tarball, the vendor's Debian
+ repository, the vendor's Ubuntu repository, then RPMs for an older
+ enterprise distribution. Do not conclude a build is unavailable after
+ checking one of them.
+- [ ] **Will the binary start in the runtime image?** The image is
+ `debian:bookworm-slim` with glibc 2.36. Compare with
+ `objdump -T <binary> | grep -oE 'GLIBC_2\.[0-9]+' | sort -uV | tail -1`
+ and list the shared libraries with `objdump -p <binary> | grep NEEDED`.
+ Every library must already be in the image; see the table in
+ `README.md` in this directory.
+- [ ] **Know which of the two identity shapes the engine uses.** MySQL's
+ identity doubles as the name of its bundle directory, because each MySQL
+ line gets a client of its own. MariaDB keeps two values, a server
+ identity and a client version, because one client serves many server
+ lines. Follow the engine's existing shape rather than introducing the
+ other one, and never record a version the server did not report.
+- [ ] **Add the bundle and the identity together.** The new directory goes into
+ the bundle set the startup check walks, in
+ `backend/internal/util/tools/mysql.go` or `mariadb.go`, and the identity
+ it serves is mapped to it. Detection refuses any version with no bundle,
+ so these two land in one change or the version stays unsupported.
+- [ ] **Check both architectures before claiming the version is supported.**
+ A version whose client exists for only one architecture is supported only
+ there, and is refused on the other. `assets/tools/arm/mysql/` has no 5.7
+ bundle for that reason.
+- [ ] **Do not look for version tables to extend; there are none left.** The
+ restore downgrade order is computed from the numbers in the identity, the
+ MySQL compression choice is derived from the identity rather than matched
+ against a list of known ones, and the interface renders the identity
+ string itself. All three used to be lookup tables whose missing entry
+ changed behavior quietly. If you find yourself adding a version to a
+ table, the table is the bug.
+- [ ] **An identity names a line, so its digits are not a promise about the
+ binary.** Identity `26` covers every MySQL 26.x and `13.0` every MariaDB
+ 13.x, while the bundle holds one patch. That is intended. What is not
+ intended is a bundle holding a version from a *different* line, which the
+ startup check now rejects.
+- [ ] **Add the identity constant on both sides.** The backend constant and the
+ one in `frontend/src/entity/databases/model/<engine>/` name the same
+ value, and the enumeration is the type of the field, so a missing
+ constant is a build error rather than a blank field.
+- [ ] **Add the version to the test matrices.** A unit test of the version
+ mapping proves nothing about a dump. The matrices in
+ `backend/internal/features/databases/databases/<engine>/model_test.go`
+ and `backend/internal/features/tests/logical/<engine>/backup_restore_test.go`
+ boot a real server of each version.
+- [ ] **Update the supported-version lists** in the root `README.md` and in all
+ five copies under `assets/readme/`, and the tables in `README.md` in this
+ directory. `assets/readme/AGENTS.md` requires every copy to follow the
+ English file.
+
+## Refreshing a patch level
+
+Refreshing is lower risk than adding a version, but it changes the client for
+every server already using that bundle, so it is not a silent operation.
+
+- [ ] Keep every binary within one bundle on the same upstream build. A
+ `pg_dump` older than its sibling `pg_basebackup` is how issue #725
+ survived unnoticed.
+- [ ] Pin the exact upstream package version in the refresh script. Installing
+ "the newest patch of this line" makes the result depend on the day it
+ ran, and two architectures refreshed a week apart then disagree.
+- [ ] Refresh both architectures from the same upstream source in the same
+ change. Mixing sources is how one directory name comes to mean two
+ different builds, and the difference surfaces as an engine-specific
+ dump failure on one architecture only.
+- [ ] Run the refreshed binary in the runtime base image before committing:
+
+ docker run --rm --platform linux/amd64 -v "$PWD/assets/tools:/tools:ro" \
+ debian:bookworm-slim bash -c 'apt-get update -qq && \
+ apt-get install -y -qq libedit2 libncurses6 libtinfo6 libssl3 >/dev/null && \
+ /tools/x64/<engine>/<bundle>/bin/<command> --version'
+
+- [ ] Confirm the executable bit is recorded in the index. `git ls-files -s`
+ must show `100755`; a binary committed as `100644` fails at runtime and
+ not at build time.
+- [ ] Run the engine's whole matrix, not only the refreshed version. A refresh
+ changes the client for every server on that bundle.
+- [ ] Record the new patch and its download source in the tables in
+ `README.md` in this directory, in the same change.
+
+## What not to do here
+
+- Do not install client binaries in the `Dockerfile`. ADR-0005 rejected that.
+- Do not add a shared library to the runtime image only to satisfy one client
+ when a build against the libraries already present exists.
+- Do not trust a directory name while you are building the bundle. Confirm
+ what a binary is by running `--version`, or by reading its version string
+ when the architecture cannot be executed locally. The startup check does
+ compare the two — it runs every client's version flag and rejects a bundle
+ whose version belongs to another line — but it is the last net, not the
+ first. Note that `mariadb-dump --version` prints two numbers and only the one
+ before `-MariaDB` is the server line; `client 10.19` is the protocol
+ version.
diff --git a/openspec/changes/support-mysql-26-and-mariadb-13/design.md b/openspec/changes/support-mysql-26-and-mariadb-13/design.md
new file mode 100644
index 00000000..61f150b5
--- /dev/null
+++ b/openspec/changes/support-mysql-26-and-mariadb-13/design.md
@@ -0,0 +1,138 @@
+## Context
+
+See proposal.md — Why for the motivation.
+
+Three facts about the current code shape every decision below.
+
+First, MySQL has no separation between the server version and the client bundle. `backend/internal/util/tools/mysql.go:43-50` builds the bundle path by interpolating the stored version into `assets/tools/<arch>/mysql/mysql-<version>/bin`, so the enum value is simultaneously what the user sees and the name of a directory that must exist. MariaDB already separates the two: `MariadbVersion` names the server, `MariadbClientVersion` names the directory, and `GetMariadbClientVersionForServer` (`mariadb.go:57-64`) maps between them.
+
+Second, three call sites read the version through a lookup that has no failure mode. The restore downgrade guard reads a map at `mysql.go:77-83` and `mariadb.go:110-123`, and `restores/service.go:270-293` compares the results, so an absent key yields zero and the comparison silently permits a downgrade. The MySQL compression probe switches on the enum at `backups/backups/usecases/logical/mysql/compression_probe.go:36-53`, and its `default` branch is the MySQL 5.7 path. The frontend label maps in `Show{MySql,MariaDb}SpecificDataComponent.tsx` render an empty string for an unknown key.
+
+Third, a bundle's directory name is not checked against the binary inside it. `assets/tools/arm/mariadb/mariadb-10.6/bin/mariadb` reports `10.11.14-MariaDB`, while its x64 counterpart reports `10.6.21-MariaDB`. That bundle is the legacy tier, which exists precisely because the modern client cannot dump MariaDB 5.5 and 10.1, so on arm64 those two servers are served by a client that has the defect the tier was created to avoid. `checkBinDir` (`common.go:30-55`) cannot see this: it stats files.
+
+Constraints from the module docs: `backend/AGENTS.md` and the root `AGENTS.md` require intent-revealing names, forbid issue numbers in production code outside tests that pin an issue's behavior, and forbid unrequested backward-compatibility shims. `frontend/AGENTS.md` keeps every user-visible string in the interface dictionaries. ADR-0005 fixes the vendoring approach for client binaries, so new clients are committed under `assets/` rather than installed during the image build.
+
+The runtime image is `debian:bookworm-slim` with glibc 2.36 (`Dockerfile:100`), and it installs `ca-certificates gosu libncurses5 libncurses6 libmariadb3 libgnutls30` plus `postgresql-17` from the PostgreSQL project's repository.
+
+## Goals / Non-Goals
+
+**Goals:**
+
+- No server dumped by a client from an older release line, on either engine. Inside one line the client may trail the server by a minor; the vendors keep a line compatible with itself, and a bundle refresh closes the gap when it matters.
+- A server we cannot serve refused where the user sees it — at the connection test — rather than at the first backup.
+- Every client bundle exercised against a real server that selects it, not only against a unit test of the mapping. That includes the legacy MariaDB tier, which no test reaches today.
+- Adding the next release line reduced to a short, written procedure, so the recurring cost of this policy stays small.
+
+**Non-Goals:**
+
+- Recording the server's exact version. Identity stays at the release-line granularity the client choice needs, so MariaDB 13.0 and 13.2 record the same identity and use the same bundle, while MySQL 8.0 and 8.4 stay apart because they are separate lines.
+- Any change to how PostgreSQL or MongoDB clients are chosen.
+- Serving a release line we ship no client for. That is the case this design refuses; the client arrives with the next change.
+
+## Decisions
+
+### Keep the MySQL identity as its bundle name, and decide acceptance from the bundle present on this architecture
+
+MySQL keeps one value that names both the server's release line and the directory its client lives in, as it does today. A new line means a new identity and a new directory with the same name. MariaDB keeps its existing pair of types, because several MariaDB lines legitimately share one client: 5.5 and 10.1 need the legacy client, and everything from 10.2 up is served by one modern client.
+
+Introducing a client-version type for MySQL as well was considered and rejected. It exists to let one bundle serve several identities, and under the decision below every MySQL line gets its own bundle, so the second type would carry no information. If a future release does need one bundle to serve two MySQL lines, that is the change that should introduce the type.
+
+Acceptance is decided per architecture, from the bundle actually present. This matters today: `assets/tools/arm/mysql/` has no 5.7 bundle, because upstream never shipped a 5.7 client for arm64, so a MySQL 5.7 server on an arm64 deployment resolves to a path that does not exist and fails when a backup runs. Under this decision it is refused at the connection test instead, with a message that names the architecture as the reason.
+
+### Accept a server whose release line we ship a client for, refuse one we do not
+
+A server is accepted when the product ships a client designated to serve that server's release line, and refused otherwise with a message naming the lines it does support. Designated does not mean built for that line: the modern MariaDB client is designated for every line from 10.2 up, and the legacy one for the lines it cannot dump. What the designation may never be is a client from a line older than the server's. Adding support for a new upstream line means adding its client bundle and its version identity together, in one change.
+
+**The line is the unit, not the patch and not the minor.** A line is the set of versions the vendor numbers together, which is what the existing identities already encode: MySQL 8 is two lines, `8.0` and `8.4`; MariaDB 10 is several, down to `10.6` and `10.11`; MySQL 9 and 26 are one line each, and so is MariaDB 12 and MariaDB 13. Inside a line the bundled client may trail the server:
+
+- MariaDB 13.0.2 client, MariaDB 13.2 server → accepted. Same line, and the bundle is refreshed to 13.2 when there is a reason to.
+- MariaDB 13.4 client, MariaDB 14.1 server → refused. There is no MariaDB 14 bundle, so the connection test fails and names the lines we serve.
+- MySQL 26.7.0 client, MySQL 26.10 server → accepted, for the same reason as the first case.
+
+Refusing a minor inside a served line was considered and rejected. It would turn every quarterly rolling release into a hard outage for users who upgrade before we ship, in exchange for a guarantee the vendors already give inside a line: a 13.x client understands 13.x syntax. The failure this design actually guards against is a *line* boundary, where the server has features the client's generation never saw.
+
+The alternative at the other end is forward compatibility across lines: accept a major above the newest client and dump it with the newest client we have. It was measured and it works on the cases tested — the bundled 9.5.0 client dumped a MySQL 26.7.0 server and the dump restored cleanly, and the bundled 12.1.2 client did the same against MariaDB 13.0.2 — but measurement on a sample schema is not the guarantee a backup product needs. Neither vendor supports a client older than the server's line, so a feature introduced after the client would be dumped by a program that has never heard of it, and the result is a backup that looks successful and restores wrong. A refusal at the connection test costs the user a wait for the next release; a silently incomplete dump costs them the data they thought they had.
+
+Pull request #787 sits at the far end of that trade: it maps every major from 9 upward onto the identity `9`, so a 26.7 server is dumped by the 9.x client, displayed as MySQL 9, and treated as equal to 9 by the downgrade guard.
+
+Minor mapping inside the older majors is left exactly as it is (`mapMysql8xVersion`, `mapMariadb10xVersion`, `mapMariadb11xVersion`): each falls through to the newest line of that major. Those majors are closed — 8.4, 10.11 and 11.8 are the last lines their majors will have — so the fallthrough has nothing left to mis-route, and rewriting it would be churn.
+
+The cost of this decision is a recurring one, and it is accepted deliberately: each upstream line that users adopt needs a change here, and users on that line see an error until it ships. `assets/tools/AGENTS.md` carries the checklist for it, and the cheaper case — a new minor inside a line we serve — needs nothing at all until we choose to refresh.
+
+### Bundle a MariaDB 13 client from the vendor's Ubuntu jammy build
+
+MariaDB's 13.0 repository for Debian bookworm carries only `ppc64el` (its `dists/bookworm/Release` lists no other architecture), and the 13.0 packages for amd64 and arm64 appear under trixie. The architecture-independent tarball exists only for x86_64. The vendor's Ubuntu repository does publish 13.0.2 for jammy and noble on both amd64 and arm64: `dists/jammy/Release` lists `amd64 arm64 ppc64el s390x`, and `mariadb-dump` ships in `mariadb-client`, `mariadb` in `mariadb-client-core`.
+
+The jammy arm64 build of `mariadb-dump` needs at most glibc 2.34 and links exactly the libraries the arm64 MariaDB 12.1 client we already ship links: `libssl.so.3`, `libcrypto.so.3`, `libz.so.1`, `libstdc++.so.6`, `libgcc_s.so.1`, `libc.so.6`. The runtime image provides all of them at glibc 2.36, so this build runs where the current one runs.
+
+Alternatives: the trixie packages need glibc 2.41 and would not start in the runtime image; building from source in a bookworm container works but adds a source build to the release path for no benefit over an official binary; AlmaLinux 8 aarch64 RPMs are a viable fallback, recorded in the documentation, because their glibc floor is older still.
+
+### Move the modern MariaDB client to 12.3 and make the tiers three
+
+Replace the 12.1 bundle with 12.3, the long-term release of that era — the vendor's `lts` tag points at 12.3 — and add 13.0 as a third tier. Servers on 5.5 and 10.1 keep the legacy client, servers from 10.2 through 12.x get 12.3, and servers on 13.x get 13.0.
+
+Keeping 12.1 was rejected because its line stopped receiving patches in February 2026. Collapsing 13.x onto the 12.3 client was rejected because a client for 13 is available for both architectures, so there is no reason to accept a client from an older line here while insisting on a matching one for MySQL.
+
+The legacy tier is rebuilt rather than left alone. It is the tier that exists because the modern client queries `generation_expression`, which MariaDB added in 10.2, and on arm64 it currently holds a 10.11 client — a binary with exactly the defect the tier avoids, so MariaDB 5.5 and 10.1 on arm64 are effectively unserved today. Refreshing both architectures to 10.6.28 from one source fixes that, and the new `mariadb:5.5` and `mariadb:10.1` matrix cases are what keep it fixed: without them the tier has no test at all, which is how the wrong binary went unnoticed.
+
+### Render the version identity instead of looking it up
+
+Display the recorded identity string directly in the database view and delete the label maps in `Show{MySql,MariaDb}SpecificDataComponent.tsx`.
+
+The maps are pure indirection: every entry maps an identity to itself, so `'11.8'` is looked up to produce `'11.8'` (`ShowMariaDbSpecificDataComponent.tsx:15-27`). Their only effect is that an identity missing from the object renders as an empty string, which is how a forgotten entry becomes a blank version field instead of a build error.
+
+Extending the maps with the two new identities was rejected because it keeps a structure whose sole behavior is to fail quietly when someone forgets it, in exchange for nothing. The enumeration of identities stays as the type of the field: the set of identities is closed, since one is added with each bundle, so the type can state it.
+
+### Make the startup check run each client and compare what it prints with the bundle it sits in
+
+Replace the file-existence and permission check in `checkBinDir` with an execution of each client's version flag, and compare the version string it prints against the name of the bundle directory, keeping the existing fatal and non-fatal tiers.
+
+The present check would pass a client that cannot start. That is not hypothetical: the MariaDB clients built from distribution packages link `libedit.so.2`, which the runtime image does not install directly — it arrives only as a dependency of `postgresql-common`. Any change to the PostgreSQL packages would remove it, and the first symptom today would be a failed restore rather than a failed health check.
+
+Nor would it notice a bundle holding the wrong version, which is the state `assets/tools/arm/mariadb/mariadb-10.6/` is in: a 10.11 client under a directory the code trusts to hold a 10.6 one. Comparing the printed version with the directory name costs one string check and turns that class of mistake into a startup failure. Every bundle name is a prefix of what its binaries print, so the rule is uniform even though the output formats are not:
+
+| bundle | command output (first line) |
+|---|---|
+| `postgresql-17` | `psql (PostgreSQL) 17.10 (Debian 17.10-1.pgdg12+1)` |
+| `mysql-9` | `mysqldump Ver 9.5.0 for Linux on x86_64 (MySQL Community Server - GPL)` |
+| `mariadb-12.1` | `... from 12.1.2-MariaDB, client 10.19 for debian-linux-gnu (x86_64)` |
+| `mongodb` | `mongodump version: 100.16.1` |
+
+The MariaDB line is the trap: it carries two numbers, and the one that matters is the server-line number before `-MariaDB`, not the `client 10.19` protocol version that follows. MongoDB has no version in its directory name, so it is checked for execution only.
+
+**The health endpoint does not re-run the binaries.** `CheckAllClientTools` is called both at startup (`common.go:71`) and from the healthcheck (`healthcheck/service.go:46`), and the container probes that endpoint every 30 seconds with a 5 second timeout (`Dockerfile:204`). Executing every client on each probe means roughly 38 processes — 7 PostgreSQL bundles, two of them with five binaries, plus 5 MySQL, 3 MariaDB and MongoDB — spawned twice a minute, which is how a loaded host starts reporting an unhealthy container for no reason. Execution runs once per process and its verdict is cached; the health endpoint keeps stating that verdict and re-checks only that the files are still present, which is what catches a volume that vanished.
+
+Caching the whole result, files included, was rejected: an unmounted `assets` volume is exactly the degradation the probe exists to surface, and stat is cheap. Running the binaries on a timer inside the process was rejected as well — a bundle cannot change under a running container, and a timer would reintroduce the cost it was meant to avoid.
+
+### Order versions by comparing the numbers in the identity, not by table lookup
+
+Compare two version identities by parsing the numbers they carry and comparing major then minor, and treat an identity whose numbers cannot be parsed as an error the caller must handle rather than as order zero.
+
+The table's failure mode is the bug this closes. An identity absent from the map scores zero, so the comparison concludes the backup is not newer and permits the restore. That is not a hypothetical: the two identities this change adds would each have to be entered into two maps by hand, and nothing fails to compile when they are not.
+
+Parsing the identity removes the table entirely. Every server identity in use — `5.7`, `8.0`, `8.4`, `9` and `26` for MySQL, `5.5` through `12.0` and `13.0` for MariaDB — carries its order in its own digits, and the next one added orders correctly with no further edit. MySQL's calendar majors compare above its 9 line numerically, which matches the release order. An identity with no minor, such as `9` or `26`, parses as minor zero.
+
+Both guard functions gain an error return, so `validateVersionCompatibility` in `restores/service.go:253-293` changes with them: a restore request naming a version the backend cannot parse is refused rather than allowed through a zero comparison. That is the point of the change, and it is the only caller.
+
+The alternative, adding the new identities to the existing maps, fixes this instance and leaves the next one to be found by a user restoring a backup onto an older server.
+
+## Risks / Trade-offs
+
+- A user on a release line newer than our newest client cannot add that database at all until we ship the client → The refusal names the lines we support, so the user knows the cause rather than guessing. A new minor inside a line we already serve does not hit this, which is the common case between our releases; the checklist in `assets/tools/AGENTS.md` keeps the work small for the case that does.
+- MySQL 5.7 is refused on arm64, where upstream never shipped a client → This is already the effective state, since the backup fails when the path does not resolve. The refusal moves the failure to the connection test and names the architecture. The amd64 bundle is unaffected.
+- A client can trail its server inside a line: identity `13.0` covers every 13.x and identity `26` every 26.x, while the bundles hold one patch each → Accepted deliberately, and it is the trade the decision above makes. MariaDB already has a 13.1 release candidate published, so the case is near-term rather than hypothetical. The bound on the exposure is that both clients and servers stay within one vendor generation, and the response is the bundle refresh in `assets/tools/AGENTS.md`. A user who needs a specific new feature dumped correctly needs the refresh, not a different design.
+- The repository grows by roughly 100 MB → ADR-0005 already accepts vendoring as the cost of a reproducible, network-free build. The bundle refresh replaces bytes rather than adding them; only the two new bundles add net weight.
+- Refreshing the MariaDB modern client changes the client for every MariaDB server from 10.2 up, not only for new ones → The matrix covers 10.6, 10.11, 11.4, 11.8 and 12.0 with backup, restore, encryption, exclude-tables and read-only-user cases. It does not boot a 10.2 through 10.5 server, so those identities are covered by the mapping test and by the neighbouring 10.6 case rather than end to end; four more containers on every run buy little against versions that resolve to the same client as 10.6.
+- The legacy MariaDB tier had no test at all, and on arm64 it holds the wrong binary → This change adds `mariadb:5.5` and `mariadb:10.1` to both matrices, so the tier that exists to serve pre-10.2 servers is finally exercised, on the client the refresh installs.
+- Four more database images join a CI run that already pre-pulls about 19 GB and frees space by deleting preinstalled toolchains (`.github/workflows/ci-release.yml:250-256`), and the repository they are checked out beside grows too → Task 1.11 measures both before the change is committed, and extends that cleanup step if the images no longer fit. The suite's own `-timeout 15m` (`backend/Makefile:16`) absorbs the same four container boots, which task 7.2 covers.
+- Four architecture-and-source combinations now exist in the asset tree → Each bundle's source is recorded in `assets/tools/README.md`, and the startup check runs the binaries and compares their version with the bundle name, so a mismatched build fails at startup on the affected architecture.
+- The arm64 MariaDB 13 client was verified by comparing its library and glibc requirements with the shipped 12.1 client, not by executing it, because the development host has no emulation for that architecture → The refreshed startup check runs it on a real arm64 build, and the release pipeline builds both architectures.
+- Running the binaries makes the check sensitive to the host, not only to the image: on a Fedora host the bundled `mariadb` client fails to load `libedit.so.2` and the check would disable MariaDB support, even though `mariadb-dump` itself runs → PostgreSQL, the only fatal tier, links `libreadline.so.8` and starts there, so the process still boots. `backend/Makefile:19-29` already builds a `libedit.so.2` symlink for the test run; a `run-fedora` target gets the same shim, so local development on a non-Debian host is not degraded by a check meant to protect the image.
+
+## Migration Plan
+
+No data migration. Version identities already stored keep resolving to a client, and adding identities does not rewrite existing rows. Three behavior changes reach existing deployments: MariaDB servers from 10.2 up are dumped by the refreshed modern client; MariaDB 5.5 and 10.1 servers on arm64 are dumped by a real 10.6 client instead of the 10.11 binary that bundle holds today; and a MySQL 5.7 database on an arm64 deployment is now refused at the connection test instead of failing at backup time. An arm64 deployment that already stored a MySQL 5.7 database keeps the row — the refusal happens when the connection is tested or the version re-detected — and its backups fail with a message naming the architecture instead of a missing path. A rollback is a revert of the change; a database added on a newly supported version stops passing its connection test on the older build, which is that build's existing behavior for such a server.
+
+## Open Questions
+
+- Whether MySQL will designate a calendar release as long-term, which would make that release the bundle to carry for the line instead of 26.7. This does not change the approach, only which patch the 26 bundle holds, which is a refresh.
diff --git a/openspec/changes/support-mysql-26-and-mariadb-13/proposal.md b/openspec/changes/support-mysql-26-and-mariadb-13/proposal.md
new file mode 100644
index 00000000..c29de0cc
--- /dev/null
+++ b/openspec/changes/support-mysql-26-and-mariadb-13/proposal.md
@@ -0,0 +1,57 @@
+## Why
+
+Databasus refuses to add a MySQL 26.x or MariaDB 13.x database. The connection test fails with `unsupported MySQL major version: 26` (issue #786, reported against Oracle MySQL HeatWave, which already serves `26.7.0-cloud`) and `unsupported MariaDB major version: 13` (issue #795, MariaDB 13.0.2 in Docker). Both engines have released these versions, so anyone on a current server is locked out of backups entirely.
+
+The same investigation surfaced a second problem that no issue reports yet: the client binaries we ship have drifted onto release lines that upstream no longer patches. The MySQL 9 bundle holds `mysqldump` 9.5.0, and the 9.5 line ended in January 2026; the MariaDB modern bundle holds 12.1.2, and the 12.1 line ended in February 2026. Every backup and restore runs through these binaries, so they should sit on lines that still receive fixes.
+
+## What Changes
+
+- Accept MySQL 26.x as a supported server version, mapped to a new bundled MySQL 26 client.
+- Accept MariaDB 13.x as a supported server version, mapped to a new bundled MariaDB 13 client.
+- Keep refusing a server the product ships no client for, and make that refusal honest: a version is supported when a client for that server's release line ships with it, on the architecture in use. A release line is the set of versions the vendor numbers together — `8.0` and `8.4` are separate lines, while every MySQL 26.x belongs to one and every MariaDB 13.x to another. Inside a line the bundled client may sit a minor behind the server, and that gap is closed by refreshing the bundle rather than by refusing the server. A line we ship no client for is refused outright: a MariaDB 14.1 server is rejected, while a MariaDB 13.2 server is accepted by the 13 bundle. A consequence worth stating: MySQL 5.7 on arm64 becomes an explicit refusal at the connection test, because upstream never shipped a 5.7 client for that architecture and the backup fails today when the path does not resolve.
+- Keep the MySQL version identity as the name of its client directory, as today, since every MySQL line gets a client of its own. MariaDB keeps its existing split between server version and client version, because one modern client legitimately serves every line from 10.2 up.
+- Refresh every MySQL and MariaDB client bundle onto the current patch of a line upstream still supports: MySQL 8.0.40 to 8.0.46, 8.4.3 to 8.4.11, 9.5.0 to 9.7.2; MariaDB legacy 10.6.21 to 10.6.28, and the modern bundle from 12.1.2 to 12.3.3, the long-term release of that era.
+- Close three places where an unrecognised version currently changes behavior silently rather than failing: the restore downgrade guard reads a version-order map that returns zero for unknown keys, the MySQL network compression probe falls through to the deprecated `--compress` flag, and the frontend version label map renders an empty string for a version it does not list. The frontend map is removed rather than extended: every entry in it maps an identity to itself, so the view can render the identity directly.
+- Make the startup check run each shipped client and compare the version it prints with the name of the bundle it sits in, rather than only checking that the file is present and executable. The current check would not notice a client that cannot start for want of a shared library, which is the failure mode a new bundle is most likely to introduce, nor a bundle holding a different version than its name claims, which is the state `assets/tools/arm/mariadb/mariadb-10.6/` is in today. The health endpoint keeps reporting that result without re-running the binaries on every probe.
+- Fix the arm64 MariaDB legacy bundle, which holds a 10.11 client under the name `mariadb-10.6`. The legacy tier exists because the modern client queries `generation_expression`, a column MariaDB added in 10.2, so a 10.11 client cannot dump the 5.5 and 10.1 servers that tier is meant to serve. On arm64 those two versions are effectively unsupported today; the refresh in this change gives them a real 10.6 client, and new matrix cases cover them.
+- Extend the MySQL and MariaDB test matrices with real `mysql:26.7` and `mariadb:13.0` containers so the new versions are covered by the same backup, restore, encryption, exclude-tables and read-only-user tests as the existing ones, and add `mariadb:5.5` and `mariadb:10.1` so the legacy client tier is exercised at all.
+- Record how the bundles are built. `assets/tools/README.md` gains the provenance of every bundle and the runtime libraries the binaries need; a new `assets/tools/AGENTS.md` carries the checklist for adding a version and for refreshing a patch level.
+
+No persisted data changes meaning: existing databases keep their stored version values, and no row is rewritten. Three behaviors do change for deployments that already run. MariaDB databases from 10.2 up are dumped by the refreshed modern client rather than by 12.1.2. MariaDB 5.5 and 10.1 databases on arm64 are dumped by a real 10.6 client instead of the 10.11 binary that bundle holds today, which is a fix rather than a regression. And a MySQL 5.7 database on an arm64 deployment stops passing its connection test, because `assets/tools/arm/mysql/` ships only 8.0, 8.4 and 9 — upstream never built a 5.7 client for that architecture. That database cannot be backed up on arm64 today either: the bundle path does not resolve and the backup fails when it runs. The change moves that failure to the connection test and names the architecture, and it does not restore the ability to back such a database up.
+
+## Capabilities
+
+### New Capabilities
+
+- `database-version-support`: which MySQL and MariaDB server versions the system accepts, how a detected server version selects the client used to dump and restore it, and what the system does when it meets a version it does not recognise.
+- `client-tool-bundles`: which database client binaries ship with the product, the guarantee they carry about the server versions they serve, what the health check reports when one is missing, and the libraries they require from the runtime image.
+
+### Modified Capabilities
+
+None. No existing spec under `openspec/specs/` describes version support or bundled client tools.
+
+## Impact
+
+Backend. `backend/internal/util/tools/mysql.go` and `mariadb.go` hold the version enums, the bundle lists the health check walks, the version-order maps behind the restore guard and the client selection for MariaDB. `backend/internal/util/tools/common.go` holds the bundle check itself. `backend/internal/features/databases/databases/mysql/model.go` and `mariadb/model.go` hold the version detection that rejects unknown majors. `backend/internal/features/backups/backups/usecases/logical/mysql/compression_probe.go` switches on the version enum. `backend/internal/features/restores/service.go` calls the two downgrade-guard functions, so it changes with their signatures.
+
+Frontend. The version enums and label maps in `frontend/src/entity/databases/model/{mysql,mariadb}/` and `frontend/src/features/databases/ui/show/Show{MySql,MariaDb}SpecificDataComponent.tsx`.
+
+Assets. New bundles under `assets/tools/{x64,arm}/mysql/` and `assets/tools/{x64,arm}/mariadb/`, plus refreshed contents of the existing ones. This adds roughly 100 MB to the repository, which ADR-0005 already accepts as the cost of vendoring clients instead of installing them at image build time.
+
+Documentation. The supported-version lists in `README.md` and in all five copies under `assets/readme/`, the bundle tables in `assets/tools/README.md`, and the new `assets/tools/AGENTS.md`.
+
+Website. The MySQL landing page states the supported versions in six languages: `website/app/(en)/mysql-backup/page.tsx` and the five copies under `website/app/[lang]/mysql-backup/content/`. They are public claims about what the product supports, so they move with the README.
+
+Tests. `backend/internal/features/tests/logical/{mysql,mariadb}/backup_restore_test.go` and `backend/internal/features/databases/databases/{mysql,mariadb}/model_test.go` carry the version matrices.
+
+Build and CI. `tools/refresh-mariadb-x64-libedit.sh` becomes the script that builds every MariaDB bundle. `backend/Makefile` gains the `libedit.so.2` shim for running the backend on a non-Debian host, now that the startup check executes the clients. `.github/workflows/ci-release.yml` may need more room freed for the four new database images.
+
+The change answers to the root `AGENTS.md`, `backend/AGENTS.md`, `frontend/AGENTS.md`, `website/AGENTS.md` and `assets/readme/AGENTS.md`.
+
+## Out of Scope
+
+- Raising the runtime base image from `debian:bookworm-slim` to trixie. MariaDB's bookworm repository for 13.0 carries only `ppc64el`, but its Ubuntu jammy build satisfies the same library floor as the bundle we already ship on both architectures we run, so the base image does not need to move.
+- PostgreSQL and MongoDB bundles. Their patch levels are current and recorded in `assets/tools/README.md`.
+- Physical backups. MySQL and MariaDB are logical-only in Databasus.
+- Supporting a release line before its client ships. Each upstream line that users adopt is a change of its own: its client bundle and its version identity land together, and until then the connection test refuses that server by design. A new minor inside a line we already serve is not that case — it needs a bundle refresh at most, and it keeps working in the meantime. `assets/tools/AGENTS.md` carries both procedures so the recurring cost stays small.
+- Renaming the version identities already in use. `12.0` names the whole MariaDB 12 line and `9` the whole MySQL 9 line; both are stored in existing rows, and making them consistent with each other is a data migration this change does not need.
diff --git a/openspec/changes/support-mysql-26-and-mariadb-13/specs/client-tool-bundles/spec.md b/openspec/changes/support-mysql-26-and-mariadb-13/specs/client-tool-bundles/spec.md
new file mode 100644
index 00000000..4ae10b6a
--- /dev/null
+++ b/openspec/changes/support-mysql-26-and-mariadb-13/specs/client-tool-bundles/spec.md
@@ -0,0 +1,90 @@
+## Purpose
+
+Defines the database client programs that ship inside the product, what the system guarantees about the server versions they can serve, and how a missing or unusable client becomes visible to an operator instead of surfacing as a failed backup.
+
+## ADDED Requirements
+
+### Requirement: Every accepted version identity has a designated client on every supported architecture
+
+The system SHALL ship, for each processor architecture it runs on, a client designated to dump and restore every MySQL and MariaDB version identity it accepts. The designated client is either the one built for that identity's own release line, or a client from another line documented as serving it — a newer one, as the modern MariaDB client serves every line from 10.2 up, or an older one, as the legacy MariaDB client serves the lines the modern client cannot dump. A designated client MAY trail the server inside a single release line, and SHALL never come from a line older than the server's own.
+
+#### Scenario: Start on a supported architecture
+
+- **WHEN** the product starts on either supported architecture
+- **THEN** it reports each expected client set as verified, except for a client set documented as unavailable on that architecture
+
+#### Scenario: A version identity served by a newer client
+
+- **WHEN** a version identity has no client built specifically for it and a newer shipped client is designated to serve it
+- **THEN** the system serves it with that client, and the designation is recorded in the client documentation
+
+#### Scenario: A version identity served by an older client on purpose
+
+- **WHEN** a version identity exists for servers a newer client cannot dump, as MariaDB 5.5 and 10.1 need a client older than 10.2
+- **THEN** the product ships a client from a line that can dump them on every architecture, and that client is used for those identities
+
+#### Scenario: An architecture with no client for a version identity
+
+- **WHEN** an architecture ships no client able to serve a version identity, as arm64 ships none for MySQL 5.7
+- **THEN** that identity is unsupported on that architecture and a server reporting it is refused rather than attempted
+
+### Requirement: Shipped clients stay on a maintained release line
+
+The system SHALL ship clients from a release line that the vendor still patches, or, when the line has reached its end of life, from the final patch that line received.
+
+#### Scenario: A line the vendor still patches
+
+- **WHEN** a client is shipped for a line the vendor still supports
+- **THEN** it is the newest patch released for that line at the time the change ships
+
+#### Scenario: A line that has ended
+
+- **WHEN** a client is shipped for a line whose upstream support has ended, because servers on that line are still in use
+- **THEN** it is the last patch that line received
+
+### Requirement: A client that cannot run is reported at startup
+
+The startup check SHALL confirm that each shipped client can actually execute in the runtime environment, not only that its file is present and executable, so that a missing shared library is reported before a backup needs it. The health check SHALL report that result without running the clients again, so that repeated probing does not depend on starting every client binary.
+
+#### Scenario: A client whose shared library is absent
+
+- **WHEN** a shipped client cannot start because a shared library it needs is absent from the runtime environment
+- **THEN** the check reports that client as failed, naming the client and the reason
+
+#### Scenario: A client that runs
+
+- **WHEN** a shipped client starts and reports its own version
+- **THEN** the check reports that client as verified
+
+#### Scenario: Repeated health probes
+
+- **WHEN** the health check runs repeatedly while the product is up
+- **THEN** it reports the startup verdict for each client together with a fresh confirmation that the client files are still present
+
+### Requirement: A client set holds the version it is named for
+
+The startup check SHALL compare the version each client reports with the release line that client set is registered under, and SHALL report a mismatch as a failure, so that a client set cannot silently hold a different version than the one the system selects it for.
+
+#### Scenario: A client set holding a different version
+
+- **WHEN** a client set registered for one release line contains a client that reports a version from another line
+- **THEN** the check reports that client set as failed, naming the line expected and the version found
+
+#### Scenario: A client set holding a later patch of its own line
+
+- **WHEN** a client set registered for a release line contains a client reporting a later patch or minor of that same line
+- **THEN** the check reports that client set as verified
+
+### Requirement: A missing client disables its engine without stopping the product
+
+The system SHALL treat a missing or unusable MySQL, MariaDB or MongoDB client as a warning that disables backups for the affected version, and SHALL treat a missing or unusable PostgreSQL client as fatal.
+
+#### Scenario: MySQL client set is missing
+
+- **WHEN** a MySQL client set is missing at startup
+- **THEN** the product starts, logs a warning naming the client set, and keeps serving databases of other engines
+
+#### Scenario: PostgreSQL client set is missing
+
+- **WHEN** a PostgreSQL client set is missing at startup
+- **THEN** the product reports the failure and exits
diff --git a/openspec/changes/support-mysql-26-and-mariadb-13/specs/database-version-support/spec.md b/openspec/changes/support-mysql-26-and-mariadb-13/specs/database-version-support/spec.md
new file mode 100644
index 00000000..3d29136c
--- /dev/null
+++ b/openspec/changes/support-mysql-26-and-mariadb-13/specs/database-version-support/spec.md
@@ -0,0 +1,138 @@
+## Purpose
+
+Defines which MySQL and MariaDB server versions Databasus accepts for backup, how the version it detects governs the tooling and the safety checks applied to that database, and how it behaves when it meets a server it ships no client for.
+
+## ADDED Requirements
+
+### Requirement: Supported MySQL server versions are accepted
+
+The system SHALL accept a MySQL server reporting major version 5, 8, 9 or 26 when it ships a client for that server's release line on the running architecture, and SHALL record a version identity that names the line the server belongs to rather than its exact version.
+
+#### Scenario: Add a MySQL server on a previously supported line
+
+- **WHEN** an authorized user tests the connection to a reachable MySQL server reporting version 5.7, 8.0, 8.4 or 9.x with sufficient backup privileges
+- **THEN** the connection test succeeds and the database records the matching version identity
+
+#### Scenario: Add a MySQL server on the calendar scheme
+
+- **WHEN** an authorized user tests the connection to a reachable MySQL server reporting version 26.7 with sufficient backup privileges
+- **THEN** the connection test succeeds and the database records a version identity of 26 rather than the identity of an earlier line
+
+#### Scenario: A later release inside the calendar line
+
+- **WHEN** an authorized user tests the connection to a MySQL server on a release later than the newest 26.x client the product ships, while still inside the 26 line
+- **THEN** the connection test succeeds, the database records the identity 26, and the shipped 26 client is used
+
+#### Scenario: Managed MySQL reporting a vendor suffix
+
+- **WHEN** the MySQL server reports its version with a vendor suffix, such as `26.7.0-cloud` on a managed instance
+- **THEN** the system reads the version from the leading numbers and accepts the server
+
+### Requirement: Supported MariaDB server versions are accepted
+
+The system SHALL accept a MariaDB server reporting major version 5, 10, 11, 12 or 13, and SHALL record a version identity that names the line the server belongs to rather than its exact version.
+
+#### Scenario: Add a MariaDB 13 server
+
+- **WHEN** an authorized user tests the connection to a reachable MariaDB server reporting version 13.0 with sufficient backup privileges
+- **THEN** the connection test succeeds and the database records a version identity of 13.0
+
+#### Scenario: A later minor inside the MariaDB 13 line
+
+- **WHEN** an authorized user tests the connection to a MariaDB server reporting a 13.x version later than the client the product ships for that line, such as 13.2 against a 13.0 client
+- **THEN** the connection test succeeds and the server is served by the shipped 13 client, because the client and the server belong to the same release line
+
+#### Scenario: Add a MariaDB server on a previously supported line
+
+- **WHEN** an authorized user tests the connection to a reachable MariaDB server reporting version 5.5, 10.x, 11.x or 12.x with sufficient backup privileges
+- **THEN** the connection test succeeds and the database records the matching version identity
+
+### Requirement: A server on an unserved release line is refused, never dumped by a client from an older line
+
+The system SHALL refuse a MySQL or MariaDB server whose release line no shipped client serves, and SHALL never dump such a server with a client from an earlier line, so that no backup is produced by a program from a generation that does not know the server's features. Within one release line the client may be older than the server: that gap is closed by refreshing the bundle, not by refusing the database.
+
+#### Scenario: Server on a release line the product ships no client for
+
+- **WHEN** an authorized user tests the connection to a reachable MySQL or MariaDB server whose release line is newer than every line the product ships a client for, such as a MariaDB 14.1 server while the newest MariaDB client serves the 13 line
+- **THEN** the connection test fails, names the versions the product supports, and no database is added
+
+#### Scenario: Server ahead of its client inside a served line
+
+- **WHEN** an authorized user tests the connection to a server whose release line is served but whose own version is newer than the client shipped for that line, such as a MariaDB 13.2 server against a 13.0 client
+- **THEN** the connection test succeeds and the database is served by that line's client
+
+#### Scenario: Release line whose client exists on one architecture only
+
+- **WHEN** an authorized user tests the connection to a server whose client is absent for the architecture the product runs on, such as MySQL 5.7 on an arm64 deployment
+- **THEN** the connection test fails and reports that this version is unsupported on this architecture
+
+#### Scenario: A database recorded before its client became unavailable
+
+- **WHEN** a backup starts for a database whose recorded version has no client on the architecture the product now runs on
+- **THEN** the backup fails with a message naming the version and the architecture, rather than with a missing-file error
+
+#### Scenario: A newer client serves an older line by design
+
+- **WHEN** a server's release line has no client of its own but a newer shipped client is designated to serve that line, as the modern MariaDB client serves every line from 10.2 up
+- **THEN** the server is accepted and that client is used
+
+### Requirement: An unusable server is rejected with a reason
+
+The system SHALL refuse a server it cannot serve and SHALL name what it found, so that the user can correct the choice rather than discover the problem when a backup fails.
+
+#### Scenario: MariaDB server added under the MySQL type
+
+- **WHEN** an authorized user tests a connection to a MariaDB server while the database type is MySQL
+- **THEN** the connection test fails, reports the version it found and directs the user to the MariaDB type
+
+#### Scenario: Version string cannot be read
+
+- **WHEN** the server answers the version query with a value the system cannot parse
+- **THEN** the connection test fails and reports the value it received
+
+#### Scenario: MySQL major below the supported range
+
+- **WHEN** a MySQL server reports a major version below 5
+- **THEN** the connection test fails and names the versions the system supports
+
+#### Scenario: MariaDB major below the supported range
+
+- **WHEN** a MariaDB server reports a major version below 5
+- **THEN** the connection test fails and names the versions the system supports
+
+### Requirement: The downgrade guard covers every accepted version
+
+The system SHALL refuse to restore a backup taken from a newer server onto an older server for every MySQL and MariaDB version it accepts, including versions added after the guard was written.
+
+#### Scenario: Restore a calendar-scheme MySQL backup onto an earlier line
+
+- **WHEN** an authorized user requests a restore of a backup taken from a MySQL 26.x server onto a MySQL 9.x or 8.x server
+- **THEN** the system refuses the restore and explains that the backup comes from a newer server
+
+#### Scenario: Restore a MariaDB 13 backup onto MariaDB 12
+
+- **WHEN** an authorized user requests a restore of a backup taken from a MariaDB 13.x server onto a MariaDB 12.x server
+- **THEN** the system refuses the restore and explains that the backup comes from a newer server
+
+#### Scenario: Restore onto an equal or newer server
+
+- **WHEN** an authorized user requests a restore of a backup onto a server of the same or a newer version identity
+- **THEN** the system allows the restore
+
+### Requirement: Backups of new versions use the modern transfer settings
+
+The system SHALL apply the same network compression negotiation to newly supported MySQL versions as it applies to MySQL 8.0 and later, rather than falling back to the legacy setting reserved for MySQL 5.7.
+
+#### Scenario: Back up a calendar-scheme MySQL server
+
+- **WHEN** a backup of a MySQL 26.x database starts
+- **THEN** the system negotiates compression from the modern algorithm set and falls back through it to an uncompressed transfer if the server or its proxy refuses
+
+### Requirement: The displayed version is never blank
+
+The system SHALL display a version for every MySQL and MariaDB database it accepted, for every version identity it can record.
+
+#### Scenario: View a database on a newly supported version
+
+- **WHEN** an authorized user views a MySQL 26.x or MariaDB 13.x database
+- **THEN** the version field shows that version rather than an empty value
diff --git a/openspec/changes/support-mysql-26-and-mariadb-13/tasks.md b/openspec/changes/support-mysql-26-and-mariadb-13/tasks.md
new file mode 100644
index 00000000..7b8cc780
--- /dev/null
+++ b/openspec/changes/support-mysql-26-and-mariadb-13/tasks.md
@@ -0,0 +1,70 @@
+## 1. Client bundles
+
+Every bundle task lands both architectures of one bundle, then verifies the binaries by running them inside the runtime base image. The verification command for an amd64 tree is:
+
+```
+docker run --rm --platform linux/amd64 -v "$PWD/assets/tools:/tools:ro" debian:bookworm-slim \
+ bash -c 'apt-get update -qq && apt-get install -y -qq libedit2 libncurses6 libtinfo6 libssl3 >/dev/null && \
+ /tools/x64/<engine>/<bundle>/bin/<command> --version'
+```
+
+The arm64 tree cannot be executed on an amd64 host without emulation; tasks 3.1 and 3.2 make the product itself verify it at startup on a real arm64 build.
+
+- [x] 1.1 Add `assets/tools/{x64,arm}/mysql/mysql-26/bin/{mysql,mysqldump}` from `https://cdn.mysql.com/Downloads/MySQL-26.7/mysql-26.7.0-linux-glibc2.28-{x86_64,aarch64}.tar.xz`, strip the binaries, and verify the x64 pair reports `26.7.0` under the command above
+- [x] 1.2 Refresh `assets/tools/{x64,arm}/mysql/mysql-9/bin/` from `mysql-9.7.2-linux-glibc2.28-{x86_64,aarch64}.tar.xz` at the same download host, and verify the x64 pair reports `9.7.2`
+- [x] 1.3 Refresh `assets/tools/{x64,arm}/mysql/mysql-8.4/bin/` from `mysql-8.4.11-...` and `mysql-8.0/bin/` from `mysql-8.0.46-...`, and verify each x64 pair reports its new patch
+- [x] 1.4 Confirm `mysql-5.7` already carries 5.7.44, the final patch of that line, and leave it unchanged; record the check in `assets/tools/README.md` rather than touching the binaries
+- [x] 1.5 Add `assets/tools/{x64,arm}/mariadb/mariadb-13.0/bin/{mariadb,mariadb-dump}` from the vendor's Ubuntu jammy packages `https://mirror.mariadb.org/repo/13.0/ubuntu/pool/main/m/mariadb/mariadb-client{,-core}_13.0.2+maria~ubu2204_{amd64,arm64}.deb` — `mariadb-dump` ships in `mariadb-client`, `mariadb` in `mariadb-client-core` — and verify the x64 pair reports `13.0.2-MariaDB`
+- [x] 1.6 Replace `assets/tools/{x64,arm}/mariadb/mariadb-12.1/` with `mariadb-12.3/` built from `https://mirror.mariadb.org/repo/12.3/debian/` for bookworm on both architectures, and verify the x64 pair reports `12.3.3-MariaDB`
+- [x] 1.7 Refresh `assets/tools/{x64,arm}/mariadb/mariadb-10.6/bin/` to 10.6.28 from `https://mirror.mariadb.org/repo/10.6/ubuntu/` for jammy on both architectures, so both architectures carry the same build; today they do not — the x64 copy comes from the architecture-independent tarball and reports 10.6.21, while the arm copy comes from distribution packaging and carries a 10.11 version string, which the refresh resolves. Verify the x64 pair reports `10.6.28-MariaDB`
+- [x] 1.8 Generalise `tools/refresh-mariadb-x64-libedit.sh` into one script covering tasks 1.5 to 1.7. It takes the exact package version, the vendor repository (Debian bookworm for 12.3, Ubuntu jammy for 13.0 and 10.6) and the target architecture, since those three differ per bundle. Pin the package version rather than installing the newest patch of a line, otherwise the result changes with upstream. For arm64 it downloads the `.deb` and unpacks it with `dpkg-deb -x` instead of `apt-get install` under `--platform linux/arm64`, because the development host has no emulation and unpacking needs none. Verify by re-running it for one already-committed bundle and confirming `sha256sum` matches the committed binaries
+- [x] 1.9 Verify every new and refreshed binary is recorded executable in the index: `git ls-files -s assets/tools | grep -v '^100755' | grep -E 'mysql|mariadb'` prints nothing
+- [x] 1.10 Verify every bundle now holds the version its directory name claims, which `assets/tools/arm/mariadb/mariadb-10.6/` does not today — it reports `10.11.14-MariaDB`. For each bundle, read the version out of the binary (`--version` on x64, `strings` on the arm tree) and confirm it starts with the bundle's line: `mariadb-10.6` → `10.6.x`, `mariadb-12.3` → `12.3.x`, `mariadb-13.0` → `13.0.x`, `mysql-26` → `26.x`
+- [x] 1.11 Measure what the change costs the CI runner before relying on it: `du -sh assets/tools/{x64,arm}` for the tree, and `docker pull` followed by `docker image ls` for `mysql:26.7`, `mariadb:13.0`, `mariadb:5.5` and `mariadb:10.1`. The pre-pull step in `.github/workflows/ci-release.yml:250-256` already frees ~11 GB to fit ~19 GB of images and says the fit is tight; if the new images no longer fit, extend that step's cleanup in the same change
+
+## 2. Version identity and client selection
+
+- [x] 2.1 Add the MySQL 26 identity and its bundle to `backend/internal/util/tools/mysql.go`, and make bundle resolution report whether the bundle for the running architecture is present instead of returning a path that may not exist; verify with `go test ./internal/util/tools/... -count=1`
+- [x] 2.2 Extend MySQL version detection in `backend/internal/features/databases/databases/mysql/model.go` so every 26.x server maps to the 26 identity, whatever its minor, and keep every unserved major refused with a message listing the supported versions. Leave `mapMysql8xVersion` as it is: major 8 is closed at 8.4, so its fallthrough has nothing left to mis-route. Verify with `go test ./internal/features/databases/... -count=1`
+- [x] 2.3 Add the MariaDB 13 server identity and a 13.0 client tier in `tools/mariadb.go`, extend detection in `mariadb/model.go` so every 13.x server maps to the 13.0 identity, and route that identity to the new tier. A 13.2 server is accepted by the 13.0 client because they share a release line; a 14.x server is refused because no 14 client ships. Verify with `go test ./internal/features/databases/... -count=1`
+- [x] 2.4 Refuse a version whose client is absent for the running architecture at the connection test, naming the architecture, which is what MySQL 5.7 on arm64 needs; today that case resolves to a missing path and fails when a backup runs; verify with `go test ./internal/features/databases/... -count=1`
+- [x] 2.5 Replace the version-order maps behind the restore downgrade guard in `tools/mysql.go` and `tools/mariadb.go` with a comparison that parses the numbers in the identity, so a newly added identity orders correctly without a table entry and an unparseable identity returns an error instead of ordering as zero; cover both new identities; verify with `go test ./internal/features/restores/... ./internal/util/tools/... -count=1`
+- [x] 2.6 Extend the compression candidate selection in `backend/internal/features/backups/backups/usecases/logical/mysql/compression_probe.go` so every identity above 5.7 negotiates from the modern algorithm set, and make the 5.7 path explicit rather than a fallthrough; verify with `go test ./internal/features/backups/... -count=1`
+- [x] 2.7 Delete `GetMysqlVersionEnum` and `GetMariadbVersionEnum`, which have no callers anywhere including tests, so the new identities do not have to be added to code nothing reads; verify with `make lint` and `go build ./...`
+
+## 3. Startup and health verification
+
+- [x] 3.1 Change the client check in `backend/internal/util/tools/common.go` to execute each client's version flag instead of only checking presence and the executable bit, keeping the existing fatal tier for PostgreSQL and the warning tier for the others; verify with `go test ./internal/util/tools/... -count=1` and by starting the backend with a bundle directory temporarily renamed, which must produce a warning naming that bundle
+- [x] 3.2 Compare the version each client prints with the release line its bundle is registered under, and report a mismatch as a failure of that bundle. The output formats differ per engine and the MariaDB one carries two numbers — `mariadb-dump ... from 12.1.2-MariaDB, client 10.19 ...`, where the bundle's line is the one before `-MariaDB` — so parse per engine rather than taking the first number found. Verify with `go test ./internal/util/tools/... -count=1`, including a case that pins a bundle holding a foreign version as a failure
+- [x] 3.3 Keep the execution and version comparison to once per process and have `ClientToolsHealthError` report the cached verdict, re-checking only that the files are still present. The container probes the endpoint every 30 seconds with a 5 second timeout (`Dockerfile:204`), and running roughly 38 client binaries per probe is how a loaded host reports a false unhealthy. Verify with `go test ./internal/util/tools/... -count=1` and by confirming that deleting a bundle directory under a running backend still degrades the health endpoint
+- [x] 3.4 Add the new bundles to the lists the check walks in `tools/mysql.go` and `tools/mariadb.go`, and confirm a clean start reports every bundle verified
+- [x] 3.5 Extend the `libedit.so.2` shim in `backend/Makefile:19-29` from `test-fedora` to a `run-fedora` target, since running the binaries makes the check fail for the MariaDB clients on a host that ships `libedit.so.0`; verify by starting the backend on such a host and seeing MariaDB reported as verified rather than disabled
+
+## 4. Frontend
+
+- [x] 4.1 Delete the version label maps in `frontend/src/features/databases/ui/show/Show{MySql,MariaDb}SpecificDataComponent.tsx` and render the recorded identity string directly, so an identity the release does not know about displays as itself rather than as an empty value; verify with `pnpm lint`, `pnpm test` and `pnpm build` in `frontend/`
+- [x] 4.2 Add the new identities to `frontend/src/entity/databases/model/mysql/MysqlVersion.ts` and `mariadb/MariadbVersion.ts`, keeping the enumeration as the type of the version field since the set of identities is closed; verify with `pnpm lint` and `pnpm build` in `frontend/`
+- [x] 4.3 Confirm the two new identities survive the whole path: add a MySQL 26 database and a MariaDB 13 database against real servers and confirm each view shows its version rather than an empty field. The version field is an unconstrained string in the API schema, so `make swagger` has nothing to regenerate here
+
+## 5. Tests against real servers
+
+- [x] 5.1 Add `mysql:26.7` to the matrix in `backend/internal/features/databases/databases/mysql/model_test.go` and `mariadb:13.0` to `mariadb/model_test.go`, covering connection, privilege detection and read-only user creation; verify with `go test ./internal/features/databases/... -count=1`
+- [x] 5.2 Add the same two images to the backup and restore matrices in `backend/internal/features/tests/logical/{mysql,mariadb}/backup_restore_test.go`, including the encryption, exclude-tables and read-only-user cases the neighbouring versions run; verify with `go test ./internal/features/tests/logical/mysql/... ./internal/features/tests/logical/mariadb/... -count=1`
+- [x] 5.3 Add `mariadb:5.5` and `mariadb:10.1` to both MariaDB matrices, which today start at 10.6 and therefore never exercise the legacy client tier at all — the tier whose arm64 bundle holds a 10.11 binary. Skip the subtests those servers genuinely cannot run, the way the matrix already gates `runsRoutineGrantTest`, rather than dropping the versions. Verify with `go test ./internal/features/databases/... ./internal/features/tests/logical/mariadb/... -count=1`
+- [x] 5.4 Add cases asserting the refusals on both engines: a MySQL major above 26 and a MariaDB major above 13 are refused with a message listing the supported versions, and a version whose client is absent for the running architecture is refused naming the architecture; verify with `go test ./internal/features/databases/... -count=1`
+- [x] 5.5 Add mapping cases for the other half of the rule: a MariaDB 13.2 server records the 13.0 identity and a MySQL 26.10 server records the 26 identity, so a later release inside a served line stays accepted; verify with `go test ./internal/features/databases/... -count=1`
+- [x] 5.6 Add restore guard cases asserting that a backup from MySQL 26.x is refused onto 9.x and 8.x, and a backup from MariaDB 13.x onto 12.x; verify with `go test ./internal/features/restores/... -count=1`
+- [x] 5.7 Add a case pinning the behavior from issue #786 — a server whose version string carries a vendor suffix such as `26.7.0-cloud` is accepted — which is the one place an issue number belongs in the tests; verify with `go test ./internal/features/databases/... -count=1`
+
+## 6. Documentation
+
+- [x] 6.1 Update `assets/tools/README.md`: the bundle layout and the per-bundle version table for MySQL and MariaDB, the download source of every bundle, the shared libraries the binaries need from the runtime image, and the note that `libedit.so.2` reaches the image only as a dependency of `postgresql-common`
+- [x] 6.2 Add `assets/tools/AGENTS.md` carrying the checklist for adding a new engine version and for refreshing a patch level, using the draft in this change at `assets-tools-agents-draft.md` as the starting content
+- [x] 6.3 Update the supported-version lines in `README.md` and in all five copies `assets/readme/README.{es,fr,pt,ru,zh}.md`, as `assets/readme/AGENTS.md` requires; each list sits at lines 115-116 of its file, and the Chinese copy uses its own list punctuation. Three edits, not one: add the new versions, mark MySQL 5.7 as x86-64 only now that arm64 refuses it, and correct the MariaDB line, which reads "10, 11 and 12" while the product also accepts 5.5
+- [x] 6.4 Update the MySQL landing page on the website, which states the supported versions in six languages: `website/app/(en)/mysql-backup/page.tsx` and the five copies under `website/app/[lang]/mysql-backup/content/`. Each copy repeats the list in five places — the feature bullets, the JSON-LD FAQ entry, the prose in the compatibility section, the per-version cards, and the visible FAQ answer — and `website/AGENTS.md` requires the visible FAQ and its JSON-LD copy to agree, so find them with `grep -rn '5\.7\|MariaDB 1' website/app/*/mysql-backup` rather than by line number. Verify with `npm run lint` and `npm run build` in `website/`, the commands `website/AGENTS.md` names
+
+## 7. Whole-suite verification and review
+
+- [x] 7.1 Run `make lint` for the backend, `pnpm lint` and `pnpm format` in `frontend/`, and `npm run lint` in `website/`, and fix every finding
+- [x] 7.2 Run the whole backend suite once, at the end, with `make test` or `make test-fedora` on a Fedora host, since it recreates the shared containers and database slots other agents draw from. Four new containers join the run against a `-timeout 15m` budget (`backend/Makefile:16`); if the suite now exceeds it, raise the budget in the same change rather than dropping matrix cases
+- [x] 7.3 Resolve every `CHANGES REQUIRED` finding from the mandatory post-implementation review, and leave the working tree ready to commit
diff --git a/openspec/specs/client-tool-bundles/spec.md b/openspec/specs/client-tool-bundles/spec.md
new file mode 100644
index 00000000..218d51c5
--- /dev/null
+++ b/openspec/specs/client-tool-bundles/spec.md
@@ -0,0 +1,92 @@
+# Client Tool Bundles Specification
+
+## Purpose
+
+Defines the database client programs that ship inside the product, what the system guarantees about the server versions they can serve, and how a missing or unusable client becomes visible to an operator instead of surfacing as a failed backup.
+
+## Requirements
+
+### Requirement: Every accepted version identity has a designated client on every supported architecture
+
+The system SHALL ship, for each processor architecture it runs on, a client designated to dump and restore every MySQL and MariaDB version identity it accepts. The designated client is either the one built for that identity's own release line, or a client from another line documented as serving it — a newer one, as the modern MariaDB client serves every line from 10.2 up, or an older one, as the legacy MariaDB client serves the lines the modern client cannot dump. A designated client MAY trail the server inside a single release line, and SHALL never come from a line older than the server's own.
+
+#### Scenario: Start on a supported architecture
+
+- **WHEN** the product starts on either supported architecture
+- **THEN** it reports each expected client set as verified, except for a client set documented as unavailable on that architecture
+
+#### Scenario: A version identity served by a newer client
+
+- **WHEN** a version identity has no client built specifically for it and a newer shipped client is designated to serve it
+- **THEN** the system serves it with that client, and the designation is recorded in the client documentation
+
+#### Scenario: A version identity served by an older client on purpose
+
+- **WHEN** a version identity exists for servers a newer client cannot dump, as MariaDB 5.5 and 10.1 need a client older than 10.2
+- **THEN** the product ships a client from a line that can dump them on every architecture, and that client is used for those identities
+
+#### Scenario: An architecture with no client for a version identity
+
+- **WHEN** an architecture ships no client able to serve a version identity, as arm64 ships none for MySQL 5.7
+- **THEN** that identity is unsupported on that architecture and a server reporting it is refused rather than attempted
+
+### Requirement: Shipped clients stay on a maintained release line
+
+The system SHALL ship clients from a release line that the vendor still patches, or, when the line has reached its end of life, from the final patch that line received.
+
+#### Scenario: A line the vendor still patches
+
+- **WHEN** a client is shipped for a line the vendor still supports
+- **THEN** it is the newest patch released for that line at the time the change ships
+
+#### Scenario: A line that has ended
+
+- **WHEN** a client is shipped for a line whose upstream support has ended, because servers on that line are still in use
+- **THEN** it is the last patch that line received
+
+### Requirement: A client that cannot run is reported at startup
+
+The startup check SHALL confirm that each shipped client can actually execute in the runtime environment, not only that its file is present and executable, so that a missing shared library is reported before a backup needs it. The health check SHALL report that result without running the clients again, so that repeated probing does not depend on starting every client binary.
+
+#### Scenario: A client whose shared library is absent
+
+- **WHEN** a shipped client cannot start because a shared library it needs is absent from the runtime environment
+- **THEN** the check reports that client as failed, naming the client and the reason
+
+#### Scenario: A client that runs
+
+- **WHEN** a shipped client starts and reports its own version
+- **THEN** the check reports that client as verified
+
+#### Scenario: Repeated health probes
+
+- **WHEN** the health check runs repeatedly while the product is up
+- **THEN** it reports the startup verdict for each client together with a fresh confirmation that the client files are still present
+
+### Requirement: A client set holds the version it is named for
+
+The startup check SHALL compare the version each client reports with the release line that client set is registered under, and SHALL report a mismatch as a failure, so that a client set cannot silently hold a different version than the one the system selects it for.
+
+#### Scenario: A client set holding a different version
+
+- **WHEN** a client set registered for one release line contains a client that reports a version from another line
+- **THEN** the check reports that client set as failed, naming the line expected and the version found
+
+#### Scenario: A client set holding a later patch of its own line
+
+- **WHEN** a client set registered for a release line contains a client reporting a later patch or minor of that same line
+- **THEN** the check reports that client set as verified
+
+### Requirement: A missing client disables its engine without stopping the product
+
+The system SHALL treat a missing or unusable MySQL, MariaDB or MongoDB client as a warning that disables backups for the affected version, and SHALL treat a missing or unusable PostgreSQL client as fatal.
+
+#### Scenario: MySQL client set is missing
+
+- **WHEN** a MySQL client set is missing at startup
+- **THEN** the product starts, logs a warning naming the client set, and keeps serving databases of other engines
+
+#### Scenario: PostgreSQL client set is missing
+
+- **WHEN** a PostgreSQL client set is missing at startup
+- **THEN** the product reports the failure and exits
diff --git a/openspec/specs/database-version-support/spec.md b/openspec/specs/database-version-support/spec.md
new file mode 100644
index 00000000..b59a0a02
--- /dev/null
+++ b/openspec/specs/database-version-support/spec.md
@@ -0,0 +1,140 @@
+# Database Version Support Specification
+
+## Purpose
+
+Defines which MySQL and MariaDB server versions Databasus accepts for backup, how the version it detects governs the tooling and the safety checks applied to that database, and how it behaves when it meets a server it ships no client for.
+
+## Requirements
+
+### Requirement: Supported MySQL server versions are accepted
+
+The system SHALL accept a MySQL server reporting major version 5, 8, 9 or 26 when it ships a client for that server's release line on the running architecture, and SHALL record a version identity that names the line the server belongs to rather than its exact version.
+
+#### Scenario: Add a MySQL server on a previously supported line
+
+- **WHEN** an authorized user tests the connection to a reachable MySQL server reporting version 5.7, 8.0, 8.4 or 9.x with sufficient backup privileges
+- **THEN** the connection test succeeds and the database records the matching version identity
+
+#### Scenario: Add a MySQL server on the calendar scheme
+
+- **WHEN** an authorized user tests the connection to a reachable MySQL server reporting version 26.7 with sufficient backup privileges
+- **THEN** the connection test succeeds and the database records a version identity of 26 rather than the identity of an earlier line
+
+#### Scenario: A later release inside the calendar line
+
+- **WHEN** an authorized user tests the connection to a MySQL server on a release later than the newest 26.x client the product ships, while still inside the 26 line
+- **THEN** the connection test succeeds, the database records the identity 26, and the shipped 26 client is used
+
+#### Scenario: Managed MySQL reporting a vendor suffix
+
+- **WHEN** the MySQL server reports its version with a vendor suffix, such as `26.7.0-cloud` on a managed instance
+- **THEN** the system reads the version from the leading numbers and accepts the server
+
+### Requirement: Supported MariaDB server versions are accepted
+
+The system SHALL accept a MariaDB server reporting major version 5, 10, 11, 12 or 13, and SHALL record a version identity that names the line the server belongs to rather than its exact version.
+
+#### Scenario: Add a MariaDB 13 server
+
+- **WHEN** an authorized user tests the connection to a reachable MariaDB server reporting version 13.0 with sufficient backup privileges
+- **THEN** the connection test succeeds and the database records a version identity of 13.0
+
+#### Scenario: A later minor inside the MariaDB 13 line
+
+- **WHEN** an authorized user tests the connection to a MariaDB server reporting a 13.x version later than the client the product ships for that line, such as 13.2 against a 13.0 client
+- **THEN** the connection test succeeds and the server is served by the shipped 13 client, because the client and the server belong to the same release line
+
+#### Scenario: Add a MariaDB server on a previously supported line
+
+- **WHEN** an authorized user tests the connection to a reachable MariaDB server reporting version 5.5, 10.x, 11.x or 12.x with sufficient backup privileges
+- **THEN** the connection test succeeds and the database records the matching version identity
+
+### Requirement: A server on an unserved release line is refused, never dumped by a client from an older line
+
+The system SHALL refuse a MySQL or MariaDB server whose release line no shipped client serves, and SHALL never dump such a server with a client from an earlier line, so that no backup is produced by a program from a generation that does not know the server's features. Within one release line the client may be older than the server: that gap is closed by refreshing the bundle, not by refusing the database.
+
+#### Scenario: Server on a release line the product ships no client for
+
+- **WHEN** an authorized user tests the connection to a reachable MySQL or MariaDB server whose release line is newer than every line the product ships a client for, such as a MariaDB 14.1 server while the newest MariaDB client serves the 13 line
+- **THEN** the connection test fails, names the versions the product supports, and no database is added
+
+#### Scenario: Server ahead of its client inside a served line
+
+- **WHEN** an authorized user tests the connection to a server whose release line is served but whose own version is newer than the client shipped for that line, such as a MariaDB 13.2 server against a 13.0 client
+- **THEN** the connection test succeeds and the database is served by that line's client
+
+#### Scenario: Release line whose client exists on one architecture only
+
+- **WHEN** an authorized user tests the connection to a server whose client is absent for the architecture the product runs on, such as MySQL 5.7 on an arm64 deployment
+- **THEN** the connection test fails and reports that this version is unsupported on this architecture
+
+#### Scenario: A database recorded before its client became unavailable
+
+- **WHEN** a backup starts for a database whose recorded version has no client on the architecture the product now runs on
+- **THEN** the backup fails with a message naming the version and the architecture, rather than with a missing-file error
+
+#### Scenario: A newer client serves an older line by design
+
+- **WHEN** a server's release line has no client of its own but a newer shipped client is designated to serve that line, as the modern MariaDB client serves every line from 10.2 up
+- **THEN** the server is accepted and that client is used
+
+### Requirement: An unusable server is rejected with a reason
+
+The system SHALL refuse a server it cannot serve and SHALL name what it found, so that the user can correct the choice rather than discover the problem when a backup fails.
+
+#### Scenario: MariaDB server added under the MySQL type
+
+- **WHEN** an authorized user tests a connection to a MariaDB server while the database type is MySQL
+- **THEN** the connection test fails, reports the version it found and directs the user to the MariaDB type
+
+#### Scenario: Version string cannot be read
+
+- **WHEN** the server answers the version query with a value the system cannot parse
+- **THEN** the connection test fails and reports the value it received
+
+#### Scenario: MySQL major below the supported range
+
+- **WHEN** a MySQL server reports a major version below 5
+- **THEN** the connection test fails and names the versions the system supports
+
+#### Scenario: MariaDB major below the supported range
+
+- **WHEN** a MariaDB server reports a major version below 5
+- **THEN** the connection test fails and names the versions the system supports
+
+### Requirement: The downgrade guard covers every accepted version
+
+The system SHALL refuse to restore a backup taken from a newer server onto an older server for every MySQL and MariaDB version it accepts, including versions added after the guard was written.
+
+#### Scenario: Restore a calendar-scheme MySQL backup onto an earlier line
+
+- **WHEN** an authorized user requests a restore of a backup taken from a MySQL 26.x server onto a MySQL 9.x or 8.x server
+- **THEN** the system refuses the restore and explains that the backup comes from a newer server
+
+#### Scenario: Restore a MariaDB 13 backup onto MariaDB 12
+
+- **WHEN** an authorized user requests a restore of a backup taken from a MariaDB 13.x server onto a MariaDB 12.x server
+- **THEN** the system refuses the restore and explains that the backup comes from a newer server
+
+#### Scenario: Restore onto an equal or newer server
+
+- **WHEN** an authorized user requests a restore of a backup onto a server of the same or a newer version identity
+- **THEN** the system allows the restore
+
+### Requirement: Backups of new versions use the modern transfer settings
+
+The system SHALL apply the same network compression negotiation to newly supported MySQL versions as it applies to MySQL 8.0 and later, rather than falling back to the legacy setting reserved for MySQL 5.7.
+
+#### Scenario: Back up a calendar-scheme MySQL server
+
+- **WHEN** a backup of a MySQL 26.x database starts
+- **THEN** the system negotiates compression from the modern algorithm set and falls back through it to an uncompressed transfer if the server or its proxy refuses
+
+### Requirement: The displayed version is never blank
+
+The system SHALL display a version for every MySQL and MariaDB database it accepted, for every version identity it can record.
+
+#### Scenario: View a database on a newly supported version
+
+- **WHEN** an authorized user views a MySQL 26.x or MariaDB 13.x database
+- **THEN** the version field shows that version rather than an empty value